Nostr notes by

It will work. It's just being pulled from the app store.

2026-04-06T06:02:12Z

In reply to nevent1q…qfak
_________________________

It will work. It's just being pulled from the app store.

Recently I had an experience with a service where I was a paid ...

2026-04-06T05:58:26Z

Recently I had an experience with a service where I was a paid subscriber. The service decided to artificially limit the features that they had for my tier, and where I go used to them and was glad to pay. The basic thing is, they took away what I already had access to, and locked it behind a new tier. In general I have no issues if free features are gradually adjusted to maintain costs (I understand it’s costly), but I have no mercy for rug pulls like this. If you are the owner of the SaaS, please be considerate and don’t just add features without thinking ahead. Want to charge more, add more to the next tier, make me want to upgrade. Pricing is hard, splitting features is hard, not fucking your customers over is easy. 🫡

Okay, I'll translate that as outboxes being higher. ...

2026-04-06T05:57:25Z

In reply to nevent1q…d3uq
_________________________

Okay, I'll translate that as outboxes being higher. They're supposed to be checked by default, so someone who doesn't care to add more relays doesn't need to do anything. The misordering was a big. I'll fix that.

I hadn't even thought about including sets in the optional relays, just favorites, but that is an obvious one.

I was thinking of adding a full pfp upload algo, yeah. I needed ...

2026-04-06T05:51:40Z

In reply to nevent1q…etx2
_________________________

I was thinking of adding a full pfp upload algo, yeah. I needed to implement something for onboarding new users, anyway, so that they don't start off with the fallback. Both ideas kinda merged in my head. 😂

you gotta add the nostr: before you nevent for most clients homie

2026-04-06T05:55:48Z

In reply to nevent1q…sqr8
_________________________

you gotta add the nostr: before you nevent for most clients homie

My own. Aitherboard and Imwald. They both have gitstuff in the ...

2026-04-06T05:53:55Z

In reply to nevent1q…8u3d
_________________________

My own. Aitherboard and Imwald. They both have gitstuff in the feeds and notifications. GitRepublic also shows them, on a particular repo.

You dont actually tell everyone, just thought it was funny

2026-04-06T05:55:41Z

In reply to nevent1q…jhle
_________________________

You dont actually tell everyone, just thought it was funny

GN 👋

2026-04-06T05:55:55Z

In reply to nevent1q…3nqn
_________________________

GN 👋

转 ———————— # ...

2026-04-06T05:50:12Z

转
————————

# 孙子会如何看待对伊朗开战？

但凡想正经将孙子兵法应用于现代战争，首先就要摒弃大众对孙子的固有认知。《孙子兵法》如今沦为一堆鸡汤语录，被套用在商业战略、体育竞技与心灵励志书籍中，大多断章取义、不求甚解。但这绝非其能流传两千余年的根本原因。孙子论述的从来不是抽象博弈，而是国与国之间的战争。

关于孙子其人，历来众说纷纭。传统记载认为，公元前6世纪末（约公元前540年至前496年），名将孙武效力于吴国。彼时战争规模有限，作战主力多为精锐小股部队，而非后世的庞大常备军。但这一说法从未形成共识。学界至今无法确定，《孙子兵法》是否为孙武一人所作，亦或是历代诸多思想家不断编撰、打磨而成。多数学者认为，该书更可能成书于公元前4世纪的战国时期。当时列国林立，秦、楚、燕等诸侯国为求生存、谋求一统，陷入长期大规模厮杀。彼时的战争不再是局部征伐，而是全民动员、职业化军队参战、结局生死攸关的持久决战。因此不少学者推断，历史上或许确有孙武其人，但整部兵法，是历代作者顺应战争形态演变，逐步汇总完善而成的智慧结晶。

《孙子兵法》开篇便振聋发聩：“兵者，国之大事，死生之地，存亡之道，不可不察也。”孙子所处的时代，战败即意味着亡国灭种；军队持续扩张，战事绵延日久，战争早已不是偶发冲突，而是关乎国运的持久博弈。立足这一背景，他构建的战争理论，至今仍被严重曲解。孙子从不推崇为战而战，也不执着于硬碰硬的决战，核心思想是以最低代价，让军事行动服务于政治目标。他早已点明：“夫兵久而国利者，未之有也。”

其核心要义常被简化为一句话，实则意蕴深远：“兵者，诡道也。”这绝非单纯指战场诡计，而是一套完整的战争思维。在孙子看来，诡道就是误导敌军认知，迷惑对手对你的战略意图、军事实力与作战短板的判断，逼迫敌方在犹疑不定中做出误判。

而诡道，必然依托情报洞察。孙子所言“知己知彼，百战不殆”，绝非单纯比拼武器装备，而是看透敌方整套体系——领导层格局、军队凝聚力、资源储备与应变能力。在此层面，情报不只是摸清底细的工具，更是施加影响的筹码。

分析任何一场战争前，孙子必先追问一个至今仍争议不休的核心问题：政治目标究竟是什么？他始终将战争与政治紧密绑定，提出“夫未战而庙算胜者，得算多也”，这无关战术排布，重在目标对齐。须知战略从来不止是动用武力，更是搭建手段与政治目的的桥梁。

套用在美以对伊朗的军事行动上，这个问题依旧是关键：终极目标是什么？是颠覆政权，还是逼迫其改弦更张？是摧毁核计划，还是迫使其接受约束？是战略威慑，还是武力逼降？这些目标绝非一回事，对应的投入规模、作战周期与风险承受底线，全然不同。

美国总统近期公开表态，明确一系列核心诉求：摧毁伊朗导弹库存与生产能力、瓦解其袭扰国际航运的海上战力、杜绝其研发核武器的可能、切断其扶持指挥代理人武装的渠道。这些目标，精准针对伊朗的军事实力与挑衅行径。

与此同时，美方部分言论又乐见伊朗现政权倒台、呼吁“伊朗人民争取自由”，还声称铲除伊朗高层便能催生“新政权”、倒逼其改变行事风格。这类表态，并未新增作战目标，却埋下模糊空间——乐见政权更迭，不等于将颠覆政权定为核心政治目标。

但这份模糊，本身就是一种施压手段。它让伊朗现政权不仅要考量持久战的代价，更要直面自身存亡危机。此举大幅加剧伊朗决策层的焦虑，威胁早已超出军力损耗，直指政权存续根基。

孙子绝不会全盘否定这种操作，只会审视其实际效用。“兵者，诡道也”，刻意制造战略模糊，便能误导敌方判断、打乱其盘算、强化威慑力度，同时不突破既定政治目标。这种战略性模糊，本身就是一种施压谋略。美方一边释放有限打击的信号，一边暗示存亡危机，倒逼伊朗决策层权衡多重风险，将政权存续纳入核心考量，让对手忌惮的不再只是战事损耗，更是政权覆灭的终极后果。

但孙子也会划出一条清晰红线：迷惑敌军是上策，自身战略含糊是大忌。倘若政界高层、军方统帅、盟友阵营对作战目标无法达成共识，谋略便会沦为混乱。战略层面的含糊不清，终将导致行动一盘散沙。

孙子还定下一套经典作战优先级，至今仍是解读战争的绝佳框架：“上兵伐谋，其次伐交，其次伐兵，其下攻城。”万般皆无效，才会走到最后一步——“攻城之法，为不得已”。这套逻辑，完全适用于伊朗局势。

第一，伐谋。伊朗的对抗逻辑，从来不靠常规战场决胜，而是依托持久战、分散部署与非对称战力，依靠代理人武装、导弹部队、经济施压，靠日积月累消耗对手。仅靠摧毁武器装备，根本打不垮这套体系。孙子早有箴言：“百战百胜，非善之善者也。”终极目的不是毁灭，而是瓦解敌方整套作战逻辑。因此，只打击军力远远不够，还要精准重创其指挥网络、财源命脉、内部管控体系与战力再生能力。

这正是孙子推崇的迂回制胜之道：提前布局造势，让决战尚未打响，胜负便已注定；必要时依旧果断出手，借战力扩大优势、抬高对手代价。核心是避实击虚，靠机动牵制、体系瓦解与心理施压击溃敌方。放到现代，这套思路早已延伸至信息战、网络战，以及低烈度非常规博弈，全方位削弱对手的战力与抗争意志。

当前针对伊朗的诸多行动，已然贴合这套思路，只是局势仍存极大不确定性。美以精准打击伊朗核心军事节点，但伊朗剩余战力、内部凝聚力、高层决策动向，依旧迷雾重重。不过诸多线索（虽未实锤、尚存争议）显示，施压已初见成效：伊朗大规模齐射导弹与无人机的频次明显下降，多方消息称其协同作战紊乱、高层内部分歧加剧、联合作战难以推进；伊朗亦悄然向美方释放缓和信号，同时传出人员叛逃传闻，当局更是强化管控，在核心城区增设民兵检查站维稳。单一线索不足为凭，但串联来看，伊朗政权承受的压力，早已蔓延至军事之外，深入内部稳定与决策核心。

第二，伐交。伊朗的影响力，深度绑定真主党、伊拉克与叙利亚民兵、胡塞武装等全套代理人网络。这些势力绝非边缘角色，而是伊朗非对称作战的核心支柱。孙子将伐交置于伐兵之前，自有深意：瓦解盟友体系，无需决战便能削弱敌方根基，彻底孤立对手。如今美以行动已然践行此道：以色列持续清剿真主党，定点清除其高层、摧毁基础设施、瓦解协同作战能力；也门胡塞武装袭扰航运、反击以色列的举动也警示世人——即便代理人战力受损，依旧能持续制造麻烦，彻底斩断伊朗外围势力，才有望击溃其整体战略。而维系盟友间的步调一致，更是重中之重。

第三，伐兵。精准打击伊朗导弹阵地、海上军力、防空系统与军工设施，贴合既定作战目标，既能短期削弱其域外投送战力，也能形成长期震慑。但单纯军事打击无法一锤定音：战术胜利，不等于战略决胜。不仅要销毁现有战力，更要改写敌方决策逻辑，断绝其重建军力、重启挑衅的可能。精准铲除伊朗军政核心人物（现代战法，远超孙子所处时代的认知），恰好直击要害：既削弱其用兵能力，也瓦解其抗争意志。由此可见，军事行动必须融入整套体系打击战略，恪守孙子“伐谋为先，不唯伐兵”的核心。

最后，攻城。“攻城之法，为不得已。”孙子将攻城列为下策，只因耗时耗力、代价惨重。古代围城战拖沓奢靡、变数极大，会彻底丧失机动主动权，极易陷入持久战——而这正是孙子极力规避的局面。这套逻辑至今成立：现代城市战同样繁复烧钱、政治代价巨大，会消耗大量战力、拉长战事周期。对追求高效达成政治目标的战略家而言，攻城从来不是首选。即便迫不得已出兵（比如为颠覆政权速占首都），也必须速战速决、精准施策。

在孙子眼中，时间永远是关键。一场短促凌厉、足以促成政治和谈的战事，才是最优解：敲定刚性约束，杜绝伊朗重启核计划、接受全面核查、限制导弹研发、禁止袭扰国际航运、削减扶持代理人武装。

达成上述目标，作战初衷便已实现；若未能如愿，唯有升级施压。孙子深知，摧毁伊朗的作战手段，从来不是终点，而是瓦解其开战能力、动摇其抗争决心的筹码。顺着这套思路，终极施压必然直击伊朗命脉——关乎其存续的核心利益：石油收入、维系军力与维稳大局的关键基建。譬如封锁哈尔克岛石油出口要道、斩断其借霍尔木兹海峡拿捏全球航运的经济施压筹码；瓦解其维系内部团结的通讯与信息网络。这类施压，绝非为毁灭而毁灭，而是通过抬高战事成本，倒逼伊朗政权妥协，动摇其统治根基，无力再对外挑衅。

纵观全程，孙子评判胜负的标准始终简单直白：不在于摧毁多少装备，而在于达成多少目标。若敌方决策彻底转向，战略便大功告成；若无改观，再亮眼的战术战果，终究徒劳无功。

这便是《孙子兵法》流传千古的底气：它从不是一本战场杀敌手册，而是一套博弈思维框架——战争是意志的较量，受政治目标牵引、被代价底线约束，最终决胜于决策博弈，而非武力屠戮。

孙子亦深谙武力背后的政治局限，懂战场之外舆论人心的分量。他再三警示“夫兵久而国利者，未之有也”，强调军事行动必须紧扣国家核心利益，绝不能肆意扩大作战目标。他极度看重情报预判，主张提前洞悉局势、掌控走向——这套理念，如今早已延伸至信息舆论领域，左右敌我高层与民众的认知。

他也明白，威慑从来不是口头狠话，而是精准拿捏人心、适度施压。“不战而屈人之兵，善之善者也”，核心是让敌方看清持久战的惨痛后果。但他亦告诫切莫赶尽杀绝：“围师必阙，穷寇勿迫。”施压的初衷，不是断绝所有退路，而是引导对手做出理性选择。放到当下，便是适度动武倒逼伊朗妥协，同时预留契合既定目标的政治和解通道。

这点至关重要：即便战火导致伊朗政权自然崩塌，也不等同于早早将颠覆政权定为作战目标。倘若美方目标从“逼其改弦更张”悄然转为“大举地面出兵颠覆政权”，便会重蹈过往战争覆辙——有限目标无限扩张，深陷战后重建、长期反恐泥潭，对手凭借灵活分散、隐蔽周旋持续反击。这般局面，只会利于防守方、拉长战事、瓦解内部共识。

孙子的警示掷地有声：战略必须锚定政治初心，目标务必恪守底线，否则前期战果，终将在持久战中消磨殆尽。

附记：若想深入研读原著，塞缪尔·B·格里菲思译本的《孙子兵法》，仍是当下最权威、流传最广的经典版本。

---
作者简介：
约翰·斯宾塞，城市作战研究所执行董事。
著有《九死一生：绝境求生的人生启示》，合著《读懂城市战争》。
更多资讯可查阅官网：
www.johnspenceronline.com

Sometimes it syncs 😅

2026-04-06T05:50:00Z

In reply to nevent1q…4wvp
_________________________

Sometimes it syncs 😅

What would be the best file format? PNG?

2026-04-06T05:47:50Z

In reply to nevent1q…dgjp
_________________________

What would be the best file format? PNG?

Nostr event nevent1qqsv5g48yq52m2mzr0qklufrcnxe4lynykxw4eq8pwwvtfepf9wytlqpr9mhxue69uhhyetvv9ujuumgv9jx7amzd9czucm0d5pzqkj540wgff0684cp4js7l73ke5djns8rhq4crm2djwqdjg7934gs5ngx3c

2026-04-06T05:27:24Z

Nostr event nevent1qqs8upqvtv424enx9vh2sjq0jxw3k04w49lnfmy5l62llga7m8maqrspr9mhxue69uhhyetvv9ujuumgv9jx7amzd9czucm0d5pzqkj540wgff0684cp4js7l73ke5djns8rhq4crm2djwqdjg7934gsq53qru

2026-04-06T05:23:03Z

Block 943873 3 - high priority 1 - medium priority 1 - low ...

2026-04-06T05:20:51Z

Block 943873

3 - high priority
1 - medium priority
1 - low priority
1 - no priority
1 - purging

#bitcoinfees #mempool

Block 943873 3 - high priority 1 - medium priority 1 - low ...

2026-04-06T05:20:51Z

Block 943873

3 - high priority
1 - medium priority
1 - low priority
1 - no priority
1 - purging

#bitcoinfees #mempool

hmm.. in China when people fight each other and they have their ...

2026-04-06T05:19:28Z

hmm.. in China when people fight each other and they have their kids with them, they seem to fight each other then attack the kids as well

in most countries the kids are usually off limits, but in the US i do see young black kids join the fight to help their parents 😂

just use it in your linkedin, and keep it hush-hush

2026-04-06T05:18:36Z

In reply to nevent1q…f8e8
_________________________

just use it in your linkedin, and keep it hush-hush

When your Palestine supporting Bitch Wifoid (Wife Foid) won't ...

2026-04-06T05:03:15Z

When your Palestine supporting Bitch Wifoid (Wife Foid) won't let you be healthy by avoiding Goyslop, and eating Kosher because eating Kosher funds The Jews 😔✊️.

https://v.nostr.build/z66qvnrbryDmMRtB.mov

2026-04-06T05:01:27Z

In reply to nevent1q…u586
_________________________

Ce codec vidéo coûte un pognon de dingue aux plateformes de ...

2026-04-06T05:01:00Z

Ce codec vidéo coûte un pognon de dingue aux plateformes de streaming, le français VideoLAN porte la riposte libre
https://www.clubic.com/actualite-607765-ce-codec-video-coute-un-pognon-de-dingue-aux-plateformes-de-streaming-le-francais-videolan-porte-la-riposte-libre.html
#nostrfr

Block 943873 1 - high priority 1 - medium priority 1 - low ...

2026-04-06T05:00:57Z

Block 943873

1 - high priority
1 - medium priority
1 - low priority
1 - no priority
1 - purging

#bitcoinfees #mempool

Block 943873 1 - high priority 1 - medium priority 1 - low ...

2026-04-06T05:00:57Z

Block 943873

1 - high priority
1 - medium priority
1 - low priority
1 - no priority
1 - purging

#bitcoinfees #mempool

Block 943873 1 - high priority 1 - medium priority 1 - low ...

2026-04-06T05:00:57Z

Block 943873

1 - high priority
1 - medium priority
1 - low priority
1 - no priority
1 - purging

#bitcoinfees #mempool

You are famous bro 😎

2026-04-06T04:55:39Z

In reply to nevent1q…npcv
_________________________

You are famous bro 😎

Yessss bro, this is what I am looking for! 🙌 I am not really ...

2026-04-06T04:54:23Z

In reply to nevent1q…5wjy
_________________________

Yessss bro, this is what I am looking for! 🙌

I am not really crazy to replace my current phono preamp, but this looks really good. I only wish it has a headphone output, that’s the only thing missing.

Thank you! 🙏

I also can type appropriately 😭

2026-04-06T04:53:38Z

In reply to nevent1q…zfuk
_________________________

I also can type appropriately 😭

😂 https://media.tenor.com/nimOIXx-bAgAAAAC/robot-robots.gif

2026-04-06T04:52:48Z

In reply to nevent1q…vxev
_________________________

😂

How do I have 50K followers when we don’t not have like 100 ...

2026-04-06T04:49:12Z

How do I have 50K followers when we don’t not have like 100 people on nostr with 100 alts? 🤷‍♂️

Yes

2026-04-06T04:44:13Z

In reply to nevent1q…8m33
_________________________

Yes

URL(remove spaces): https:// pfp.nostr.build ...

2026-04-06T04:40:26Z

In reply to nevent1q…4803
_________________________

URL(remove spaces): https:// pfp.nostr.build /1e32e7ded1df45aa5d63919eaf0eb3c5590906e70c28180809ca921d9ea6a2a6.gif

Nostr event nevent1qqsrrhjeg54njva6t6awehg4usnynhu9qmpp3aqgj7dhrvlvfvetpuspr9mhxue69uhhyetvv9ujuumgv9jx7amzd9czucm0d5pzqlwpvac39uz74ay4g7qx2sa3cqrvuvjhy7899vwf40lkxfcw6uz0tza2y7

2026-04-06T04:39:02Z

やっぱダメっすよ　俺はもう

This is how I Nostr ...

2026-04-06T04:38:12Z

This is how I Nostr

I'll be upfront and say you're probably over qualified, ...

2026-04-06T04:34:37Z

In reply to nevent1q…a4za
_________________________

I'll be upfront and say you're probably over qualified, and I can also say the told me they wanted a full time employee and not consulting, so just a heads up on that. But I'd be happy to chat about it if you're still interested!

quoting
nevent1q…czjq
Are you on signal? They're going to want to chat over email probably, so we can just go straight to email if you'd prefer. My public email is on my website (just click the contact button to show it). I can give you more specifics. You'd be expected to pick up on those tools with little guidance. Chances are I'd be consulting with them on tech stack decisions.

https://www.vaughnnugent.com/
https://signal.me/#eu/duR00-XpDlel3PjNSnO2E4CLlAbd3cYy0s0qOO2BYD9vmaow4kBMh79UXh7dPkgU

Build manifest for get_file_hash v0.4.7

2026-04-06T04:17:40Z

In reply to nevent1q…2ddv
_________________________

Build manifest for get_file_hash v0.4.7

<?xml version='1.0' ...

2026-04-06T04:17:28Z

<?xml version='1.0' encoding='windows-1252'?>





<?if $(sys.BUILDARCH) = x64 or $(sys.BUILDARCH) = arm64 ?>
<?define PlatformProgramFilesFolder = "ProgramFiles64Folder" ?>
<?else ?>
<?define PlatformProgramFilesFolder = "ProgramFilesFolder" ?>
<?endif ?>

<Wix xmlns='http://schemas.microsoft.com/wix/2006/wi'>;

<Product
Id='*'
Name='get_file_hash'
UpgradeCode='DED69220-26E3-4406-B564-7F2B58C56F57'
Manufacturer='gnostr admin@gnostr.org'
Language='1033'
Codepage='1252'
Version='$(var.Version)'>

<Package Id='*'
Keywords='Installer'
Description='A utility crate providing a procedural macro to compute and embed file hashes at compile time.'
Manufacturer='gnostr admin@gnostr.org'
InstallerVersion='450'
Languages='1033'
Compressed='yes'
InstallScope='perMachine'
SummaryCodepage='1252'
/>

<MajorUpgrade
Schedule='afterInstallInitialize'
DowngradeErrorMessage='A newer version of [ProductName] is already installed. Setup will now exit.'/>

<Media Id='1' Cabinet='media1.cab' EmbedCab='yes' DiskPrompt='CD-ROM #1'/>
<Property Id='DiskPrompt' Value='get_file_hash Installation'/>

<Directory Id='TARGETDIR' Name='SourceDir'>
<Directory Id='$(var.PlatformProgramFilesFolder)' Name='PFiles'>
<Directory Id='APPLICATIONFOLDER' Name='get_file_hash'>




<Directory Id='Bin' Name='bin'>
<Component Id='Path' Guid='8DB39A25-8B99-4C25-8CF5-4704353C7C6E' KeyPath='yes'>
<Environment
Id='PATH'
Name='PATH'
Value='[Bin]'
Permanent='no'
Part='last'
Action='set'
System='yes'/>
</Component>
<Component Id='binary0' Guid='*'>
<File
Id='exe0'
Name='get_file_hash.exe'
DiskId='1'
Source='$(var.CargoTargetBinDir)\get_file_hash.exe'
KeyPath='yes'/>
</Component>
<Component Id='binary1' Guid='*'>
<File
Id='exe1'
Name='n34.exe'
DiskId='1'
Source='$(var.CargoTargetBinDir)\n34.exe'
KeyPath='yes'/>
</Component>
<Component Id='binary2' Guid='*'>
<File
Id='exe2'
Name='n34-relay.exe'
DiskId='1'
Source='$(var.CargoTargetBinDir)\n34-relay.exe'
KeyPath='yes'/>
</Component>
<Component Id='binary3' Guid='*'>
<File
Id='exe3'
Name='readme.exe'
DiskId='1'
Source='$(var.CargoTargetBinDir)\readme.exe'
KeyPath='yes'/>
</Component>
</Directory>
</Directory>
</Directory>
</Directory>

<Feature
Id='Binaries'
Title='Application'
Description='Installs all binaries and the license.'
Level='1'
ConfigurableDirectory='APPLICATIONFOLDER'
AllowAdvertise='no'
Display='expand'
Absent='disallow'>




<ComponentRef Id='binary0'/>
<ComponentRef Id='binary1'/>
<ComponentRef Id='binary2'/>
<ComponentRef Id='binary3'/>

<Feature
Id='Environment'
Title='PATH Environment Variable'
Description='Add the install location of the [ProductName] executable to the PATH system environment variable. This allows the [ProductName] executable to be called from any location.'
Level='1'
Absent='allow'>
<ComponentRef Id='Path'/>
</Feature>
</Feature>

<SetProperty Id='ARPINSTALLLOCATION' Value='[APPLICATIONFOLDER]' After='CostFinalize'/>





<Property Id='ARPHELPLINK' Value='https://github.com/gnostr-org/get_file_hash'/>;

<UI>
<UIRef Id='WixUI_FeatureTree'/>


<Publish Dialog='WelcomeDlg' Control='Next' Event='NewDialog' Value='CustomizeDlg' Order='99'>1</Publish>
<Publish Dialog='CustomizeDlg' Control='Back' Event='NewDialog' Value='WelcomeDlg' Order='99'>1</Publish>

</UI>










</Product>

</Wix>

use std::process::Command; use std::fs; use sha2::{Digest, ...

2026-04-06T04:17:13Z

use std::process::Command;
use std::fs;
use sha2::{Digest, Sha256};

fn calculate_sha256(file_path: &str) -> String {
let content = fs::read(file_path).expect("Unable to read file");
let mut hasher = Sha256::new();
hasher.update(&content);
hasher.finalize()
.iter()
.map(|b| format!("{:02x}", b))
.collect()
}

#[test]
fn test_get_file_hash_binary_no_features() {
let output = Command::new("cargo")
.arg("run")
.arg("--bin")
.arg("get_file_hash")
.output()
.expect("Failed to execute command");

let stdout = String::from_utf8_lossy(&output.stdout);
let stderr = String::from_utf8_lossy(&output.stderr);

// Assert that the command ran successfully
assert!(output.status.success(), "Command failed with stderr: {}", stderr);

// Manually calculate the hash of the binary's source file
let expected_hash = calculate_sha256("src/bin/get_file_hash.rs");

// Assert that the output contains the correct hash
// Check for the raw hash first
assert!(stdout.contains(&expected_hash), "Output did not contain raw expected hash. Expected: {}, Actual: {}", expected_hash, stdout);

// Then check for the formatted string, including backticks
// Use a regex-like check for more flexibility with newlines if needed, or refine to exact match
let expected_hash_line = format!("* **SHA-256 Hash:** `{}`", expected_hash);
assert!(stdout.contains(&expected_hash_line), "Output did not contain expected hash line. Expected line: {}, Actual: {}", expected_hash_line, stdout);

// Assert that the output contains "Integrity Verified."
assert!(stdout.contains("Integrity Verified."), "Output did not contain 'Integrity Verified.'. stdout: {}", stdout);

println!("Output from get_file_hash binary (no features):
{}", stdout);
}

#[test]
fn test_get_file_hash_binary_with_nostr_feature() {
let output = Command::new("cargo")
.arg("run")
.arg("--bin")
.arg("get_file_hash")
.arg("--features")
.arg("nostr")
.output()
.expect("Failed to execute command");

let stdout = String::from_utf8_lossy(&output.stdout);
let stderr = String::from_utf8_lossy(&output.stderr);

// Assert that the command ran successfully
assert!(output.status.success(), "Command failed with stderr: {}", stderr);

// Manually calculate the hash of the binary's source file
let expected_hash = calculate_sha256("src/bin/get_file_hash.rs");

// Assert that the output contains the correct hash
assert!(stdout.contains(&expected_hash), "Output did not contain raw expected hash. Expected: {}, Actual: {}", expected_hash, stdout);

// Then check for the formatted string, including backticks
let expected_hash_line = format!("* **SHA-256 Hash:** `{}`", expected_hash);
assert!(stdout.contains(&expected_hash_line), "Output did not contain expected hash line. Expected line: {}, Actual: {}", expected_hash_line, stdout);

// Assert that the output contains "Integrity Verified."
assert!(stdout.contains("Integrity Verified."), "Output did not contain 'Integrity Verified.'. stdout: {}", stdout);

println!("Output from get_file_hash binary (with nostr feature):
{}", stdout);
}

//! A crate providing the `get_file_hash!` procedural macro. //! ...

2026-04-06T04:17:01Z

//! A crate providing the `get_file_hash!` procedural macro.
//!
//! This macro allows you to compute the SHA-256 hash of a file at compile time,
//! embedding the resulting hash string directly into your Rust executable.

pub use get_file_hash_core::get_file_hash;

/// The SHA-256 hash of this crate's `build.rs` at the time of compilation.
pub const BUILD_HASH: &str = env!("BUILD_HASH");

/// The SHA-256 hash of this crate's `Cargo.toml` at the time of compilation.
pub const CARGO_TOML_HASH: &str = env!("CARGO_TOML_HASH");

/// The SHA-256 hash of this crate's `src/lib.rs` at the time of compilation.
pub const LIB_HASH: &str = env!("LIB_HASH");

/// The name of the package as specified in Cargo.toml.
pub const CARGO_PKG_NAME: &str = env!("CARGO_PKG_NAME");

/// The version of the package as specified in Cargo.toml.
pub const CARGO_PKG_VERSION: &str = env!("CARGO_PKG_VERSION");

#[cfg(feature = "nostr")]
/// The git commit hash of the repository at the time of compilation.
pub const GIT_COMMIT_HASH: &str = env!("GIT_COMMIT_HASH");

#[cfg(feature = "nostr")]
/// The git branch of the repository at the time of compilation.
pub const GIT_BRANCH: &str = env!("GIT_BRANCH");

#[cfg(test)]
mod tests {
use sha2::{Digest, Sha256};

use super::*;

/// Verifies that the exported CARGO_TOML_HASH is not empty.
#[test]
fn test_injected_hash_exists() {
assert!(!BUILD_HASH.is_empty());
println!("Verified build.rs Hash:
{}", BUILD_HASH);

assert!(!CARGO_TOML_HASH.is_empty());
println!("Verified Cargo.toml Hash:
{}", CARGO_TOML_HASH);

assert!(!LIB_HASH.is_empty());
println!("Verified src/lib.rs Hash:\n{}", LIB_HASH);

assert!(!CARGO_PKG_NAME.is_empty());
println!("Verified Package Name:\n{}", CARGO_PKG_NAME);

assert!(!CARGO_PKG_VERSION.is_empty());
println!("Verified Package Version:\n{}", CARGO_PKG_VERSION);

#[cfg(feature = "nostr")]
{
assert!(!GIT_COMMIT_HASH.is_empty());
println!("Verified Git Commit Hash:\n{}", GIT_COMMIT_HASH);

assert!(!GIT_BRANCH.is_empty());
println!("Verified Git Branch:\n{}", GIT_BRANCH);
}
}

/// Tests that the `get_file_hash!` macro correctly computes the SHA-256
/// hash of `lib.rs` and that it matches a manually computed hash of the
/// same file.
#[test]
fn test_get_lib_hash() {
let file_content = include_bytes!("lib.rs");

let mut hasher = Sha256::new();
hasher.update(file_content);
let expected_hash = hasher
.finalize()
.iter()
.map(|b| format!("{:02x}", b))
.collect::<String>();

let actual_hash = get_file_hash!("lib.rs");
assert_eq!(actual_hash, expected_hash);
}
}

Relay URL,Latitude,Longitude wot.nostr.party,36.1627,-86.7816 ...

2026-04-06T04:16:49Z

Relay URL,Latitude,Longitude
wot.nostr.party,36.1627,-86.7816
nostr.simplex.icu,50.1109,8.68213
relay.snort.social,53.3498,-6.26031
nostr.stakey.net,52.3676,4.90414
relay.mccormick.cx,52.3563,4.95714
nostr.overmind.lol,43.6532,-79.3832
nostriches.club,43.6532,-79.3832
kanagrovv-pyramid.kozow.com,43.4305,-83.9638
relay.toastr.net,40.8054,-74.0241
relay.primal.net,43.6532,-79.3832
r.bitcoinhold.net,43.6532,-79.3832
wot.dtonon.com,43.6532,-79.3832
santo.iguanatech.net,40.8302,-74.1299
relay2.ngengine.org,43.6532,-79.3832
nostr.oxtr.dev,50.4754,12.3683
simplex.icu,50.1109,8.68213
bitchat.nostr1.com,38.6327,-90.1961
relay.nostu.be,40.4167,-3.70329
nostr.mifen.me,43.6532,-79.3832
relay.vantis.ninja,43.6532,-79.3832
nostr-kyomu-haskell.onrender.com,37.7775,-122.397
nostr-relay.amethyst.name,39.0067,-77.4291
relay.bitcoindistrict.org,43.6532,-79.3832
nos.xmark.cc,50.6924,3.20113
relay01.lnfi.network,35.6764,139.65
nostr-dev.wellorder.net,45.5201,-122.99
nostr.rblb.it,43.7094,10.6582
offchain.pub,39.1585,-94.5728
wot.nostr.place,32.7767,-96.797
fanfares.nostr1.com,38.6327,-90.1961
ephemeral.snowflare.cc,43.6532,-79.3832
relay.visionfusen.org,43.6532,-79.3832
nostr.carroarmato0.be,51.0368,3.21186
social.amanah.eblessing.co,48.1046,11.6002
relay.cyphernomad.com,60.4032,25.0321
nostr-rs-relay-qj1h.onrender.com,37.7775,-122.397
relay.ngengine.org,43.6532,-79.3832
relay.nosto.re,51.1792,5.89444
rusty-uat.siberian-albacore.ts.net:8443,35.6764,139.65
nostr.luisschwab.net,43.6532,-79.3832
nostr.aruku.ovh,1.27994,103.849
srtrelay.c-stellar.net,43.6532,-79.3832
nostr.tagomago.me,3.139,101.687
relay.threenine.services,51.5222,-0.62916
nostr.robosats.org,64.1476,-21.9392
nostr.2b9t.xyz,34.0549,-118.243
strfry.apps3.slidestr.net,40.4167,-3.70329
kitchen.zap.cooking,43.6532,-79.3832
relay.homeinhk.xyz,45.5152,-122.678
relay.seq1.net,43.6532,-79.3832
relay.bornheimer.app,50.1109,8.68213
relay.vrtmrz.net,43.6532,-79.3832
nostr.red5d.dev,43.6532,-79.3832
relay-freeharmonypeople.space,38.7223,-9.13934
aaa-api.freefrom.space/v1/ws,43.6532,-79.3832
dev.relay.edufeed.org,49.4521,11.0767
nostr.myshosholoza.co.za,52.3913,4.66545
nostr.plantroon.com,50.1013,8.62643
wot.dergigi.com,64.1476,-21.9392
npub1spxdug4m3y24hpx5crm0el4zhkk0wafs8kp6m0xu0wecygqej2xqq8gyhx.fips.network,43.6532,-79.3832
nostrelay.circum.space,52.3676,4.90414
relay.dreamith.to,43.6532,-79.3832
relay.nostriches.club,43.6532,-79.3832
nostr-relayrs.gateway.in.th,15.5163,103.194
nostr.chrissexton.org,43.6532,-79.3832
relay.flashapp.me,43.652,-79.3633
nostr-relay-1.trustlessenterprise.com,43.6532,-79.3832
strfry.shock.network,39.0438,-77.4874
relay.snotr.nl:49999,52.0195,4.42946
spatia-arcana.com,34.0362,-118.443
nostr.computingcache.com,34.0356,-118.442
nostr.self-determined.de,53.5,10.25
relay.sharegap.net,43.6532,-79.3832
spookstr2.nostr1.com,38.6327,-90.1961
v-relay.d02.vrtmrz.net,34.6937,135.502
bridge.tagomago.me,3.139,101.687
antiprimal.net,43.6532,-79.3832
relay.nostrdice.com,-33.8688,151.209
purpura.cloud,43.6532,-79.3832
espelho.girino.org,43.6532,-79.3832
relay.mostro.network,40.8302,-74.1299
temp.iris.to,43.6532,-79.3832
pyramid.self-determined.de,53.5,10.25
relay.jeffg.fyi,43.6532,-79.3832
nostr.aruku.kro.kr,37.3589,127.115
chat-relay.zap-work.com,43.6532,-79.3832
relay.islandbitcoin.com,12.8498,77.6545
nostr.zoracle.org,45.6018,-121.185
relay-dev.satlantis.io,40.8302,-74.1299
relay.earthly.city,34.0362,-118.443
speakeasy.cellar.social,49.4543,11.0746
relay.bnos.space,43.6532,-79.3832
relay.henryxplace.eu.org:9988,31.2304,121.474
relay.bitmacro.cloud,43.6532,-79.3832
nostr.thebiglake.org,32.71,-96.6745
relay.lab.rytswd.com,49.4543,11.0746
nostr.nadajnik.org,50.1109,8.68213
relay.evanverma.com,40.8302,-74.1299
relay2.angor.io,48.1046,11.6002
prl.plus,55.7628,37.5983
myvoiceourstory.org,37.3598,-121.981
relay.arx-ccn.com,50.4754,12.3683
wot.sudocarlos.com,43.6532,-79.3832
relayrs.notoshi.win,43.6532,-79.3832
nostrcity-club.fly.dev,48.8575,2.35138
relay.tagayasu.xyz,45.4215,-75.6972
nostr.blankfors.se,60.1699,24.9384
nrs-01.darkcloudarcade.com,39.1008,-94.5811
relay.lightning.pub,39.0438,-77.4874
nostr-02.yakihonne.com,1.32123,103.695
relay.nostrverse.net,43.6532,-79.3832
nostr.wecsats.io,43.6532,-79.3832
relay.illuminodes.com,47.6062,-122.332
api.freefrom.space/v1/ws,43.6532,-79.3832
nostr-relay.psfoundation.info,39.0438,-77.4874
relay.samt.st,40.8302,-74.1299
nostr-relay.cbrx.io,43.6532,-79.3832
inbox.mycelium.social,38.627,-90.1994
relay.anmore.me,49.281,-123.117
no.str.cr,10.074,-84.2155
nstr.a0a1.space,52.3563,4.95714
relay.typedcypher.com,51.5072,-0.127586
relay.bitmacro.pro,43.6532,-79.3832
relay.nostrzh.org,43.6532,-79.3832
ynostr.yael.at,60.1699,24.9384
nostr-relay.zeabur.app,25.0797,121.234
dynasty.libretechsystems.xyz,55.4724,9.87335
nostr.bitcoiner.social,47.6743,-117.112
nostr.girino.org,43.6532,-79.3832
nostr2.girino.org,43.6532,-79.3832
nostr-verified.wellorder.net,45.5201,-122.99
relay.fundstr.me,42.3601,-71.0589
relay.mapboss.co.th,13.7234,100.784
relay.qstr.app,51.5072,-0.127586
nostr-rs-relay-ishosta.phamthanh.me,43.6532,-79.3832
relay.klabo.world,47.674,-122.122
relay.minibolt.info,43.6532,-79.3832
x.kojira.io,43.6532,-79.3832
relay-dev.gulugulu.moe,43.6532,-79.3832
relay.nostriot.com,41.5695,-83.9786
relayone.soundhsa.com,39.1008,-94.5811
nr.yay.so,46.2126,6.1154
relay.bithome.site,52.3563,4.95714
relay.damus.io,43.6532,-79.3832
nostr.mikoshi.de,50.1109,8.68213
nostr.defucc.me,50.1109,8.68213
relay.malxte.de,52.52,13.405
relay.orangepill.ovh,49.1689,-0.358841
bbw-nostr.xyz,41.5284,-87.4237
kasztanowa.bieda.it,43.6532,-79.3832
bitcoiner.social,47.6743,-117.112
relay.lacompagniemaximus.com,45.3147,-73.8785
relay.mostr.pub,43.6532,-79.3832
relay.lanavault.space,60.1699,24.9384
kotukonostr.onrender.com,37.7775,-122.397
relay.ditto.pub,43.6532,-79.3832
relay.erybody.com,41.4513,-81.7021
nostr.dlcdevkit.com,40.0992,-83.1141
ribo.us.nostria.app,41.5868,-93.625
relay.paulstephenborile.com,49.4543,11.0746
testnet-relay.samt.st,40.8302,-74.1299
relay.purplefrog.cloud,35.6916,139.768
relay.agorist.space,52.3734,4.89406
nostr-relay.zimage.com,34.0549,-118.243
nostr.azzamo.net,52.2633,21.0283
strfry.elswa-dev.online,50.1109,8.68213
wot.shaving.kiwi,43.6532,-79.3832
okn.czas.plus,50.1109,8.68213
bcast.seutoba.com.br,43.6532,-79.3832
relay.sigit.io,50.4754,12.3683
syb.lol,34.0549,-118.243
relay.libernet.app,43.6532,-79.3832
relay.angor.io,48.1046,11.6002
relay.staging.commonshub.brussels,49.4543,11.0746
strfry.atlantislabs.space,43.6532,-79.3832
nostr.wom.wtf,43.6532,-79.3832
nostrride.io,37.3986,-121.964
nostr.dpinkerton.com,39.1008,-94.5811
r.0kb.io,32.789,-96.7989
nostr.hekster.org,37.3986,-121.964
satsage.xyz,37.3986,-121.964
nostr.islandarea.net,35.4669,-97.6473
ve.agorawlc.com,50.4754,12.3683
relay.openfarmtools.org,60.1699,24.9384
top.testrelay.top,43.6532,-79.3832
relay-rpi.edufeed.org,49.4521,11.0767
pyramid.cult.cash,32.9483,-96.7299
relay.edino.net,56.6268,47.9193
nostr.snowbla.de,60.1699,24.9384
relay.wavefunc.live,39.7392,-104.99
tenex.chat,50.4754,12.3683
relay.getsafebox.app,43.6532,-79.3832
nostr.bond,50.1109,8.68213
nostrelites.org,41.8781,-87.6298
relay.plebeian.market,50.1109,8.68213
relay.laantungir.net,-19.4692,-42.5315
relay.decentnewsroom.com,50.4754,12.3683
nostr-relay.nextblockvending.com,47.2343,-119.853
relay.spacetomatoes.net,42.3601,-71.0589
nostrbtc.com,43.6532,-79.3832
relay.puresignal.news,43.6532,-79.3832
relay-testnet.k8s.layer3.news,37.3387,-121.885
relay.binaryrobot.com,43.6532,-79.3832
relay.wavlake.com,41.2619,-95.8608
inbox.scuba323.com,40.8218,-74.45
nostr.spaceshell.xyz,43.6532,-79.3832
relay.nostr.place,32.7767,-96.797
holland-excited-charming-experiencing.trycloudflare.com,43.6532,-79.3832
theoutpost.life,64.1476,-21.9392
relay.fckstate.net,59.3293,18.0686
bcast.girino.org,43.6532,-79.3832
discovery.us.nostria.app,52.3676,4.90414
relay.bullishbounty.com,43.6532,-79.3832
nostr.88mph.life,51.5072,-0.127586
nostr.tadryanom.me,43.6532,-79.3832
nostr.sathoarder.com,48.5734,7.75211
relay.nostr.net,43.6532,-79.3832
zw.agorawlc.com,50.4754,12.3683
relay.internationalright-wing.org,-22.5022,-48.7114
nostr.vulpem.com,49.4543,11.0746
wot.codingarena.top,50.4754,12.3683
reraw.pbla2fish.cc,43.6532,-79.3832
plebchain.club,43.6532,-79.3832
orly-relay.imwald.eu,48.8575,2.35138
relay.satnam.pub,43.6532,-79.3832
cs-relay.nostrdev.com,50.4754,12.3683
schnorr.me,43.6532,-79.3832
nostr-relay.online,43.6532,-79.3832
relay.routstr.com,43.6532,-79.3832
relay.ohstr.com,43.6532,-79.3832
relay.lanacoin-eternity.com,40.8302,-74.1299
wot.nostr.net,43.6532,-79.3832
nostr.ps1829.com,33.8851,130.883
yabu.me,35.6092,139.73
soloco.nl,43.6532,-79.3832
librerelay.aaroniumii.com,43.6532,-79.3832
relay.mmwaves.de,48.8575,2.35138
relay.artx.market,43.6548,-79.3885
nostr.jerrynya.fun,31.2304,121.474
relay-arg.zombi.cloudrodion.com,1.35208,103.82
relay.edufeed.org,49.4521,11.0767
discovery.eu.nostria.app,52.3676,4.90414
relay.layer.systems,49.0291,8.35695
nostr-rs-relay.dev.fedibtc.com,39.0438,-77.4874
relay.0xchat.com,43.6532,-79.3832
nos.lol,50.4754,12.3683
lightning.red,53.3498,-6.26031
slick.mjex.me,39.0418,-77.4744
relay.boredvictor.xyz,41.3888,2.15899
nostr.rtvslawenia.com,49.4543,11.0746
relay.mitchelltribe.com,39.0438,-77.4874
nostr.4rs.nl,49.0291,8.35696
relay.olas.app,50.4754,12.3683
memlay.v0l.io,53.3498,-6.26031
nostr-01.yakihonne.com,1.29524,103.79
relay.satmaxt.xyz,43.6532,-79.3832
nostrcheck.tnsor.network,43.6532,-79.3832
relay.guggero.org,46.0037,8.95105
ai.techunder.tech:56711,22.5429,114.06
premium.primal.net,43.6532,-79.3832
nostr.tac.lol,47.4748,-122.273
relay.zone667.com,60.1699,24.9384
nostr-relay.gateway.in.th,15.5163,103.194
vault.iris.to,43.6532,-79.3832
strfry.bonsai.com,37.8716,-122.273
ribo.eu.nostria.app,52.3676,4.90414
relay.wellorder.net,45.5201,-122.99
relay.tapestry.ninja,40.8054,-74.0241
relay.dwadziesciajeden.pl,52.2297,21.0122
relay.satlantis.io,32.8769,-80.0114
nostr.pbfs.io,50.4754,12.3683
freelay.sovbit.host,64.1476,-21.9392
articles.layer3.news,37.3387,-121.885
nostr.na.social,43.6532,-79.3832
relay.fountain.fm,43.6532,-79.3832
dev.relay.stream,43.6532,-79.3832
nostr.n7ekb.net,36.1527,-95.9902
relay5.bitransfer.org,43.6532,-79.3832
relay.og.coop,43.6532,-79.3832
nostr-server-production.up.railway.app,45.5019,-73.5674
bucket.coracle.social,37.7775,-122.397
relay.gulugulu.moe,43.6532,-79.3832
relay.nostr-check.me,43.6532,-79.3832
nostr.faultables.net,43.6532,-79.3832
strfry.openhoofd.nl,51.9229,4.40833
nostr.rblb.it:7777,43.7094,10.6582
relay.nostrcheck.me,43.6532,-79.3832
0x-nostr-relay.fly.dev,48.8575,2.35138
nostr.thalheim.io,60.1699,24.9384
relay-nl.zombi.cloudrodion.com,50.8943,6.06237
relay.shadowbip.com,51.5072,-0.127586
nostr-relay.corb.net,38.8353,-104.822
purplerelay.com,43.6532,-79.3832
nostr-pub.wellorder.net,45.5201,-122.99
herbstmeister.com,34.0549,-118.243
nostrcheck.me,43.6532,-79.3832
pyramid.nostr.technology,52.3947,4.66399
nostr.spicyz.io,43.6532,-79.3832
nrs-02.darkcloudarcade.com,39.9526,-75.1652
nestr.nedao.ch,47.0151,6.98832
nostr.nodesmap.com,59.3327,18.0656
nittom.nostr1.com,38.6327,-90.1961
public.crostr.com,43.6532,-79.3832
relay.cypherflow.ai,48.8575,2.35138
nostr.bitczat.pl,60.1699,24.9384
relayone.geektank.ai,39.1008,-94.5811
testrelay.era21.space,43.6532,-79.3832
relay.npubhaus.com,43.6532,-79.3832
relay.bitmacro.io,48.8566,2.35222
nostr.data.haus,50.4754,12.3683
relay.credenso.cafe,43.3601,-80.3127
relay.ru.ac.th,13.7607,100.627
relay-fra.zombi.cloudrodion.com,48.8566,2.35222
nostr.chaima.info,50.1109,8.68213
nostr.mom,50.4754,12.3683

#[cfg(feature = "nostr")] use serde_json::to_string; use ...

2026-04-06T04:16:29Z

#[cfg(feature = "nostr")]
use serde_json::to_string;
use std::process::Command;
use std::path::PathBuf;
#[cfg(feature = "nostr")]
use nostr_sdk::prelude::{*, EventBuilder, Tag, Kind};
#[cfg(feature = "nostr")]
use serde_json::json;
#[cfg(feature = "nostr")]
use csv::ReaderBuilder;
#[cfg(feature = "nostr")]
use ::url::Url;
#[cfg(feature = "nostr")]
pub use frost_secp256k1_tr as frost;
#[cfg(feature = "nostr")]
use frost::keys::{KeyPackage, PublicKeyPackage, SecretShare};
#[cfg(feature = "nostr")]
use frost::round1::{SigningCommitments, SigningNonces};
#[cfg(feature = "nostr")]
use frost::round2::SignatureShare;
#[cfg(feature = "nostr")]
use frost::SigningPackage;
#[cfg(feature = "nostr")]
use rand::thread_rng;
#[cfg(feature = "nostr")]
pub use frost_secp256k1_tr as frost_bip340;

pub mod frost_mailbox_logic;

#[cfg(feature = "nostr")]
use std::collections::BTreeMap;

pub const DUMMY_BUILD_MANIFEST_ID_STR: &str = "f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0";
pub const DEFAULT_GNOSTR_KEY: &str = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
pub const DEFAULT_PICTURE_URL: &str = "https://avatars.githubusercontent.com/u/135379339?s=400&u=11cb72cccbc2b13252867099546074c50caef1ae&v=4";;
pub const DEFAULT_BANNER_URL: &str = "https://raw.githubusercontent.com/gnostr-org/gnostr-icons/refs/heads/master/banner/1024x341.png";;

pub const EMPTY_BLOB_SHA1: &str = "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391";
pub const EMPTY_BLOB_SHA256: &str = "473a0f4c3be8a93681a267e3b1e9a7dcda1185436fe141f7749120a303721813";
pub const EMPTY_BLOB_PRIVATE_KEY_NSEC: &str = "nsec1guaq7npmaz5ndqdzvl3mr6d8mndprp2rdls5ram5jys2xqmjrqfsdzhrp6";

pub const EMPTY_TREE_SHA1: &str = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
pub const EMPTY_TREE_SHA256: &str = "6ef19b41225c5369f1c104d45d8d85efa9b057b53b14b4b9b939dd74decc5321";
pub const EMPTY_TREE_PRIVATE_KEY_NSEC: &str = "nsec1dmceksfzt3fknuwpqn29mrv9a75mq4a48v2tfwde88whfhkv2vsslsc46c";

#[cfg(feature = "nostr")]
const ONLINE_RELAYS_GPS_CSV: &[u8] = include_bytes!("online_relays_gps.csv");

/// BIP-64MOD + GCC: Complete NIP-19 Identity Mapping
///
/// These constants provide the Bech32 encoded Private (NSEC) and
/// Public (NPUB) keys for Git-standard empty states.
#[cfg(feature = "nostr")]
pub struct GitEmptyIdentity;

#[cfg(feature = "nostr")]
impl GitEmptyIdentity {
// === EMPTY BLOB IDENTITY ===
// Derived from the identity of a 0-byte file.
pub const BLOB_NSEC: &'static str = "nsec1guaq7npmaz5ndqdzvl3mr6d8mndprp2rdls5ram5jys2xqmjrqfsdzhrp6";
pub const BLOB_NPUB: &'static str = "npub180cvv07tjdrghvkyh6964p7w9vsqpf3p05868v399v86p8y6f69sq5fdp0";
pub const BLOB_HEX: &'static str = "473a0f4c3be8a93681a267e3b1e9a7dcda1185436fe141f7749120a303721813";

// === EMPTY TREE IDENTITY ===
// Derived from the identity of an empty directory.
pub const TREE_NSEC: &'static str = "nsec1dmceksfzt3fknuwpqn29mrv9a75mq4a48v2tfwde88whfhkv2vsslsc46c";
pub const TREE_NPUB: &'static str = "npub1pxmpep6yk7z6p332u9588k0vscg26rv29pynvscg26rv29pynvsq6erdfh";
pub const TREE_HEX: &'static str = "6ef19b41225c5369f1c104d45d8d85efa9b057b53b14b4b9b939dd74decc5321";

// === NULL / GENESIS IDENTITY ===
// Often used for the 'System' or 'Root' user in a new GCC chain.
// Derived from 32-bytes of zeros.
pub const NULL_NSEC: &'static str = "nsec1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqp3994m";
pub const NULL_NPUB: &'static str = "npub1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqad8gh8";
pub const NULL_HEX: &'static str = "0000000000000000000000000000000000000000000000000000000000000000";
}

/// Example usage for signature verification logic
#[cfg(feature = "nostr")]
pub mod git_empty_state {
#[cfg(feature = "nostr")]
use crate::GitEmptyIdentity;

/// Returns the expected public key for a given Git object hash.
/// Useful for automated verification of 'Empty State' transitions.
pub fn get_expected_npub(git_hash: &str) -> Option<&'static str> {
match git_hash {
GitEmptyIdentity::BLOB_HEX => Some(GitEmptyIdentity::BLOB_NPUB),
GitEmptyIdentity::TREE_HEX => Some(GitEmptyIdentity::TREE_NPUB),
GitEmptyIdentity::NULL_HEX => Some(GitEmptyIdentity::NULL_NPUB),
_ => None,
}
}
}

#[cfg(feature = "nostr")]
pub fn get_relay_urls() -> Vec<String> {
let content = String::from_utf8_lossy(ONLINE_RELAYS_GPS_CSV);
let mut rdr = ReaderBuilder::new()
.has_headers(true)
.from_reader(content.as_bytes());

rdr.records()
.filter_map(|result| {
match result {
Ok(record) => {
record.get(0).and_then(|url_str| {
let full_url_str = if url_str.contains("://") {
url_str.to_string()
} else {
format!("wss://{}", url_str)
};
match Url::parse(&full_url_str) {
Ok(url) if url.scheme() == "wss" => Some(url.to_string()),
_ => {
eprintln!("Warning: Invalid or unsupported relay URL scheme: {}", full_url_str);
None
}
}
})
},
Err(e) => {
eprintln!("Error reading CSV record: {}", e);
None
}
}
})
.collect()
}

#[cfg(feature = "nostr")]
use std::io::Write;
#[cfg(feature = "nostr")]
use std::fs;

#[cfg(feature = "nostr")]
pub fn should_remove_relay(error_msg: &str) -> bool {
error_msg.contains("relay not connected") ||
error_msg.contains("not in web of trust") ||
error_msg.contains("blocked: not authorized") ||
error_msg.contains("timeout") ||
error_msg.contains("blocked: spam not permitted") ||
error_msg.contains("relay experienced an error trying to publish the latest event") ||
error_msg.contains("duplicate: event already broadcast")
}

#[cfg(feature = "nostr")]
pub fn write_event_json_to_file(
output_dir: &PathBuf,
filename: &str,
event: &Event,
) -> Option<()> {
let file_path = output_dir.join(filename);
if let Some(parent) = file_path.parent() {
if let Err(e) = fs::create_dir_all(parent) {
println!("cargo:warning=Failed to create parent directories for {}: {}", file_path.display(), e);
return None;
}
}
if let Err(e) = fs::File::create(&file_path).and_then(|mut file| write!(file, "{}", event.as_json())) {
println!("cargo:warning=Failed to write event JSON to file {}: {}", file_path.display(), e);
None
} else {
println!("Successfully wrote event JSON to {}", file_path.display());
Some(())
}
}

#[cfg(feature = "nostr")]
pub async fn publish_nostr_event_if_release(
client: &mut nostr_sdk::Client,
hash: String,
keys: Keys,
event_builder: EventBuilder,
_relay_urls: &mut Vec<String>,
file_path_str: &str,
output_dir: &PathBuf,
total_bytes_sent: &mut usize,
) -> Option<EventId> {
let public_key = keys.public_key().to_string();

let event = client.sign_event_builder(event_builder).await.unwrap();

match client.send_event(&event).await { Ok(event_output) => {
println!("cargo:warning=Published Nostr event for {}: {}", file_path_str, event_output.val);

let event_json_size = to_string(&event).map(|s| s.as_bytes().len()).unwrap_or(0);
// Print successful relays
for relay_url in event_output.success.iter() {
println!("cargo:warning=Successfully published to relay: {} ({} bytes)", relay_url, event_json_size);
*total_bytes_sent += event_json_size;
}
// Print failed relays and remove "unfriendly" relays from the list
for (relay_url, error_msg) in event_output.failed.iter() {
if should_remove_relay(error_msg) {
if let Err(e) = client.remove_relay(relay_url).await {
println!("cargo:warning=Failed to remove relay {}: {}", relay_url, e);
}
// println!("cargo:warning=Removed relay {}", relay_url);
}
}

let filename = format!("{}/{}/{}/{}.json", file_path_str, hash, public_key.clone(), event_output.val.to_string());
write_event_json_to_file(output_dir, &filename, &event);
Some(event_output.val)
},
Err(e) => {
println!("cargo:warning=Failed to publish Nostr event for {}: {}", file_path_str, e);
None
},
}
}

#[cfg(feature = "nostr")]
pub async fn get_repo_announcement_event(
client: &mut nostr_sdk::Client,
_keys: &Keys,
relay_urls: &Vec<String>,
repo_url: &str,
repo_name: &str,
repo_description: &str,
git_commit_hash: &str,
git_branch: &str,
output_dir: &PathBuf,
public_key_hex: &str,
) -> Option<EventId> {

let mut tags = vec![
Tag::parse(["d", repo_name].iter().map(ToString::to_string).collect::<Vec<String>>()).unwrap(),
Tag::parse(["name", repo_name].iter().map(ToString::to_string).collect::<Vec<String>>()).unwrap(),
Tag::parse(["description", repo_description].iter().map(ToString::to_string).collect::<Vec<String>>()).unwrap(),
Tag::parse(["web", repo_url].iter().map(ToString::to_string).collect::<Vec<String>>()).unwrap(),
Tag::parse(["clone", repo_url].iter().map(ToString::to_string).collect::<Vec<String>>()).unwrap(),
Tag::parse(["r", git_commit_hash, "euc"].iter().map(ToString::to_string).collect::<Vec<String>>()).unwrap(),
Tag::parse(["commit", git_commit_hash].iter().map(ToString::to_string).collect::<Vec<String>>()).unwrap(),
Tag::parse(["branch", git_branch].iter().map(ToString::to_string).collect::<Vec<String>>()).unwrap(),
Tag::parse(["maintainers", "gnostr"].iter().map(ToString::to_string).collect::<Vec<String>>()).unwrap(),
//Tag::parse(["t", "personal-fork"].iter().map(ToString::to_string).collect::<Vec<String>>()).unwrap(),
Tag::parse(["t", "gnostr"].iter().map(ToString::to_string).collect::<Vec<String>>()).unwrap(),
Tag::parse(["t", repo_name].iter().map(ToString::to_string).collect::<Vec<String>>()).unwrap(),
];

// Append each relay url
for relay in relay_urls {
tags.push(Tag::parse(["relays", relay].iter().map(ToString::to_string).collect::<Vec<String>>()).unwrap());
}
let event_builder = EventBuilder::new(Kind::Custom(30617), repo_description).tags(tags);
let event = client.sign_event_builder(event_builder).await.unwrap();

match client.send_event(&event).await {
Ok(event_output) => {
println!("cargo:warning=Published Nostr Repository Announcement for {}: {}", repo_name, event_output.val);

let filename = format!("30617/{}/{}/{}.json", repo_name, public_key_hex, event_output.val.to_string());
write_event_json_to_file(output_dir, &filename, &event);
Some(event_output.val)
},
Err(e) => {
println!("cargo:warning=Failed to publish Nostr Repository Announcement for {}: {}", repo_name, e);
None
},
}
}

#[cfg(feature = "nostr")]
pub async fn publish_repo_patch_event(
client: &mut nostr_sdk::Client,
_keys: &Keys,
_relay_urls: &Vec<String>,
repo_url: &str,
repo_name: &str,
repo_description: &str,
git_commit_hash: &str,
git_branch: &str,
output_dir: &PathBuf,
public_key_hex: &str,
) -> Option<EventId> {

let tags = vec![
Tag::parse(["r", repo_url].iter().map(ToString::to_string).collect::<Vec<String>>()).unwrap(),
Tag::parse(["name", repo_name].iter().map(ToString::to_string).collect::<Vec<String>>()).unwrap(),
Tag::parse(["description", repo_description].iter().map(ToString::to_string).collect::<Vec<String>>()).unwrap(),
Tag::parse(["commit", git_commit_hash].iter().map(ToString::to_string).collect::<Vec<String>>()).unwrap(),
Tag::parse(["branch", git_branch].iter().map(ToString::to_string).collect::<Vec<String>>()).unwrap(),
];

let event_builder = EventBuilder::new(Kind::Custom(1617), repo_description).tags(tags);
let event = client.sign_event_builder(event_builder).await.unwrap();

match client.send_event(&event).await {
Ok(event_output) => {
println!("cargo:warning=Published Nostr Repository Announcement for {}: {}", repo_name, event_output.val);

let filename = format!("30617/{}/{}/{}.json", repo_name, public_key_hex, event_output.val.to_string());
write_event_json_to_file(output_dir, &filename, &event);
Some(event_output.val)
},
Err(e) => {
println!("cargo:warning=Failed to publish Nostr Repository Announcement for {}: {}", repo_name, e);
None
},
}
}

/// Computes the SHA-256 hash of the specified file at compile time.
///
/// This macro takes a string literal representing a file path, reads the file's bytes
/// at compile time, computes its SHA-256 hash, and returns the hash as a hex-encoded `String`.
///
/// # Examples
///
/// ```rust
/// use get_file_hash_core::get_file_hash;
/// use sha2::{Digest, Sha256};
///
/// let hash = get_file_hash!("lib.rs");
/// println!("Hash: {}", hash);
/// ```

#[macro_export]
macro_rules! get_file_hash {
($file_path:expr) => {{
let bytes = include_bytes!($file_path);
let mut hasher = Sha256::new();
hasher.update(bytes);
let result = hasher.finalize();

// Convert the GenericArray to a hex string
result
.iter()
.map(|b| format!("{:02x}", b))
.collect::<String>()
}};
}

/// Computes the SHA-256 hash of the specified file at compile time and uses it as a Nostr private key.
///
/// This macro takes a string literal representing a file path, computes its SHA-256 hash,
/// and returns a `nostr::Keys` object derived from this hash.
///
/// # Examples
///
/// ```rust
/// use get_file_hash_core::file_hash_as_nostr_private_key;
/// use sha2::{Digest, Sha256};
/// use nostr_sdk::prelude::ToBech32;
///
/// let keys = file_hash_as_nostr_private_key!("lib.rs");
/// println!("Public Key: {}", keys.public_key().to_bech32().unwrap());
/// ```
#[cfg(feature = "nostr")]
#[macro_export]
macro_rules! file_hash_as_nostr_private_key {
($file_path:expr) => {{
let hash_hex = $crate::get_file_hash!($file_path);
nostr_sdk::Keys::parse(&hash_hex).expect("Failed to create Nostr Keys from file hash")
}};
}

/// Publishes a NIP-34 repository announcement event to Nostr relays.
///
/// This macro takes Nostr keys, relay URLs, project details, a clone URL, and a file path.
/// It computes the SHA-256 hash of the file at compile time to use as the "earliest unique commit" (EUC),
/// and then publishes a Kind 30617 event.
///
/// # Examples
///
/// ```no_run
/// use get_file_hash_core::repository_announcement;
/// use get_file_hash_core::get_file_hash;
/// use nostr_sdk::Keys;
/// use sha2::{Digest, Sha256};
///
/// #[tokio::main]
/// async fn main() {
/// let keys = Keys::generate();
/// let relay_urls = vec!["wss://relay.damus.io".to_string()];
/// let project_name = "my-awesome-repo";
/// let description = "A fantastic new project.";
/// let clone_url = "git@github.com:user/my-awesome-repo.git";
///
/// repository_announcement!(
/// &keys,
/// &relay_urls,
/// project_name,
/// description,
/// clone_url,
/// "../Cargo.toml", // Use a known file in your project
/// None
/// );
/// }
#[cfg(feature = "nostr")]
#[macro_export]
macro_rules! repository_announcement {
($keys:expr, $relay_urls:expr, $project_name:expr, $description:expr, $clone_url:expr, $file_for_euc:expr) => {{
let euc_hash = $crate::get_file_hash!($file_for_euc);
// The 'd' tag value should be unique for the repository. Using the project_name for simplicity.
let d_tag_value = $project_name;
$crate::publish_repository_announcement_event(
$keys,
$relay_urls,
$project_name,
$description,
$clone_url,
&euc_hash,
d_tag_value,
None,
).await;
}};
($keys:expr, $relay_urls:expr, $project_name:expr, $description:expr, $clone_url:expr, $file_for_euc:expr, $build_manifest_event_id:expr) => {{
let euc_hash = $crate::get_file_hash!($file_for_euc);
let d_tag_value = $project_name;
$crate::publish_repository_announcement_event(
$keys,
$relay_urls,
$project_name,
$description,
$clone_url,
&euc_hash,
d_tag_value,
$build_manifest_event_id, // Correct: Pass directly
).await;
}};
}

/// Publishes a NIP-34 patch event to Nostr relays.
///
/// This macro takes Nostr keys, relay URLs, the repository's d-tag value,
/// the commit ID the patch applies to, and the path to the patch file.
/// The content of the patch file is included directly in the event.
///
/// # Examples
///
/// ```no_run
/// use get_file_hash_core::publish_patch;
/// use nostr_sdk::Keys;
///
/// #[tokio::main]
/// async fn main() {
/// let keys = Keys::generate();
/// let relay_urls = vec!["wss://relay.damus.io".to_string()];
/// let d_tag = "my-awesome-repo";
/// let commit_id = "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0"; // Example commit ID
///
/// publish_patch!(
/// &keys,
/// &relay_urls,
/// d_tag,
/// commit_id,
/// "lib.rs" // Use an existing file for the patch content
/// );
/// }
/// ```
#[cfg(feature = "nostr")]
#[macro_export]
macro_rules! publish_patch {
($keys:expr, $relay_urls:expr, $d_tag_value:expr, $commit_id:expr, $patch_file_path:expr) => {{
let patch_content = include_str!($patch_file_path);
$crate::publish_patch_event(
$keys,
$relay_urls,
$d_tag_value,
$commit_id,
patch_content,
None, // Pass None for build_manifest_event_id
).await;
}};
($keys:expr, $relay_urls:expr, $d_tag_value:expr, $commit_id:expr, $patch_file_path:expr, $build_manifest_event_id:expr) => {{
let patch_content = include_str!($patch_file_path);
$crate::publish_patch_event(
$keys,
$relay_urls,
$d_tag_value,
$commit_id,
patch_content,
$build_manifest_event_id, // Pass directly, macro arg should be Option<&EventId>
).await;
}};
}

/// Publishes a NIP-34 pull request event to Nostr relays.
///
/// This macro takes Nostr keys, relay URLs, the repository's d-tag value,
/// the commit ID of the pull request, a clone URL where the work can be fetched,
/// and an optional title for the pull request.
///
/// # Examples
///
/// ```no_run
/// use get_file_hash_core::publish_pull_request;
/// use nostr_sdk::Keys;
///
/// #[tokio::main]
/// async fn main() {
/// let keys = Keys::generate();
/// let relay_urls = vec!["wss://relay.damus.io".to_string()];
/// let d_tag = "my-awesome-repo";
/// let commit_id = "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0";
/// let clone_url = "git@github.com:user/my-feature-branch.git";
/// let title = Some("Feat: Add new awesome feature");
///
/// publish_pull_request!(
/// &keys,
/// &relay_urls,
/// d_tag,
/// commit_id,
/// clone_url,
/// title,
/// None
/// );
/// }
/// ```
#[cfg(feature = "nostr")]
#[macro_export]
macro_rules! publish_pull_request {
// 5 args: No title, no build_manifest_event_id
($keys:expr, $relay_urls:expr, $d_tag_value:expr, $commit_id:expr, $clone_url:expr) => {{
$crate::publish_pull_request_event(
$keys, $relay_urls, $d_tag_value, $commit_id, $clone_url,
None, // title: Option<&str>
None, // build_manifest_event_id: Option<&EventId>
).await;
}};

// 6 args: With title (Option<&str>), no build_manifest_event_id
($keys:expr, $relay_urls:expr, $d_tag_value:expr, $commit_id:expr, $clone_url:expr, $title:expr) => {{
$crate::publish_pull_request_event(
$keys, $relay_urls, $d_tag_value, $commit_id, $clone_url,
$title, // title: Option<&str>
None, // build_manifest_event_id: Option<&EventId>
).await;
}};

// 7 args: With title (Option<&str>), with build_manifest_event_id (Option<&EventId>)
// This needs to be before the 6-arg arm that passes a single Option for build_manifest_event_id if it's not None.
($keys:expr, $relay_urls:expr, $d_tag_value:expr, $commit_id:expr, $clone_url:expr, $title:expr, $build_manifest_event_id:expr) => {{
$crate::publish_pull_request_event(
$keys, $relay_urls, $d_tag_value, $commit_id, $clone_url,
$title, // title: Option<&str>
$build_manifest_event_id, // build_manifest_event_id: Option<&EventId>
).await;
}};

// 6 args: No title, with build_manifest_event_id (Option<&EventId>)
// This must be after the 7-arg arm to avoid ambiguity.
// The example needs to explicitly pass None for title.
($keys:expr, $relay_urls:expr, $d_tag_value:expr, $commit_id:expr, $clone_url:expr, _none_title:tt, $build_manifest_event_id:expr) => {{ // _none_title as tt to match None
$crate::publish_pull_request_event(
$keys, $relay_urls, $d_tag_value, $commit_id, $clone_url,
None, // title: Option<&str>
$build_manifest_event_id, // build_manifest_event_id: Option<&EventId>
).await;
}};
}

/// Publishes a NIP-34 PR update event to Nostr relays.
///
/// This macro takes Nostr keys, relay URLs, the repository's d-tag value,
/// the event ID of the original pull request, the new commit ID,
/// and the new clone URL.
///
/// # Examples
///
/// ```no_run
/// use get_file_hash_core::publish_pr_update;
/// use nostr_sdk::Keys;
/// use nostr_sdk::EventId;
/// use std::str::FromStr;
///
/// #[tokio::main]
/// async fn main() {
/// let keys = Keys::generate();
/// let relay_urls = vec!["wss://relay.damus.io".to_string()];
/// let d_tag = "my-awesome-repo";
/// let pr_event_id = EventId::from_str("f6e4d6a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9").unwrap(); // Example PR Event ID
/// let updated_commit_id = "z9y8x7w6v5u4t3s2r1q0p9o8n7m6l5k4j3i2h1g0";
/// let updated_clone_url = "git@github.com:user/my-feature-branch-v2.git";
///
/// publish_pr_update!(
/// &keys,
/// &relay_urls,
/// d_tag,
/// &pr_event_id,
/// updated_commit_id,
/// updated_clone_url
/// );
/// }
/// ```
#[cfg(feature = "nostr")]
#[macro_export]
macro_rules! publish_pr_update {
($keys:expr, $relay_urls:expr, $d_tag_value:expr, $pr_event_id:expr, $updated_commit_id:expr, $updated_clone_url:expr) => {{
$crate::publish_pr_update_event(
$keys,
$relay_urls,
$d_tag_value,
$pr_event_id,
$updated_commit_id,
$updated_clone_url,
None, // Pass None for build_manifest_event_id
).await;
}};
($keys:expr, $relay_urls:expr, $d_tag_value:expr, $pr_event_id:expr, $updated_commit_id:expr, $updated_clone_url:expr, $build_manifest_event_id:expr) => {{
$crate::publish_pr_update_event(
$keys,
$relay_urls,
$d_tag_value,
$pr_event_id,
$updated_commit_id,
$updated_clone_url,
$build_manifest_event_id,

).await;
}};
}

/// Publishes a NIP-34 repository state event to Nostr relays.
///
/// This macro takes Nostr keys, relay URLs, the repository's d-tag value,
/// the branch name, and the commit ID for that branch.
///
/// # Examples
///
/// ```no_run
/// use get_file_hash_core::publish_repository_state;
/// use nostr_sdk::Keys;
///
/// #[tokio::main]
/// async fn main() {
/// let keys = Keys::generate();
/// let relay_urls = vec!["wss://relay.damus.io".to_string()];
/// let d_tag = "my-awesome-repo";
/// let branch_name = "main";
/// let commit_id = "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0";
///
/// publish_repository_state!(
/// &keys,
/// &relay_urls,
/// d_tag,
/// branch_name,
/// commit_id
/// );
/// }
/// ```
#[cfg(feature = "nostr")]
#[macro_export]
macro_rules! publish_repository_state {
($keys:expr, $relay_urls:expr, $d_tag_value:expr, $branch_name:expr, $commit_id:expr) => {{
$crate::publish_repository_state_event(
$keys,
$relay_urls,
$d_tag_value,
$branch_name,
$commit_id,
).await;
}};
}

/// Publishes a NIP-34 issue event to Nostr relays.
///
/// This macro takes Nostr keys, relay URLs, the repository's d-tag value,
/// a unique issue ID, the issue's title, and its content (markdown).
///
/// # Examples
///
/// ```no_run
/// use get_file_hash_core::publish_issue;
/// use nostr_sdk::Keys;
///
/// #[tokio::main]
/// async fn main() {
/// let keys = Keys::generate();
/// let relay_urls = vec!["wss://relay.damus.io".to_string()];
/// let d_tag = "my-awesome-repo";
/// let issue_id = "123";
/// let title = "Bug: Fix authentication flow";
/// let content = "The authentication flow is currently broken when users try to log in with invalid credentials. It crashes instead of showing an error message.";
///
/// publish_issue!(
/// &keys,
/// &relay_urls,
/// d_tag,
/// issue_id,
/// title,
/// content
/// );
/// }
/// ```
/// ```
#[cfg(feature = "nostr")]
#[macro_export]
macro_rules! publish_issue {
($keys:expr, $relay_urls:expr, $d_tag_value:expr, $issue_id:expr, $title:expr, $content:expr) => {{
$crate::publish_issue_event(
$keys,
$relay_urls,
$d_tag_value,
$issue_id,
$title,
$content,
None, // Pass None for build_manifest_event_id
).await;
}};
($keys:expr, $relay_urls:expr, $d_tag_value:expr, $issue_id:expr, $title:expr, $content:expr, $build_manifest_event_id:expr) => {{
$crate::publish_issue_event(
$keys,
$relay_urls,
$d_tag_value,
$issue_id,
$title,
$content,
$build_manifest_event_id, // Pass Option<&EventId> directly
).await;
}};
}

pub fn get_git_tracked_files(dir: &PathBuf) -> Vec<String> {
match Command::new("git")
.arg("ls-files")
.current_dir(dir)
.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::null())
.output()
{
Ok(output) if output.status.success() && !output.stdout.is_empty() => {
String::from_utf8_lossy(&output.stdout)
.lines()
.filter_map(|line| Some(String::from(line)))
.collect()
}
Ok(output) => {
println!("cargo:warning=git ls-files failed or returned empty. Status: {:?}, Stderr: {}",
output.status, String::from_utf8_lossy(&output.stderr));
Vec::new()
}
Err(e) => {
println!("cargo:warning=Failed to execute git ls-files: {}", e);
Vec::new()
}
}
}

#[cfg(feature = "nostr")]
pub async fn publish_metadata_event(
keys: &Keys,
relay_urls: &[String],
picture_url: &str,
banner_url: &str,
file_path_str: &str,
) {
let client = nostr_sdk::Client::new(keys.clone());

for relay_url in relay_urls {
if let Err(e) = client.add_relay(relay_url).await {
println!("cargo:warning=Failed to add relay for metadata {}: {}", relay_url, e);
}
}
client.connect().await;

let metadata_json = json!({
"picture": picture_url,
"banner": banner_url,
"name": file_path_str,
"about": format!("Metadata for file event: {}", file_path_str),
});

let metadata = serde_json::from_str::<nostr_sdk::Metadata>(&metadata_json.to_string())
.expect("Failed to parse metadata JSON");

match client.send_event_builder(EventBuilder::metadata(&metadata)).await {
Ok(_event_id) => {
//println!("cargo:warning=Published Nostr metadata event for {}: {:?}", file_path_str, event_id);
}
Err(e) => {
println!("cargo:warning=Failed to publish Nostr metadata event for {}: {}", file_path_str, e);
}
}
}

#[cfg(feature = "nostr")]
pub async fn publish_repository_announcement_event(
keys: &Keys,
relay_urls: &[String],
project_name: &str,
description: &str,
clone_url: &str,
euc: &str, // Earliest Unique Commit hash
d_tag_value: &str, // d-tag value
build_manifest_event_id: Option<&EventId>,
) {
let client = nostr_sdk::Client::new(keys.clone());

for relay_url in relay_urls {
if let Err(e) = client.add_relay(relay_url).await {
println!("cargo:warning=Failed to add relay for repository announcement {}: {}", relay_url, e);
}
}
client.connect().await;

let mut tags = vec![
Tag::parse(["name", project_name]).expect("Failed to create name tag"),
Tag::parse(["description", description]).expect("Failed to create description tag"),
Tag::parse(["clone", clone_url]).expect("Failed to create clone tag"),
Tag::custom("euc".into(), vec![euc.to_string()]),
Tag::custom("d".into(), vec![d_tag_value.to_string()]), // NIP-33 d-tag
];

if let Some(event_id) = build_manifest_event_id {
tags.push(Tag::event(*event_id));
}

let event_builder = EventBuilder::new(
Kind::Custom(30617), // NIP-34 Repository Announcement kind
"", // Content is empty for repository announcement
).tags(tags);

match client.send_event_builder(event_builder).await {
Ok(event_id) => {
println!("cargo:warning=Published NIP-34 Repository Announcement for {}. Event ID (raw): {:?}, Event ID (bech32): {}", project_name, event_id, event_id.to_bech32().unwrap());
}
Err(e) => {
println!("cargo:warning=Failed to publish NIP-34 Repository Announcement for {}: {}", project_name, e);
}
}
}

#[cfg(feature = "nostr")]
pub async fn publish_patch_event(
keys: &Keys,
relay_urls: &[String],
d_tag_value: &str,
commit_id: &str,
patch_content: &str,
build_manifest_event_id: Option<&EventId>,
) {
let client = nostr_sdk::Client::new(keys.clone());

for relay_url in relay_urls {
if let Err(e) = client.add_relay(relay_url).await {
println!("cargo:warning=Failed to add relay for patch {}: {}", relay_url, e);
}
}
client.connect().await;

let mut tags = vec![
Tag::custom("d".into(), vec![d_tag_value.to_string()]), // Repository d-tag
Tag::parse(["commit", commit_id]).expect("Failed to create commit tag"),
];

if let Some(event_id) = build_manifest_event_id {
tags.push(Tag::event(*event_id));
}

let event_builder = EventBuilder::new(
Kind::Custom(1617), // NIP-34 Patch kind
patch_content,
).tags(tags);

match client.send_event_builder(event_builder).await {
Ok(event_id) => {
println!("cargo:warning=\nPublished NIP-34 Patch event for commit {}.\nEvent ID (raw): {:?},\nEvent ID (bech32): {}", commit_id, event_id, event_id.to_bech32().unwrap());
}
Err(e) => {
println!("cargo:warning=Failed to publish NIP-34 Patch event for commit {}: {}", commit_id, e);
}
}
}

#[cfg(feature = "nostr")]
pub async fn publish_pull_request_event(
keys: &Keys,
relay_urls: &[String],
d_tag_value: &str,
commit_id: &str,
clone_url: &str,
title: Option<&str>,
build_manifest_event_id: Option<&EventId>,
) {
let client = nostr_sdk::Client::new(keys.clone());

for relay_url in relay_urls {
if let Err(e) = client.add_relay(relay_url).await {
println!("cargo:warning=Failed to add relay for pull request {}: {}", relay_url, e);
}
}
client.connect().await;

let mut tags = vec![
Tag::custom("d".into(), vec![d_tag_value.to_string()]), // Repository d-tag
Tag::parse(["commit", commit_id]).expect("Failed to create commit tag"),
Tag::parse(["clone", clone_url]).expect("Failed to create clone tag"),
];

if let Some(t) = title {
tags.push(Tag::parse(["title", t]).expect("Failed to create title tag"));
}

if let Some(event_id) = build_manifest_event_id {
tags.push(Tag::event(*event_id));
}

let event_builder = EventBuilder::new(
Kind::Custom(1618), // NIP-34 Pull Request kind
"gnostr patch", // Content can be empty or a description for the PR
).tags(tags);

match client.send_event_builder(event_builder).await {
Ok(event_id) => {
println!("cargo:warning=Published NIP-34 Pull Request event for commit {}. Event ID (raw): {:?}, Event ID (bech32): {}", commit_id, event_id, event_id.to_bech32().unwrap());
}
Err(e) => {
println!("cargo:warning=Failed to publish NIP-34 Pull Request event for commit {}: {}", commit_id, e);
}
}
}

#[cfg(feature = "nostr")]
pub async fn publish_pr_update_event(
keys: &Keys,
relay_urls: &[String],
d_tag_value: &str,
pr_event_id: &EventId,
updated_commit_id: &str,
updated_clone_url: &str,
build_manifest_event_id: Option<&EventId>,
) {
let client = nostr_sdk::Client::new(keys.clone());

for relay_url in relay_urls {
if let Err(e) = client.add_relay(relay_url).await {
println!("cargo:warning=Failed to add relay for PR update {}: {}", relay_url, e);
}
}
client.connect().await;

let mut tags = vec![
Tag::custom("d".into(), vec![d_tag_value.to_string()]), // Repository d-tag
Tag::parse(["p", pr_event_id.to_string().as_str()]).expect("Failed to create PR event ID tag"),
Tag::parse(["commit", updated_commit_id]).expect("Failed to create updated commit ID tag"),
Tag::parse(["clone", updated_clone_url]).expect("Failed to create updated clone URL tag"),
];

if let Some(event_id) = build_manifest_event_id {
tags.push(Tag::event(*event_id));
}

let event_builder = EventBuilder::new(
Kind::Custom(1619), // NIP-34 PR Update kind
"", // Content is empty for PR update
).tags(tags);

match client.send_event_builder(event_builder).await {
Ok(event_id) => {
println!("cargo:warning=Published NIP-34 PR Update event for PR {} (raw: {:?}). Event ID (raw): {:?}, Event ID (bech32): {}", pr_event_id.to_bech32().unwrap(), pr_event_id, event_id, event_id.to_bech32().unwrap());
}
Err(e) => {
println!("cargo:warning=Failed to publish NIP-34 PR Update event for PR {}: {}", pr_event_id.to_string(), e);
}
}
}

#[cfg(feature = "nostr")]
pub async fn publish_repository_state_event(
keys: &Keys,
relay_urls: &[String],
d_tag_value: &str,
branch_name: &str,
commit_id: &str,
) {
let client = nostr_sdk::Client::new(keys.clone());

for relay_url in relay_urls {
if let Err(e) = client.add_relay(relay_url).await {
println!("cargo:warning=Failed to add relay for repository state {}: {}", relay_url, e);
}
}
client.connect().await;

let event_builder = EventBuilder::new(
Kind::Custom(30618), // NIP-34 Repository State kind
"", // Content is empty for repository state
).tags(vec![
Tag::custom("d".into(), vec![d_tag_value.to_string()]), // Repository d-tag
Tag::parse(["name", branch_name]).expect("Failed to create branch name tag"),
Tag::parse(["commit", commit_id]).expect("Failed to create commit ID tag"),
]);

match client.send_event_builder(event_builder).await {
Ok(event_id) => {
println!("cargo:warning=Published NIP-34 Repository State event for branch {} (commit {}). Event ID (raw): {:?}, Event ID (bech32): {}", branch_name, commit_id, event_id, event_id.to_bech32().unwrap());
}
Err(e) => {
println!("cargo:warning=Failed to publish NIP-34 Repository State event for branch {} (commit {}): {}", branch_name, commit_id, e);
}
}
}

#[cfg(feature = "nostr")]
pub async fn publish_issue_event(
keys: &Keys,
relay_urls: &[String],
d_tag_value: &str,
issue_id: &str, // Unique identifier for the issue
title: &str,
content: &str,
build_manifest_event_id: Option<&EventId>,
) {
let client = nostr_sdk::Client::new(keys.clone());

for relay_url in relay_urls {
if let Err(e) = client.add_relay(relay_url).await {
println!("cargo:warning=Failed to add relay for issue {}: {}", relay_url, e);
}
}
client.connect().await;

let mut tags = vec![
Tag::custom("d".into(), vec![d_tag_value.to_string()]), // Repository d-tag
Tag::parse(["i", issue_id]).expect("Failed to create issue ID tag"),
Tag::parse(["title", title]).expect("Failed to create title tag"),
];

if let Some(event_id) = build_manifest_event_id {
tags.push(Tag::event(*event_id));
}

let event_builder = EventBuilder::new(
Kind::Custom(1621), // NIP-34 Issue kind
content,
).tags(tags);

match client.send_event_builder(event_builder).await {
Ok(event_id) => {
println!("cargo:warning=Published NIP-34 Issue event for issue {} ({}). Event ID (raw): {:?}, Event ID (bech32): {}", issue_id, title, event_id, event_id.to_bech32().unwrap());
}
Err(e) => {
println!("cargo:warning=Failed to publish NIP-34 Issue event for issue {} ({}): {}", issue_id, title, e);
}
}
}

#[cfg(feature = "nostr")]
pub fn generate_frost_keys(
max_signers: u16,
min_signers: u16,
) -> Result<(BTreeMap<frost::Identifier, SecretShare>, PublicKeyPackage), Box<dyn std::error::Error>> { let mut rng = thread_rng();
let (shares, pubkey_package) = frost::keys::generate_with_dealer(
max_signers,
min_signers,
frost::keys::IdentifierList::Default,
&mut rng,
)?;
Ok((shares, pubkey_package))
}

#[cfg(feature = "nostr")]
pub fn create_frost_commitment(
secret_share: &SecretShare,
) -> (SigningNonces, SigningCommitments) {
let mut rng = thread_rng();
frost::round1::commit(secret_share.signing_share(), &mut rng)
}

#[cfg(feature = "nostr")]
pub fn create_signing_package(
commitments: BTreeMap<frost::Identifier, SigningCommitments>,
message: &[u8],
) -> SigningPackage {
frost::SigningPackage::new(commitments, message)
}

#[cfg(feature = "nostr")]
pub fn generate_signature_share(
signing_package: &SigningPackage,
nonces: &SigningNonces,
secret_share: &SecretShare,
) -> Result<SignatureShare, Box<dyn std::error::Error>> {
let key_package: KeyPackage = secret_share.clone().try_into()?;
Ok(frost::round2::sign(signing_package, nonces, &key_package)?)
}

#[cfg(feature = "nostr")]
pub fn aggregate_signature_shares(
signing_package: &SigningPackage,
signature_shares: &BTreeMap<frost::Identifier, SignatureShare>,
pubkey_package: &PublicKeyPackage,
) -> Result<frost_secp256k1_tr::Signature, Box<dyn std::error::Error>> {
Ok(frost::aggregate(signing_package, signature_shares, pubkey_package)?)
}

#[cfg(feature = "nostr")]
pub fn verify_frost_signature(
group_public_key: &frost_secp256k1_tr::VerifyingKey,
message: &[u8],
signature: &frost_secp256k1_tr::Signature,
) -> Result<(), Box<dyn std::error::Error>> {
Ok(group_public_key.verify(message, signature)?)
}
#[cfg(test)]
mod tests {
#[cfg(feature = "nostr")]
use serial_test::serial;
#[cfg(feature = "nostr")]
use std::collections::BTreeMap;
use std::fs::File;
use std::io::Write;
use sha2::{Digest, Sha256};
use tempfile;
use super::get_git_tracked_files;
#[cfg(feature = "nostr")]
use super::frost;
use std::process::Command;
#[cfg(feature = "nostr")]
use nostr_sdk::EventId;
#[cfg(feature = "nostr")]
use std::str::FromStr;

// Test for get_file_hash! macro
#[test]
fn test_get_file_hash() {
let dir = tempfile::tempdir().unwrap();
let file_path = dir.path().join("test_file.txt");
let content = "Hello, world!";
File::create(&file_path).unwrap().write_all(content.as_bytes()).unwrap();

// The macro expects a string literal, so we need to construct the path at compile time.
// This is a limitation for testing, normally you'd use it with a known file.
// For testing, we'll manually verify a file known to be in the project.
// Let's test `lib.rs` itself for a more realistic scenario.
let macro_hash = get_file_hash!("lib.rs");

// We will assert on a known file within the crate.
let bytes = include_bytes!("lib.rs");
let mut hasher_manual = Sha256::new();
hasher_manual.update(bytes);
let expected_hash_lib_rs = hasher_manual.finalize()
.iter()
.map(|b| format!("{:02x}", b))
.collect::<String>();

assert_eq!(macro_hash, expected_hash_lib_rs);

// Test with another known file, e.g., Cargo.toml of the core crate
let cargo_toml_hash = get_file_hash!("../Cargo.toml");
let cargo_toml_bytes = include_bytes!("../Cargo.toml");
let mut cargo_toml_hasher = Sha256::new();
cargo_toml_hasher.update(cargo_toml_bytes);
let expected_cargo_toml_hash = cargo_toml_hasher.finalize()
.iter()
.map(|b| format!("{:02x}", b))
.collect::<String>();
assert_eq!(cargo_toml_hash, expected_cargo_toml_hash);
}

#[test]
fn test_get_git_tracked_files() {
let dir = tempfile::tempdir().unwrap();
let repo_path = dir.path();

// Initialize a git repository
let _ = Command::new("git")
.arg("init")
.current_dir(repo_path)
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.output()
.expect("Failed to initialize git repo");

// Create some files
let file1_path = repo_path.join("file1.txt");
File::create(&file1_path).unwrap().write_all(b"content1").unwrap();
let file2_path = repo_path.join("file2.txt");
File::create(&file2_path).unwrap().write_all(b"content2").unwrap();

// Add and commit files
let _ = Command::new("git")
.arg("add")
.arg(".")
.current_dir(repo_path)
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.output()
.expect("Failed to git add files");
let _ = Command::new("git")
.arg("commit")
.arg("-m")
.arg("Initial commit")
.current_dir(repo_path)
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.output()
.expect("Failed to git commit");

let tracked_files = get_git_tracked_files(&repo_path.to_path_buf());
assert_eq!(tracked_files.len(), 2);
assert!(tracked_files.contains(&"file1.txt".to_string()));
assert!(tracked_files.contains(&"file2.txt".to_string()));
}

// #[cfg(feature = "nostr")]
// #[test]
// fn test_file_hash_as_nostr_private_key() {
// use super::file_hash_as_nostr_private_key;
// // use std::fs::{File, remove_file};
// // use std::io::Write;
// // use tempfile::tempdir; // Not needed as we're using a literal path
// use nostr_sdk::prelude::ToBech32;

// let file_path = PathBuf::from("test_nostr_file_for_macro.txt");
// let content = "Nostr test content!";
// File::create(&file_path).unwrap().write_all(content.as_bytes()).unwrap();

// let keys = file_hash_as_nostr_private_key!("test_nostr_file_for_macro.txt");

// assert!(!keys.public_key().to_bech32().unwrap().is_empty());

// remove_file(&file_path).unwrap();
// }

#[cfg(feature = "nostr")]
#[tokio::test]
async fn test_publish_metadata_event_tr() {
use super::publish_metadata_event;
use nostr_sdk::Keys;

let keys = Keys::parse(super::DEFAULT_GNOSTR_KEY).expect("Failed to create Nostr Keys from DEFAULT_GNOSTR_KEY");
let picture_url = super::DEFAULT_PICTURE_URL;
let banner_url = super::DEFAULT_BANNER_URL;
let file_path_str = "test_file.txt";

// This test primarily checks that the function doesn't panic
// and goes through its execution path.
// Actual publishing success depends on external network conditions.
let relay_urls = super::get_relay_urls();
publish_metadata_event(
&keys,
&relay_urls,
picture_url,
banner_url,
file_path_str,
).await;
}

#[cfg(feature = "nostr")]
#[tokio::test]
#[serial]
async fn test_repository_announcement_event_tr() {
use super::get_relay_urls;
use nostr_sdk::{Keys, EventId};
use std::str::FromStr;

let keys = Keys::parse(super::DEFAULT_GNOSTR_KEY).expect("Failed to create Nostr Keys from DEFAULT_GNOSTR_KEY");
let relay_urls = get_relay_urls();
let project_name = "test-nip34-repo";
let description = "A test repository for NIP-34 announcements.";
let clone_url = "git@example.com:test/test-nip34-repo.git";
let _dummy_build_manifest_id = EventId::from_str(super::DUMMY_BUILD_MANIFEST_ID_STR).unwrap();
let _file_for_euc = "Cargo.toml"; // Use a known file in the project, as required by include_bytes!

// This test primarily checks that the macro and function compile and execute without panicking.
// Actual publishing success depends on external network conditions.
super::publish_metadata_event(
&keys,
&relay_urls,
"https://example.com/test_repo_announcement_picture.jpg";,
"https://example.com/test_repo_announcement_banner.jpg";,
"test_repository_announcement_event_metadata",
).await;

let dummy_build_manifest_id = EventId::from_str(super::DUMMY_BUILD_MANIFEST_ID_STR).unwrap();

repository_announcement!(
&keys,
&relay_urls,
project_name,
description,
clone_url,
"../Cargo.toml", // Pass the string literal directly, correcting path for include_bytes!
Some(&dummy_build_manifest_id)
);
}

#[cfg(feature = "nostr")]
#[tokio::test]
async fn test_publish_patch_event_tr() {
use super::{get_relay_urls, DEFAULT_PICTURE_URL, DEFAULT_BANNER_URL};
use nostr_sdk::Keys;

let keys = Keys::parse(super::DEFAULT_GNOSTR_KEY).expect("Failed to create Nostr Keys from DEFAULT_GNOSTR_KEY");
let relay_urls = get_relay_urls();
let d_tag = "test-repo-for-patch";
let commit_id = "fedcba9876543210fedcba9876543210fedcba";

// This test primarily checks that the macro and function compile and execute without panicking.
// Actual publishing success depends on external network conditions.
super::publish_metadata_event(
&keys,
&relay_urls,
DEFAULT_PICTURE_URL,
DEFAULT_BANNER_URL,
"test_publish_patch_event_metadata",
).await;

let dummy_build_manifest_id = EventId::from_str(super::DUMMY_BUILD_MANIFEST_ID_STR).unwrap();
publish_patch!(
&keys,
&relay_urls,
d_tag,
commit_id,
"lib.rs", // Use an existing file for the patch content
Some(&dummy_build_manifest_id)
); }

#[cfg(feature = "nostr")]
#[tokio::test]
async fn test_publish_pull_request_event_tr() {
use super::get_relay_urls;
use nostr_sdk::Keys;

let keys = Keys::parse(super::DEFAULT_GNOSTR_KEY).expect("Failed to create Nostr Keys from DEFAULT_GNOSTR_KEY");
let relay_urls = get_relay_urls();
let d_tag = "test-repo-for-pr";
let commit_id = "0123456789abcdef0123456789abcdef01234567";
let clone_url = "git@example.com:test/pr-branch.git";
let title = Some("Feat: Implement NIP-34 PR");
let dummy_build_manifest_id = EventId::from_str(super::DUMMY_BUILD_MANIFEST_ID_STR).unwrap();

super::publish_metadata_event(
&keys,
&relay_urls,
"https://example.com/test_pr_picture.jpg";,
"https://example.com/test_pr_banner.jpg";,
"test_publish_pull_request_event_metadata",
).await;

// Test with a title
publish_pull_request!(
&keys,
&relay_urls,
d_tag,
commit_id,
clone_url,
Some(title.unwrap()),
Some(&dummy_build_manifest_id)
);
// Test without a title
publish_pull_request!(
&keys,
&relay_urls,
d_tag,
commit_id,
clone_url
);
}

#[cfg(feature = "nostr")]
#[tokio::test]
async fn test_publish_pr_update_event_tr() {
use super::get_relay_urls;
use nostr_sdk::{Keys, EventId};
use std::str::FromStr;

let keys = Keys::parse(super::DEFAULT_GNOSTR_KEY).expect("Failed to create Nostr Keys from DEFAULT_GNOSTR_KEY");
let relay_urls = get_relay_urls();
let d_tag = "test-repo-for-pr-update";
let pr_event_id = EventId::from_str("f6e4d6a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9").unwrap(); // Placeholder EventId
let updated_commit_id = "z9y8x7w6v5u4t3s2r1q0p9o8n7m6l5k4j3i2h1g0";
let updated_clone_url = "git@example.com:test/pr-branch-updated.git";
let dummy_build_manifest_id = EventId::from_str(super::DUMMY_BUILD_MANIFEST_ID_STR).unwrap();

// This test primarily checks that the macro and function compile and execute without panicking.
// Actual publishing success depends on external network conditions.
super::publish_metadata_event(
&keys,
&relay_urls,
"https://example.com/test_pr_update_picture.jpg";,
"https://example.com/test_pr_update_banner.jpg";,
"test_publish_pr_update_event_metadata",
).await;

publish_pr_update!(
&keys,
&relay_urls,
d_tag,
&pr_event_id, // Pass a reference to pr_event_id
updated_commit_id,
updated_clone_url,
Some(&dummy_build_manifest_id)
); }

#[cfg(feature = "nostr")]
#[tokio::test]
async fn test_publish_repository_state_event() {
use super::get_relay_urls;
use nostr_sdk::Keys;

let keys = Keys::parse(super::DEFAULT_GNOSTR_KEY).expect("Failed to create Nostr Keys from DEFAULT_GNOSTR_KEY");
let relay_urls = get_relay_urls();
let d_tag = "test-repo-for-state";
let branch_name = "main";
let commit_id = "abcde12345abcde12345abcde12345abcde12345";
use nostr_sdk::EventId;
use std::str::FromStr;
let _dummy_build_manifest_id = EventId::from_str(super::DUMMY_BUILD_MANIFEST_ID_STR).unwrap();

// This test primarily checks that the macro and function compile and execute without panicking.
// Actual publishing success depends on external network conditions.
super::publish_metadata_event(
&keys,
&relay_urls,
"https://example.com/test_repo_state_picture.jpg";,
"https://example.com/test_repo_state_banner.jpg";,
"test_publish_repository_state_event_metadata",
).await;

publish_repository_state!(
&keys,
&relay_urls,
d_tag,
branch_name,
commit_id
); }

// Test for get_file_hash! macro
#[test]
fn test_get_file_hash_tr() {
let dir = tempfile::tempdir().unwrap();
let file_path = dir.path().join("test_file.txt");
let content = "Hello, world!";
File::create(&file_path).unwrap().write_all(content.as_bytes()).unwrap();

// The macro expects a string literal, so we need to construct the path at compile time.
// This is a limitation for testing, normally you'd use it with a known file.
// For testing, we'll manually verify a file known to be in the project.
// Let's test `lib.rs` itself for a more realistic scenario.
let macro_hash = get_file_hash!("lib.rs");

// We will assert on a known file within the crate.
let bytes = include_bytes!("lib.rs");
let mut hasher_manual = Sha256::new();
hasher_manual.update(bytes);
let expected_hash_lib_rs = hasher_manual.finalize()
.iter()
.map(|b| format!("{:02x}", b))
.collect::<String>();

assert_eq!(macro_hash, expected_hash_lib_rs);

// Test with another known file, e.g., Cargo.toml of the core crate
let cargo_toml_hash = get_file_hash!("../Cargo.toml");
let cargo_toml_bytes = include_bytes!("../Cargo.toml");
let mut cargo_toml_hasher = Sha256::new();
cargo_toml_hasher.update(cargo_toml_bytes);
let expected_cargo_toml_hash = cargo_toml_hasher.finalize()
.iter()
.map(|b| format!("{:02x}", b))
.collect::<String>();
assert_eq!(cargo_toml_hash, expected_cargo_toml_hash);
}

#[test]
fn test_get_git_tracked_files_tr() {
let dir = tempfile::tempdir().unwrap();
let repo_path = dir.path();

// Initialize a git repository
let _ = Command::new("git")
.arg("init")
.current_dir(repo_path)
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.output()
.expect("Failed to initialize git repo");

// Create some files
let file1_path = repo_path.join("file1.txt");
File::create(&file1_path).unwrap().write_all(b"content1").unwrap();
let file2_path = repo_path.join("file2.txt");
File::create(&file2_path).unwrap().write_all(b"content2").unwrap();

// Add and commit files
let _ = Command::new("git")
.arg("add")
.arg(".")
.current_dir(repo_path)
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.output()
.expect("Failed to git add files");
let _ = Command::new("git")
.arg("commit")
.arg("-m")
.arg("Initial commit")
.current_dir(repo_path)
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.output()
.expect("Failed to git commit");

let tracked_files = get_git_tracked_files(&repo_path.to_path_buf());
assert_eq!(tracked_files.len(), 2);
assert!(tracked_files.contains(&"file1.txt".to_string()));
assert!(tracked_files.contains(&"file2.txt".to_string()));
}

// #[cfg(feature = "nostr")]
// #[test]
// fn test_file_hash_as_nostr_private_key() {
// use super::file_hash_as_nostr_private_key;
// // use std::fs::{File, remove_file};
// // use std::io::Write;
// // use tempfile::tempdir; // Not needed as we're using a literal path
// use nostr_sdk::prelude::ToBech32;

// let file_path = PathBuf::from("test_nostr_file_for_macro.txt");
// let content = "Nostr test content!";
// File::create(&file_path).unwrap().write_all(content.as_bytes()).unwrap();

// let keys = file_hash_as_nostr_private_key!("test_nostr_file_for_macro.txt");

// assert!(!keys.public_key().to_bech32().unwrap().is_empty());

// remove_file(&file_path).unwrap();
// }

#[cfg(feature = "nostr")]
#[tokio::test]
async fn test_publish_metadata_event() {
use super::publish_metadata_event;
use nostr_sdk::Keys;

let keys = Keys::parse(super::DEFAULT_GNOSTR_KEY).expect("Failed to create Nostr Keys from DEFAULT_GNOSTR_KEY");
let picture_url = super::DEFAULT_PICTURE_URL;
let banner_url = super::DEFAULT_BANNER_URL;
let file_path_str = "test_file.txt";

// This test primarily checks that the function doesn't panic
// and goes through its execution path.
// Actual publishing success depends on external network conditions.
let relay_urls = super::get_relay_urls();
publish_metadata_event(
&keys,
&relay_urls,
picture_url,
banner_url,
file_path_str,
).await;
}

#[cfg(feature = "nostr")]
#[tokio::test]
#[serial]
async fn test_repository_announcement_event() {
use super::get_relay_urls;
use nostr_sdk::{Keys, EventId};
use std::str::FromStr;

let keys = Keys::parse(super::DEFAULT_GNOSTR_KEY).expect("Failed to create Nostr Keys from DEFAULT_GNOSTR_KEY");
let relay_urls = get_relay_urls();
let project_name = "test-nip34-repo";
let description = "A test repository for NIP-34 announcements.";
let clone_url = "git@example.com:test/test-nip34-repo.git";
let _dummy_build_manifest_id = EventId::from_str(super::DUMMY_BUILD_MANIFEST_ID_STR).unwrap();
let _file_for_euc = "Cargo.toml"; // Use a known file in your project, as required by include_bytes!

// This test primarily checks that the macro and function compile and execute without panicking.
// Actual publishing success depends on external network conditions.
super::publish_metadata_event(
&keys,
&relay_urls,
"https://example.com/test_repo_announcement_picture.jpg";,
"https://example.com/test_repo_announcement_banner.jpg";,
"test_repository_announcement_event_metadata",
).await;

let dummy_build_manifest_id = EventId::from_str(super::DUMMY_BUILD_MANIFEST_ID_STR).unwrap();

repository_announcement!(
&keys,
&relay_urls,
project_name,
description,
clone_url,
"../Cargo.toml", // Pass the string literal directly, correcting path for include_bytes!
Some(&dummy_build_manifest_id)
);
}

#[cfg(feature = "nostr")]
#[tokio::test]
async fn test_publish_patch_event() {
use super::get_relay_urls;
use nostr_sdk::Keys;

let keys = Keys::parse(super::DEFAULT_GNOSTR_KEY).expect("Failed to create Nostr Keys from DEFAULT_GNOSTR_KEY");
let relay_urls = get_relay_urls();
let d_tag = "test-repo-for-patch";
let commit_id = "fedcba9876543210fedcba9876543210fedcba";

// This test primarily checks that the macro and function compile and execute without panicking.
// Actual publishing success depends on external network conditions.
super::publish_metadata_event(
&keys,
&relay_urls,
"https://example.com/test_patch_picture.jpg";,
"https://example.com/test_patch_banner.jpg";,
"test_publish_patch_event_metadata",
).await;

let dummy_build_manifest_id = EventId::from_str(super::DUMMY_BUILD_MANIFEST_ID_STR).unwrap();
publish_patch!(
&keys,
&relay_urls,
d_tag,
commit_id,
"lib.rs", // Use an existing file for the patch content
Some(&dummy_build_manifest_id)
); }

#[cfg(feature = "nostr")]
#[tokio::test]
async fn test_publish_pull_request_event() {
use super::get_relay_urls;
use nostr_sdk::Keys;

let keys = Keys::parse(super::DEFAULT_GNOSTR_KEY).expect("Failed to create Nostr Keys from DEFAULT_GNOSTR_KEY");
let relay_urls = get_relay_urls();
let d_tag = "test-repo-for-pr";
let commit_id = "0123456789abcdef0123456789abcdef01234567";
let clone_url = "git@example.com:test/pr-branch.git";
let title = Some("Feat: Implement NIP-34 PR");
let dummy_build_manifest_id = EventId::from_str(super::DUMMY_BUILD_MANIFEST_ID_STR).unwrap();

super::publish_metadata_event(
&keys,
&relay_urls,
"https://example.com/test_pr_picture.jpg";,
"https://example.com/test_pr_banner.jpg";,
"test_publish_pull_request_event_metadata",
).await;

// Test with a title
publish_pull_request!(
&keys,
&relay_urls,
d_tag,
commit_id,
clone_url,
Some(title.unwrap()),
Some(&dummy_build_manifest_id)
);
// Test without a title
publish_pull_request!(
&keys,
&relay_urls,
d_tag,
commit_id,
clone_url
);
}

#[cfg(feature = "nostr")]
#[tokio::test]
async fn test_publish_pr_update_event() {
use super::get_relay_urls;
use nostr_sdk::{Keys, EventId};
use std::str::FromStr;

let keys = Keys::parse(super::DEFAULT_GNOSTR_KEY).expect("Failed to create Nostr Keys from DEFAULT_GNOSTR_KEY");
let relay_urls = get_relay_urls();
let d_tag = "test-repo-for-pr-update";
let pr_event_id = EventId::from_str("f6e4d6a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9").unwrap(); // Placeholder EventId
let updated_commit_id = "z9y8x7w6v5u4t3s2r1q0p9o8n7m6l5k4j3i2h1g0";
let updated_clone_url = "git@example.com:test/pr-branch-updated.git";
let dummy_build_manifest_id = EventId::from_str(super::DUMMY_BUILD_MANIFEST_ID_STR).unwrap();

// This test primarily checks that the macro and function compile and execute without panicking.
// Actual publishing success depends on external network conditions.
super::publish_metadata_event(
&keys,
&relay_urls,
"https://example.com/test_pr_update_picture.jpg";,
"https://example.com/test_pr_update_banner.jpg";,
"test_publish_pr_update_event_metadata",
).await;

publish_pr_update!(
&keys,
&relay_urls,
d_tag,
&pr_event_id, // Pass a reference to pr_event_id
updated_commit_id,
updated_clone_url,
Some(&dummy_build_manifest_id)
); }

#[cfg(feature = "nostr")]
#[tokio::test]
#[serial]
async fn test_publish_repository_state_event_tr() {
use super::get_relay_urls;
use nostr_sdk::Keys;
use nostr_sdk::secp256k1::SecretKey as NostrSecretKey;

// 1. Generate FROST keys (1-of-1 for this test to derive a single Nostr key)
let (shares, _pubkey_package) = super::generate_frost_keys(2, 2).unwrap();
let signer_id = frost::Identifier::try_from(1 as u16).unwrap();
let secret_share = shares.get(&signer_id).unwrap();

// Convert FROST secret share's scalar to a Nostr SecretKey
let frost_secp_secret_key = secret_share.signing_share().to_scalar();
let nostr_secret_key = NostrSecretKey::from_slice(&frost_secp_secret_key.to_bytes()).unwrap();
let keys = Keys::new(nostr_secret_key.into());
let relay_urls = get_relay_urls();
let d_tag = "test-repo-for-state";
let branch_name = "main";
let commit_id = "abcde12345abcde12345abcde12345abcde12345";
use nostr_sdk::EventId;
use std::str::FromStr;
let _dummy_build_manifest_id = EventId::from_str(super::DUMMY_BUILD_MANIFEST_ID_STR).unwrap();

// This test primarily checks that the macro and function compile and execute without panicking.
// Actual publishing success depends on external network conditions.
super::publish_metadata_event(
&keys,
&relay_urls,
"https://example.com/test_repo_state_picture.jpg";,
"https://example.com/test_repo_state_banner.jpg";,
"test_publish_repository_state_event_metadata",
).await;

publish_repository_state!(
&keys,
&relay_urls,
d_tag,
branch_name,
commit_id
); }

#[cfg(feature = "nostr")]
#[tokio::test]
async fn test_publish_issue_event_tr() {
use super::get_relay_urls;
use nostr_sdk::Keys;
use nostr_sdk::EventId;
use std::str::FromStr;

let keys = Keys::parse(super::DEFAULT_GNOSTR_KEY).expect("Failed to create Nostr Keys from DEFAULT_GNOSTR_KEY");
let relay_urls = get_relay_urls();
let d_tag = "test-repo-for-issue";
let issue_id = "456";
let title = "Feature: Implement NIP-34 Issues";
let content = "This is a test issue to verify the NIP-34 issue macro implementation.";
let dummy_build_manifest_id = EventId::from_str(super::DUMMY_BUILD_MANIFEST_ID_STR).unwrap();

// This test primarily checks that the macro and function compile and execute without panicking.
// Actual publishing success depends on external network conditions.
super::publish_metadata_event(
&keys,
&relay_urls,
"https://example.com/test_issue_picture.jpg";,
"https://example.com/test_issue_banner.jpg";,
"test_publish_issue_event_metadata",
).await;

publish_issue!(
&keys,
&relay_urls,
d_tag,
issue_id,
title,
content,
Some(&dummy_build_manifest_id)
);
}

#[cfg(feature = "nostr")]
#[test]
fn test_frost_signature_flow_tr() {
let max_signers = 3;
let min_signers = 2;
let message = b"This is a test message for FROST signing";

// 1. Key Generation
let (shares, pubkey_package) = super::generate_frost_keys(max_signers, min_signers).unwrap();

let mut commitments = BTreeMap::new();
let mut nonces_map = BTreeMap::new();
let mut signature_shares_map = BTreeMap::new();

// 2. Commitment Phase (simulated for two signers)
let signer1_id = frost::Identifier::try_from(1 as u16).unwrap();
let (nonces1, comms1) = super::create_frost_commitment(&shares[&signer1_id]);
commitments.insert(signer1_id, comms1);
nonces_map.insert(signer1_id, nonces1);

let signer2_id = frost::Identifier::try_from(2 as u16).unwrap();
let (nonces2, comms2) = super::create_frost_commitment(&shares[&signer2_id]);
commitments.insert(signer2_id, comms2);
nonces_map.insert(signer2_id, nonces2);

// 3. Signing Package Creation
let signing_package = super::create_signing_package(commitments, message);

// 4. Signature Share Generation
let share1 = super::generate_signature_share(&signing_package, &nonces_map[&signer1_id], &shares[&signer1_id]).unwrap();
signature_shares_map.insert(signer1_id, share1);

let share2 = super::generate_signature_share(&signing_package, &nonces_map[&signer2_id], &shares[&signer2_id]).unwrap();
signature_shares_map.insert(signer2_id, share2);

// 5. Aggregation
let group_signature = super::aggregate_signature_shares(&signing_package, &signature_shares_map, &pubkey_package).unwrap();

// 6. Verification
let group_public_key = pubkey_package.verifying_key();
super::verify_frost_signature(&group_public_key, message, &group_signature).unwrap();
}
}

#![cfg(feature = "nostr")] use frost_secp256k1_tr as ...

2026-04-06T04:16:17Z

#![cfg(feature = "nostr")]

use frost_secp256k1_tr as frost;
use frost::keys::PublicKeyPackage;
use frost::round2::SignatureShare;
use frost::SigningPackage;
use hex;
use rand::thread_rng;
use std::collections::BTreeMap;
use sha2::Sha256;
use serde_json;
use sha2::Digest;

pub fn process_relay_share(
relay_payload_hex: &str,
signer_id_u16: u16,
_signing_package: &SigningPackage,
_pubkey_package: &PublicKeyPackage,
) -> Result<(), Box<dyn std::error::Error>> {
// In a real scenario, this function would deserialize the share, perform
// individual verification, and store it for aggregation.
// For this example, we'll just acknowledge receipt.
let _share_bytes = hex::decode(relay_payload_hex)?;
let _share = SignatureShare::deserialize(&_share_bytes)?;
let _identifier = frost::Identifier::try_from(signer_id_u16)?;

println!("✅ Share from Signer {} processed (simplified).", signer_id_u16);
Ok(())
}

pub fn simulate_frost_mailbox_coordinator() -> Result<(), Box<dyn std::error::Error>> {
let mut rng = thread_rng();
let (max_signers, min_signers) = (2, 2);

let (shares, pubkey_package) = frost::keys::generate_with_dealer(
max_signers,
min_signers,
frost::keys::IdentifierList::Default,
&mut rng,
)?;

let signer1_id = frost::Identifier::try_from(1 as u16)?;
let key_package1: frost::keys::KeyPackage = shares[&signer1_id].clone().try_into()?;
let signer2_id = frost::Identifier::try_from(2 as u16)?;
let key_package2: frost::keys::KeyPackage = shares[&signer2_id].clone().try_into()?;

let message = b"BIP-64MOD: Anchor Data Proposal v1";

let (nonces1, comms1) = frost::round1::commit(key_package1.signing_share(), &mut rng);
let (nonces2, comms2) = frost::round1::commit(key_package2.signing_share(), &mut rng);

let mut session_commitments = BTreeMap::new();
session_commitments.insert(signer1_id, comms1);
session_commitments.insert(signer2_id, comms2);

let signing_package = frost::SigningPackage::new(session_commitments.clone(), message);

let share1 = frost::round2::sign(&signing_package, &nonces1, &key_package1)?;
let share1_hex = hex::encode(share1.serialize());

let share2 = frost::round2::sign(&signing_package, &nonces2, &key_package2)?;
let share2_hex = hex::encode(share2.serialize());

println!("Coordinator listening for Nostr events (simulated)...");

process_relay_share(&share1_hex, 1_u16, &signing_package, &pubkey_package)?;
process_relay_share(&share2_hex, 2_u16, &signing_package, &pubkey_package)?;
println!("All required shares processed. Coordinator would now aggregate.");

Ok(())
}

/// Simulates a Signer producing a FROST signature share and preparing a Nostr event
/// to be sent to a coordinator via a "mailbox" relay.
///
/// In a real ROAST setup, signers would generate their share and post it
/// encrypted (e.g., using NIP-44) to a coordinator's "mailbox" on a Nostr relay.
/// This function demonstrates the creation of the signature share and the
/// construction of a *simplified* Nostr event JSON.
///
/// # Arguments
///
/// * `_identifier` - The FROST identifier of the signer. (Currently unused in this specific function body).
/// * `signing_package` - The FROST signing package received from the coordinator.
/// * `nonces` - The signer's nonces generated in Round 1.
/// * `key_package` - The signer's FROST key package.
/// * `coordinator_pubkey` - The hex-encoded public key of the ROAST coordinator,
/// used to tag the Nostr event.
///
/// # Returns
///
/// A `Result` containing the JSON string of the Nostr event if successful,
/// or a `Box<dyn std::error::Error>` if an error occurs.
pub fn create_signer_event(
_identifier: frost::Identifier,
signing_package: &frost::SigningPackage,
nonces: &frost::round1::SigningNonces,
key_package: &frost::keys::KeyPackage,
coordinator_pubkey: &str, // The Hex pubkey of the ROAST coordinator
) -> Result<String, Box<dyn std::error::Error>> {

// 1. Generate the partial signature share (Round 2 of FROST)
// This share is the core cryptographic output from the signer.
let share = frost::round2::sign(signing_package, nonces, key_package)?;
let share_bytes = share.serialize();
let share_hex = hex::encode(share_bytes);

// 2. Create a Session ID to tag the event
// This ID is derived from the signing package hash, allowing the coordinator
// to correlate shares belonging to the same signing session.
let mut hasher = Sha256::new();
hasher.update(signing_package.serialize()?);
let session_id = hex::encode(hasher.finalize());

// 3. Construct the Nostr Event JSON (Simplified)
// This JSON represents the event that a signer would post to a relay.
// In a production ROAST system, the 'content' field (the signature share)
// would be encrypted for the coordinator using NIP-44.
let event = serde_json::json!({
"kind": 4, // Example: Using Kind 4 (Private Message), though custom Kinds could be used for Sovereign Stack.
"pubkey": hex::encode(key_package.verifying_key().serialize()?.as_slice()), // Signer's public key
"created_at": 1712050000, // Example timestamp
"tags": [
["p", coordinator_pubkey], // 'p' tag: Directs the event to the coordinator.
["i", session_id], // 'i' tag: Provides a session identifier for filtering/requests.
["t", "frost-signature-share"] // 't' tag: A searchable label for the event type.
],
"content": share_hex, // The actual signature share (would be encrypted in production).
"id": "...", // Event ID (filled by relay upon publishing)
"sig": "..." // Event signature (filled by relay upon publishing)
});

Ok(event.to_string())
}

pub fn simulate_frost_mailbox_post_signer() -> Result<(), Box<dyn std::error::Error>> {
use rand::thread_rng;
use std::collections::BTreeMap;
use frost_secp256k1_tr as frost;

// This example simulates a single signer's role in a ROAST mailbox post workflow.
// The general workflow is:
// 1. Coordinator sends a request for signatures (e.g., on a BIP-64MOD proposal).
// 2. Signers receive the proposal, perform local verification.
// 3. Each signer generates their signature share and posts it (encrypted) to a
// Nostr relay, targeting the coordinator's mailbox.
// 4. The coordinator collects enough shares to aggregate the final signature.

let mut rng = thread_rng();
// For this example, we simulate a 2-of-2 threshold for simplicity.
let (max_signers, min_signers) = (2, 2);

////////////////////////////////////////////////////////////////////////////
// 1. Key Generation (Simulated Trusted Dealer)
////////////////////////////////////////////////////////////////////////////
// In a real distributed setup, this would be DKG. Here, a "trusted dealer"
// generates the shares and public key package.
let (shares, _pubkey_package) = frost::keys::generate_with_dealer(
max_signers,
min_signers,
frost::keys::IdentifierList::Default,
&mut rng,
)?;

// For a 2-of-2 scheme, we have two signers. Let's pick signer 1.
let signer1_id = frost::Identifier::try_from(1 as u16)?;
let key_package1: frost::keys::KeyPackage = shares[&signer1_id].clone().try_into()?;

let signer2_id = frost::Identifier::try_from(2 as u16)?;
let key_package2: frost::keys::KeyPackage = shares[&signer2_id].clone().try_into()?;

// The message that is to be signed (e.g., a hash of a Git commit or a Nostr event ID).
let message = b"This is a test message for ROAST mailbox post.";

////////////////////////////////////////////////////////////////////////////
// 2. Round 1: Commitment Phase (Signer's role)
////////////////////////////////////////////////////////////////////////////
// Each signer generates nonces and commitments.
let (nonces1, comms1) = frost::round1::commit(key_package1.signing_share(), &mut rng);
let (nonces2, comms2) = frost::round1::commit(key_package2.signing_share(), &mut rng);

// The coordinator collects these commitments. Here, we simulate by putting them in a BTreeMap.
let mut session_commitments = BTreeMap::new();
session_commitments.insert(signer1_id, comms1);
session_commitments.insert(signer2_id, comms2);

////////////////////////////////////////////////////////////////////////////
// 3. Signing Package Creation (Coordinator's role, simulated for context)
////////////////////////////////////////////////////////////////////////////
// The coordinator combines the collected commitments and the message to be signed
// into a signing package, which is then sent back to the signers.
let signing_package = frost::SigningPackage::new(session_commitments, message);

// Dummy coordinator public key. In a real scenario, this would be the
// actual public key of the ROAST coordinator, used for event tagging
// and encryption (NIP-44).
let coordinator_pubkey_hex = "0000000000000000000000000000000000000000000000000000000000000001";

////////////////////////////////////////////////////////////////////////////
// 4. Create the Signer Event (Signer's role)
////////////////////////////////////////////////////////////////////////////
// We demonstrate for signer 1. Signer 2 would perform a similar action.
let event_json_signer1 = create_signer_event(
signer1_id,
&signing_package,
&nonces1,
&key_package1,
coordinator_pubkey_hex,
)?;

println!("Generated Nostr Event for Signer 1 Mailbox Post:
{}", event_json_signer1);

// Similarly, Signer 2 would generate their event:
let event_json_signer2 = create_signer_event(
signer2_id,
&signing_package,
&nonces2,
&key_package2,
coordinator_pubkey_hex,
)?;
println!("Generated Nostr Event for Signer 2 Mailbox Post:
{}", event_json_signer2);

Ok(())
}

#[cfg(all(not(debug_assertions), feature = "nostr"))] ...

2026-04-06T04:16:05Z

#[cfg(all(not(debug_assertions), feature = "nostr"))]
#[tokio::main]
async fn main() {
use std::fs;
use std::path::PathBuf;

let manifest_dir = PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap());
let crate_src_path = manifest_dir.join("src").join("online_relays_gps.csv");

// Only download if the file doesn't exist or is empty
if !crate_src_path.exists() || fs::metadata(&crate_src_path).map(|m| m.len() == 0).unwrap_or(true) {
println!("cargo:warning=Downloading online_relays_gps.csv...");
let url = "https://raw.githubusercontent.com/permissionlesstech/bitchat/main/relays/online_relays_gps.csv";;
match reqwest::get(url).await {
Ok(response) => {
if response.status().is_success() {
match response.text().await {
Ok(content) => {
fs::write(&crate_src_path, content).expect("Unable to write online_relays_gps.csv");
println!("cargo:warning=Successfully downloaded online_relays_gps.csv to {:?}", crate_src_path);
},
Err(e) => {
println!("cargo:warning=Failed to get text from response: {}", e);
}
}
} else {
println!("cargo:warning=Failed to download online_relays_gps.csv: HTTP status {}", response.status());
}
},
Err(e) => {
println!("cargo:warning=Failed to fetch online_relays_gps.csv: {}", e);
}
}
}
}

#[cfg(not(all(not(debug_assertions), feature = "nostr")))]
fn main() {
// Placeholder for when the nostr feature is not enabled or in debug mode
println!("cargo:warning=Skipping online_relays_gps.csv download (nostr feature not enabled or debug mode)");
}

[package] name = "get_file_hash_core" version = { ...

2026-04-06T04:15:53Z

[package]
name = "get_file_hash_core"
version = { workspace = true }
edition = { workspace = true }
description = { workspace = true }
license = { workspace = true }
documentation = { workspace = true }
homepage = { workspace = true }
repository = { workspace = true }
authors = { workspace = true }

[features]
nostr = ["dep:nostr", "dep:nostr-sdk", "dep:serde_json", "dep:sha2", "dep:hex", "dep:reqwest", "dep:tokio", "dep:csv", "dep:url", "dep:frost-secp256k1-tr", "dep:rand"]
frost = ["dep:nostr", "dep:nostr-sdk", "dep:serde_json", "dep:sha2", "dep:hex", "dep:reqwest", "dep:tokio", "dep:csv", "dep:url", "dep:frost-secp256k1-tr", "dep:rand"]

[dependencies]
sha2 = { workspace = true, optional = true }
nostr = { workspace = true, optional = true }
serde_json = { workspace = true, optional = true }
nostr-sdk = { workspace = true, optional = true }
hex = { workspace = true, optional = true }
csv = { workspace = true, optional = true }
url = { workspace = true, optional = true }
frost-secp256k1-tr = { workspace = true, optional = true }
rand = { workspace = true, optional = true }

[dev-dependencies]
sha2 = { workspace = true }
tempfile = { workspace = true }
nostr = { workspace = true }
nostr-sdk = { workspace = true }
serde_json = { workspace = true }
hex = { workspace = true }
tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
csv = { workspace = true }
url = { workspace = true }
frost-secp256k1-tr = { workspace = true }
serial_test = { workspace = true, features = ["test_logging"] }
log = { workspace = true }

[build-dependencies]
reqwest = { workspace = true, features = ["json"], optional = true }
tokio = { workspace = true, features = ["macros", "rt-multi-thread"], optional = true }

// n34 - A CLI to interact with NIP-34 and other stuff related to ...

2026-04-06T04:15:21Z

//! A simple command-line tool that calculates and displays the ...

2026-04-06T04:15:41Z

//! A simple command-line tool that calculates and displays the SHA-256 hash of
//! its own source file.
//!
//! This utility demonstrates how to use the `get_file_hash!` macro to obtain
//! the hash of a specified file at compile time and incorporate it into runtime
//! logic.
use get_file_hash::{BUILD_HASH, CARGO_TOML_HASH, LIB_HASH};
use get_file_hash_core::get_file_hash;
use sha2::{Digest, Sha256};

const README_TEMPLATE_PART0: &str = r##"# `get_file_hash` macro

This project provides a Rust procedural macro, `get_file_hash!`, designed to compute the SHA-256 hash of a specified file at compile time. This hash is then embedded directly into your compiled executable. This feature is invaluable for:

* **Integrity Verification:** Ensuring the deployed code hasn't been tampered with.
* **Versioning:** Embedding a unique identifier linked to the exact source code version.
* **Cache Busting:** Generating unique names for assets based on their content.

## Project Structure

* `get_file_hash_core`: A foundational crate containing the `get_file_hash!` macro definition.
* `get_file_hash`: The main library crate that re-exports the macro.
* `src/bin/get_file_hash.rs`: An example executable demonstrating the macro's usage by hashing its own source file and updating this `README.md`.
* `build.rs`: A build script that also utilizes the `get_file_hash!` macro to hash `Cargo.toml` during the build process.

## Usage of `get_file_hash!` Macro

To use the `get_file_hash!` macro, ensure you have `get_file_hash` (or `get_file_hash_core` for direct usage) as a dependency in your `Cargo.toml`.

### Example

```rust
use get_file_hash::get_file_hash;
use get_file_hash::CARGO_TOML_HASH;
use sha2::{Digest, Sha256};

fn main() {
// The macro resolves the path relative to CARGO_MANIFEST_DIR
let readme_hash = get_file_hash!("src/bin/readme.rs");
let lib_hash = get_file_hash!("src/lib.rs");
println!("The SHA-256 hash of src/lib.rs is: {}", lib_hash);
println!("The SHA-256 hash of src/bin/readme.rs is: {}", readme_hash);
println!("The SHA-256 hash of Cargo.toml is: {}", CARGO_TOML_HASH);
}
```

"##;

const README_TEMPLATE_PART1: &str = r"## Release
## [`README.md`](./README.md)

```bash
cargo run --bin readme > README.md
```

## [`src/bin/readme.rs`](src/bin/readme.rs)

* **Target File:** `src/bin/readme.rs`
";

const README_TEMPLATE_PART2: &str = r"##

## [`build.rs`](build.rs)

* **Target File:** `build.rs`
";

const README_TEMPLATE_PART3: &str = r"##

## [`Cargo.toml`](Cargo.toml)

* **Target File:** `Cargo.toml`
";

const README_TEMPLATE_PART4: &str = r"##

## [`src/lib.rs`](src/lib.rs)

* **Target File:** `src/lib.rs`
";

const README_TEMPLATE_PART_NIP34: &str = r"## NIP-34 Integration: Git Repository Events on Nostr

This library provides a set of powerful macros and functions for integrating Git repository events with the Nostr protocol, adhering to the [NIP-34: Git Repositories on Nostr](https://github.com/nostr-protocol/nips/blob/master/34.md) specification.

These tools allow you to publish various Git-related events to Nostr relays, enabling decentralized tracking and collaboration for your code repositories.

### Available NIP-34 Macros

Each macro provides a convenient way to publish specific NIP-34 event kinds:

* [`repository_announcement!`](#repository_announcement)
* Publishes a `Repository Announcement` event (Kind 30617) to announce a new or updated Git repository.
* [`publish_patch!`](#publish_patch)
* Publishes a `Patch` event (Kind 1617) containing a Git patch (diff) for a specific commit.
* [`publish_pull_request!`](#publish_pull_request)
* Publishes a `Pull Request` event (Kind 1618) to propose changes and facilitate code review.
* [`publish_pr_update!`](#publish_pr_update)
* Publishes a `Pull Request Update` event (Kind 1619) to update an existing pull request.
* [`publish_repository_state!`](#publish_repository_state)
* Publishes a `Repository State` event (Kind 1620) to announce the current state of a branch (e.g., its latest commit).
* [`publish_issue!`](#publish_issue)
* Publishes an `Issue` event (Kind 1621) to report bugs, request features, or track tasks.

### Running NIP-34 Examples

To see these macros in action, navigate to the `examples/` directory and run each example individually with the `nostr` feature enabled:

```bash
cargo run --example repository_announcement --features nostr
cargo run --example publish_patch --features nostr
cargo run --example publish_pull_request --features nostr
cargo run --example publish_pr_update --features nostr
cargo run --example publish_repository_state --features nostr
cargo run --example publish_issue --features nostr
```

";

/// The main entry point of the application.
///
/// This function calculates the SHA-256 hash of the `get_file_hash.rs` source
/// file using a custom procedural macro and then prints the hash to the
/// console. It also includes a basic integrity verification check.
fn main() {
// Calculate the SHA-256 hash of the current file (`readme.rs`) at
// compile time. The `get_file_hash!` macro reads the file content and
// computes its hash.
let self_hash = get_file_hash!("readme.rs");

let status_message = if self_hash.starts_with("e3b0") {
"Warning: This hash represents an empty file."
} else {
"Integrity Verified."
};

let build_message = if BUILD_HASH.starts_with("e3b0") {
"Warning: This hash represents an empty file."
} else {
"Integrity Verified."
};
let cargo_message = if CARGO_TOML_HASH.starts_with("e3b0") {
"Warning: This hash represents an empty file."
} else {
"Integrity Verified."
};
let lib_message = if LIB_HASH.starts_with("e3b0") {
"Warning: This hash represents an empty file."
} else {
"Integrity Verified."
};

print!("{}{}{}", README_TEMPLATE_PART0, README_TEMPLATE_PART1, README_TEMPLATE_PART_NIP34);
println!("* **SHA-256 Hash:** {}", self_hash);
println!("* **Status:** {}.\n", status_message);
//
print!("{}", README_TEMPLATE_PART2);
println!("* **SHA-256 Hash:** {}", BUILD_HASH);
println!("* **Status:** {}.\n", build_message);
//
print!("{}", README_TEMPLATE_PART3);
println!("* **SHA-256 Hash:** {}", CARGO_TOML_HASH);
println!("* **Status:** {}.\n", cargo_message);
//
print!("{}", README_TEMPLATE_PART4);
println!("* **SHA-256 Hash:** {}", LIB_HASH);
println!("* **Status:** {}.\n", lib_message);
}

// n34-relay - A nostr GRASP relay implementation // Copyright ...

2026-04-06T04:15:08Z

// n34-relay - A nostr GRASP relay implementation
// Copyright (C) 2025 Awiteb <a@4rs.nl>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published
// by the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://gnu.org/licenses/agpl-3.0>;.

use std::{net::SocketAddr, process::ExitCode, sync::Arc};

use axum::Extension;
use hyper::{Method, header};
use tokio::signal;
use tower_http::{
cors,
decompression::RequestDecompressionLayer,
trace::{DefaultMakeSpan, TraceLayer},
};
use tracing::level_filters::LevelFilter;
use tracing_subscriber::{EnvFilter, Layer, layer::SubscriberExt};

/// Relay endpoints
use n34_relay::endpoints;
/// Relay errors.
use n34_relay::errors;
// /// Extension traits
// use n34_relay::ext_traits;
/// GRASP git server
use n34_relay::git_server;
// /// Relay pathes.
// use n34_relay::pathes;
// /// Raw axum websocket
// use n34_relay::raw_websocket;
/// Our relay.
use n34_relay::relay;
/// Relay configuration.
use n34_relay::relay_config;
/// Router state
use n34_relay::router_state;
/// Some useful utils.
use n34_relay::utils;

use self::{errors::RelayResult, relay_config::RelayConfig, router_state::RouterState};

/// Sets up default logging with two outputs, stderr and a log file.
///
/// Log level for stderr is controlled by `RUST_LOG` environment variable,
/// defaults to `ERROR`. The log file always uses `TRACE` level.
fn setup_logs() -> errors::RelayResult<()> {
tracing::subscriber::set_global_default(
tracing_subscriber::registry()
.with(
tracing_subscriber::fmt::layer()
.with_ansi(true)
.with_writer(std::io::stderr)
.without_time()
.with_filter(EnvFilter::from_default_env()),
)
.with(
tracing_subscriber::fmt::layer()
.with_ansi(false)
.with_writer(utils::logs_file()?)
.with_file(false)
.with_line_number(false)
.with_filter(LevelFilter::TRACE),
),
)
.ok();

Ok(())
}

async fn shutdown_signal() {
let ctrl_c = async {
signal::ctrl_c()
.await
.expect("Failed to install CTRL+C handler");
};

#[cfg(unix)]
let terminate = async {
use tokio::signal::unix::SignalKind;

signal::unix::signal(SignalKind::terminate())
.expect("Failed to create SIGTERM handler")
.recv()
.await;
};

#[cfg(not(unix))]
let terminate = std::future::pending::<()>();

tokio::select! {
_ = ctrl_c => {},
_ = terminate => {},
}
}

async fn try_main() -> RelayResult<()> {
setup_logs()?;
let config = Arc::new(RelayConfig::reload()?);
let relay_db = config.get_relay_db().await?;
let n34_relay = Arc::new(relay::build_relay(Arc::clone(&config), Arc::clone(&relay_db)).await);
let addr = SocketAddr::new(config.net.ip, config.net.port);

tracing::debug!("Running relay with configuration: {config:#?}");
tracing::info!("Relay is running at `{}`", n34_relay.url().await);

let mut app = axum::Router::new()
// main handler. GET and POST
.route("/", axum::routing::get(endpoints::main_handler).post(endpoints::main_handler));

if config.grasp.enable {
tracing::info!("Git server is running");
app = app.merge(git_server::router(&config));
}

app = app
// enable cross-origin access
.route(
"/",
axum::routing::options(|| async { hyper::StatusCode::NO_CONTENT }),
)
.layer(
cors::CorsLayer::new()
.allow_origin(cors::Any)
.allow_methods([Method::GET, Method::POST])
.allow_headers([header::CONTENT_TYPE]),
)
.layer(
TraceLayer::new_for_http()
.make_span_with(DefaultMakeSpan::default().include_headers(true)),
)
.layer(RequestDecompressionLayer::new())
.layer(Extension(Arc::new(RouterState::new(
config, n34_relay, relay_db,
))));

axum::serve(
tokio::net::TcpListener::bind(addr).await?,
app.into_make_service_with_connect_info::<SocketAddr>(),
)
.with_graceful_shutdown(shutdown_signal())
.await?;
Ok(())
}

#[tokio::main]
async fn main() -> ExitCode {
if let Err(err) = try_main().await {
eprintln!("{err}");
return ExitCode::FAILURE;
}

tracing::info!("Exited gracefully without any errors");
ExitCode::SUCCESS
}

//! A simple command-line tool that calculates and displays the ...

2026-04-06T04:14:56Z

<?xml version='1.0' ...

2026-04-06T04:14:44Z

<?xml version='1.0' encoding='windows-1252'?>





<?if $(sys.BUILDARCH) = x64 or $(sys.BUILDARCH) = arm64 ?>
<?define PlatformProgramFilesFolder = "ProgramFiles64Folder" ?>
<?else ?>
<?define PlatformProgramFilesFolder = "ProgramFilesFolder" ?>
<?endif ?>

<Wix xmlns='http://schemas.microsoft.com/wix/2006/wi'>;

<Product
Id='*'
Name='n34'
UpgradeCode='5E8926D0-4A18-48E9-A070-AFB0F698F04C'
Manufacturer='Awiteb'
Language='1033'
Codepage='1252'
Version='$(var.Version)'>

<Package Id='*'
Keywords='Installer'
Description='A CLI to interact with NIP-34 and other stuff related to code in Nostr'
Manufacturer='Awiteb'
InstallerVersion='450'
Languages='1033'
Compressed='yes'
InstallScope='perMachine'
SummaryCodepage='1252'
/>

<MajorUpgrade
Schedule='afterInstallInitialize'
DowngradeErrorMessage='A newer version of [ProductName] is already installed. Setup will now exit.'/>

<Media Id='1' Cabinet='media1.cab' EmbedCab='yes' DiskPrompt='CD-ROM #1'/>
<Property Id='DiskPrompt' Value='n34 Installation'/>

<Directory Id='TARGETDIR' Name='SourceDir'>
<Directory Id='$(var.PlatformProgramFilesFolder)' Name='PFiles'>
<Directory Id='APPLICATIONFOLDER' Name='n34'>




<Directory Id='Bin' Name='bin'>
<Component Id='Path' Guid='7A2E5F6A-FC23-498B-AEC1-5FA63678FBFD' KeyPath='yes'>
<Environment
Id='PATH'
Name='PATH'
Value='[Bin]'
Permanent='no'
Part='last'
Action='set'
System='yes'/>
</Component>
<Component Id='binary0' Guid='*'>
<File
Id='exe0'
Name='n34-cli.exe'
DiskId='1'
Source='$(var.CargoTargetBinDir)\n34-cli.exe'
KeyPath='yes'/>
</Component>
</Directory>
</Directory>
</Directory>
</Directory>

<Feature
Id='Binaries'
Title='Application'
Description='Installs all binaries and the license.'
Level='1'
ConfigurableDirectory='APPLICATIONFOLDER'
AllowAdvertise='no'
Display='expand'
Absent='disallow'>




<ComponentRef Id='binary0'/>

<Feature
Id='Environment'
Title='PATH Environment Variable'
Description='Add the install location of the [ProductName] executable to the PATH system environment variable. This allows the [ProductName] executable to be called from any location.'
Level='1'
Absent='allow'>
<ComponentRef Id='Path'/>
</Feature>
</Feature>

<SetProperty Id='ARPINSTALLLOCATION' Value='[APPLICATIONFOLDER]' After='CostFinalize'/>





<Property Id='ARPHELPLINK' Value='https://n34.dev/commands.html'/>;

<UI>
<UIRef Id='WixUI_FeatureTree'/>


<Publish Dialog='WelcomeDlg' Control='Next' Event='NewDialog' Value='CustomizeDlg' Order='99'>1</Publish>
<Publish Dialog='CustomizeDlg' Control='Back' Event='NewDialog' Value='WelcomeDlg' Order='99'>1</Publish>

</UI>










</Product>

</Wix>

// n34 - A CLI to interact with NIP-34 and other stuff related to ...

2026-04-06T04:14:31Z

// n34 - A CLI to interact with NIP-34 and other stuff related to ...

2026-04-06T04:14:19Z

// n34 - A CLI to interact with NIP-34 and other stuff related to ...

2026-04-06T04:14:07Z

// n34 - A CLI to interact with NIP-34 and other stuff related to codes in nostr
// Copyright (C) 2025 Awiteb <a@4rs.nl>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://gnu.org/licenses/gpl-3.0.html>;.

/// Extension traits for nostr types.
pub mod traits;
/// Utility functions for nostr.
pub mod utils;

use std::{collections::HashSet, time::Duration};

use futures::future;
use nostr::{
event::{Event, EventId, Kind, Tag, TagKind, TagStandard, Tags, UnsignedEvent},
filter::Filter,
key::PublicKey,
nips::{
nip01::{Coordinate, Metadata},
nip19::ToBech32,
nip22,
nip34::GitRepositoryAnnouncement,
},
parser::NostrParser,
types::RelayUrl,
};
use nostr_sdk::{Client, ClientOptions};
use traits::TokenUtils;

use crate::{
cli::{CliOptions, issue::IssueStatus, patch::PatchStatus},
error::{N34Error, N34Result},
};

/// Timeout duration for the client.
const CLIENT_TIMEOUT: Duration = Duration::from_millis(1500);
/// Length of a Nostr npub (public key) in characters.
const NPUB_LEN: usize = 63;

/// Parsed content details
#[derive(Clone)]
pub struct ContentDetails {
/// Public keys of users mentioned in the content.
pub p_tagged: HashSet<PublicKey>,
/// Event IDs and optional relay URLs for quoted events.
pub quotes: HashSet<(EventId, Option<RelayUrl>)>,
/// Hashtags found in the content.
pub hashtags: HashSet<String>,
/// Relays where mentioned users and quoted authors are read.
pub write_relays: HashSet<RelayUrl>,
}

/// A client for interacting with the Nostr relays
#[derive(Clone)]
pub struct NostrClient {
/// The underlying Nostr client implementation
pub client: Client,
}

impl ContentDetails {
/// Create a new [`ContentDetails`] instance
pub fn new(
users: impl IntoIterator<Item = PublicKey>,
quotes: impl IntoIterator<Item = (EventId, Option<RelayUrl>)>,
hashtags: impl IntoIterator<Item = String>,
write_relays: impl IntoIterator<Item = RelayUrl>,
) -> Self {
Self {
p_tagged: HashSet::from_iter(users),
quotes: HashSet::from_iter(quotes),
hashtags: HashSet::from_iter(hashtags),
write_relays: HashSet::from_iter(write_relays),
}
}

/// Converts the instance into a list of tags including hashtags, p-tagged
/// users, and quoted events.
pub fn into_tags(self) -> Tags {
let mut tags = Tags::new();
tags.extend(self.hashtags.into_iter().map(Tag::hashtag));
tags.extend(self.p_tagged.into_iter().map(Tag::public_key));
tags.extend(self.quotes.into_iter().map(|(event_id, relay_url)| {
// TODO: Add the author public key if we know it
Tag::from_standardized(TagStandard::Quote {
event_id,
relay_url,
public_key: None,
})
}));
tags
}
}

impl NostrClient {
/// Creates a new [`NostrClient`] with the given client and options.
const fn new(client: Client) -> Self {
Self { client }
}

/// Initializes a new [`NostrClient`] instance and connects to the specified
/// relays.
pub async fn init(options: &CliOptions, relays: &[RelayUrl]) -> Self {
let mut client_builder =
Client::builder().opts(ClientOptions::new().verify_subscriptions(true));

if let Ok(Some(signer)) = options.signer().await {
client_builder = client_builder.signer(signer);
}

let client = Self::new(client_builder.build());

client.add_relays(relays).await;
client
}

//// Returns the users public key
pub async fn pubkey(&self) -> N34Result<PublicKey> {
self.client
.signer()
.await?
.get_public_key()
.await
.map_err(N34Error::SignerError)
}

/// Add relays and connect to them
pub async fn add_relays(&self, relays: &[RelayUrl]) {
if relays.is_empty() {
return;
}

let mut tasks = Vec::new();
for relay in relays {
let relay = relay.clone();
let client = self.client.clone();
tasks.push(tokio::spawn(async move {
client
.add_relay(&relay)
.await
.expect("It's a valid relay url");
if let Err(err) = client.try_connect_relay(&relay, CLIENT_TIMEOUT).await {
tracing::error!("Failed to connect to relay '{relay}': {err}");
}
}));
}
future::join_all(tasks).await;
}

/// Add a relay hint and connect to it
pub async fn add_relay_hint(&self, hint: Option<RelayUrl>) {
if let Some(relay) = hint {
self.add_relays(&[relay]).await
}
}

/// broadcast an event to the given relays
pub async fn broadcast(&self, event: &Event, relays: &[RelayUrl]) -> N34Result<()> {
self.client.send_event_to(relays, event).await?;
Ok(())
}

/// Broadcasts an unsigned event to given relays, optionally broadcast the
/// relays list event. Returns URLs of relays that successfully received
/// the event.
pub async fn send_event_to(
&self,
mut event: UnsignedEvent,
relays_list: Option<&Event>,
relays: &[RelayUrl],
) -> N34Result<Vec<RelayUrl>> {
self.add_relays(relays).await;
let event_id = event.id();

let (result, ..) = futures::join!(
async {
N34Result::Ok(
self.client
.send_event_to(relays, &event.sign(&self.client.signer().await?).await?)
.await?,
)
},
async {
if let Some(event) = relays_list {
let _ = self.client.send_event_to(relays, event).await;
}
}
);
let result = result?;

for relay in &result.success {
tracing::info!(event_id = %event_id, relay = %relay, "Event sent successfully");
}
for (relay, reason) in &result.failed {
tracing::warn!(event_id = %event_id, relay = %relay, reason = %reason, "Failed to send event");
}

Ok(result.success.into_iter().collect())
}

/// Fetches the first event matching the given filter, or None if no event
/// is found.
pub async fn fetch_event(&self, filter: Filter) -> N34Result<Option<Event>> {
Ok(self
.client
.fetch_events(filter.limit(1), CLIENT_TIMEOUT)
.await?
.first_owned())
}

/// Fetches the events matching the given filter
pub async fn fetch_events(&self, filter: Filter) -> N34Result<Vec<Event>> {
// Multiply timeout by 5 to account for multiple events being fetched
Ok(self
.client
.fetch_events(filter, CLIENT_TIMEOUT * 5)
.await?
.to_vec())
}

/// Try to fetch the repositories and returns them
pub async fn fetch_repos(
&self,
repo_naddrs: &[Coordinate],
) -> N34Result<Vec<GitRepositoryAnnouncement>> {
future::join_all(repo_naddrs.iter().map(|c| {
async {
self.fetch_event(
Filter::new()
.author(c.public_key)
.identifier(&c.identifier)
.kind(Kind::GitRepoAnnouncement),
)
.await?
.map(|e| utils::event_into_repo(e, &c.identifier))
.ok_or(N34Error::NotFoundRepo)
}
}))
.await
.into_iter()
.collect()
}

/// Fetch the patch by the given id. None if not found
pub async fn fetch_patch(&self, patch_id: EventId) -> N34Result<Event> {
self.fetch_event(Filter::new().id(patch_id).kind(Kind::GitPatch))
.await?
.ok_or(N34Error::CanNotFoundPatch)
}

/// Returns the username for a given public key. If no username is found,
/// falls back to a shortened version of the public key.
pub async fn get_username(&self, user: PublicKey) -> String {
self.fetch_event(Filter::new().kind(Kind::Metadata).author(user))
.await
.ok()
.flatten()
.and_then(|e| Metadata::try_from(&e).ok())
.and_then(|m| m.display_name.or(m.name))
.unwrap_or_else(|| {
let pubkey = user.to_bech32().expect("The error is `Infallible`");
format!("{}...{}", &pubkey[..8], &pubkey[NPUB_LEN - 8..])
})
}

/// Get the latest status of an issue by its ID, only considering status
/// events from authorized_pubkeys. If no valid status event is found,
/// defaults to Open.
pub async fn fetch_issue_status(
&self,
issue_id: EventId,
authorized_pubkeys: Vec<PublicKey>,
) -> N34Result<IssueStatus> {
self.fetch_events(
Filter::new()
.event(issue_id)
.kinds([
Kind::GitStatusOpen,
Kind::GitStatusApplied,
Kind::GitStatusClosed,
])
.authors(utils::dedup(authorized_pubkeys.into_iter())),
)
.await?
.into_iter()
.max_by_key(|e| e.created_at)
.map(|status| IssueStatus::try_from(status.kind))
.unwrap_or_else(|| Ok(IssueStatus::Open))
}

/// Gets the status of a patch. If it's a revision patch, checks if it's
/// closed when the root patch is already merged/applied but doesn't
/// reference this revision. Defaults to Open status if no status event
/// is found.
pub async fn fetch_patch_status(
&self,
root_patch: EventId,
root_revision: Option<EventId>,
authorized_pubkeys: Vec<PublicKey>,
) -> N34Result<PatchStatus> {
let (root_status, event_tags) = self
.fetch_events(
Filter::new()
.event(root_patch)
.kinds([
Kind::GitStatusOpen,
Kind::GitStatusApplied,
Kind::GitStatusClosed,
Kind::GitStatusDraft,
])
.authors(utils::dedup(authorized_pubkeys.into_iter())),
)
.await?
.into_iter()
.max_by_key(|e| e.created_at)
.map(|status| N34Result::Ok((PatchStatus::try_from(status.kind)?, status.tags)))
.unwrap_or_else(|| Ok((PatchStatus::Open, Tags::new())))?;

if let Some(revision_id) = root_revision
&& root_status.is_merged_or_applied()
&& !event_tags
.filter(TagKind::e())
.any(|t| t.is_reply() && t.content().is_some_and(|c| c == revision_id.to_hex()))
{
return Ok(PatchStatus::Closed);
}

Ok(root_status)
}

pub async fn fetch_patch_series(
&self,
root_patch_id: EventId,
root_patch_author: PublicKey,
) -> N34Result<Vec<Event>> {
Ok(self
.fetch_events(
Filter::new()
.kind(Kind::GitPatch)
.author(root_patch_author)
.event(root_patch_id),
)
.await?
.into_iter()
.filter(|e| {
e.tags.iter().any(|t| {
t.is_root() && t.content().is_some_and(|c| c == root_patch_id.to_hex())
})
})
.collect())
}

/// Finds the root issue or patch for a given event. If the event is already
/// a root (issue/patch), returns it directly. For comments, follows
/// parent/root references until finding the root or failing. Returns
/// None if no root can be found.
pub async fn find_root(&self, mut event: Event) -> N34Result<Option<Event>> {
if !matches!(event.kind, Kind::GitIssue | Kind::GitPatch | Kind::Comment) {
return Err(N34Error::CanNotReplyToEvent);
}

loop {
if matches!(event.kind, Kind::GitIssue | Kind::GitPatch) {
return Ok(Some(event));
}

if let Some(nip22::CommentTarget::Event { id, relay_hint, .. }) =
nip22::extract_root(&event)
{
self.add_relay_hint(relay_hint.cloned()).await;
let root_event = self.fetch_event(Filter::new().id(*id)).await?;
if let Some(ref root_event) = root_event
&& !matches!(root_event.kind, Kind::GitIssue | Kind::GitPatch)
{
return Err(N34Error::CanNotReplyToEvent);
}
return Ok(root_event);
} else if let Some(nip22::CommentTarget::Event { id, relay_hint, .. }) =
nip22::extract_parent(&event)
{
self.add_relay_hint(relay_hint.cloned()).await;
if let Ok(Some(parent_event)) = self.fetch_event(Filter::new().id(*id)).await {
event = parent_event;
continue;
}
}

// Break if: no root/parent tags found, parent/root event fetch failed
break;
}

Ok(None)
}

/// Fetches the relay list (kind 10002) for the given user. Returns None if
/// no relays are found.
pub async fn user_relays_list(&self, user: PublicKey) -> N34Result<Option<Event>> {
self.fetch_event(Filter::new().author(user).kind(Kind::RelayList))
.await
}

/// Gets the author of the specified event, if found.
pub async fn event_author(&self, event_id: EventId) -> N34Result<Option<PublicKey>> {
Ok(self
.fetch_event(Filter::new().id(event_id))
.await?
.map(|e| e.pubkey))
}

/// Returns the read relays of the given user if found, otherwise empty
/// vector
pub async fn read_relays_from_user(&self, user: PublicKey) -> Vec<RelayUrl> {
utils::add_read_relays(self.user_relays_list(user).await.ok().flatten().as_ref())
}

/// Returns the read relays of the given users if found, otherwise empty
/// vector
pub async fn read_relays_from_users(&self, users: &[PublicKey]) -> Vec<RelayUrl> {
self.fetch_events(
Filter::new()
.kind(nostr::event::Kind::RelayList)
.authors(utils::dedup(users.iter().copied())),
)
.await
.unwrap_or_default()
.into_iter()
.flat_map(|e| utils::add_read_relays(Some(&e)))
.collect()
}

/// Parse the given content and returns the details that inside it
pub async fn parse_content(&self, content: &str) -> ContentDetails {
let mut write_relays = Vec::new();
let tokens = NostrParser::new().parse(content).collect::<Vec<_>>();

let mut p_tagged_users = tokens
.iter()
.filter_map(TokenUtils::extract_public_key)
.collect::<Vec<_>>();
let quotes = tokens
.iter()
.filter_map(TokenUtils::extract_event_id)
.collect::<Vec<_>>();
let hashtags = tokens
.iter()
.filter_map(TokenUtils::extract_hashtag)
.collect::<Vec<_>>();

for (user, relays) in &p_tagged_users {
self.add_relays(relays).await;
write_relays.extend(self.read_relays_from_user(*user).await);
}
for (event_id, relays) in &quotes {
self.add_relays(relays).await;
// Add the event author to the p-tagged users
if let Ok(Some(author)) = self.event_author(*event_id).await {
p_tagged_users.push((author, Vec::new()));
write_relays.extend(self.read_relays_from_user(author).await);
}
}

ContentDetails::new(
p_tagged_users.into_iter().map(|(p, _)| p),
quotes.into_iter().map(|(e, r)| (e, r.first().cloned())),
hashtags,
write_relays,
)
}
}