<unnamed>

Public Key

npub127u525u3l674p6l40c72u4ptxvumhfa0hu4pyjztnrw7vpppmvrqun5r64

Profile Code

nprofile1qqs90w292wgla02sa06hu09w2s4nxwdm57hm72sjfp9e3h0xqssakpspz3mhxue69uhhyetvv9ujuerpd46hxtnfduqs6amnwvaz7tmwdaejumr0dss9l663

Publishing to

relay.damus.io

nos.lol

Last Notes

2026-04-05 05:55:59 UTC

- reply

Build manifest for get_file_hash v0.4.7

2026-04-05 05:55:44 UTC

<?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 [email protected]'
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 [email protected]'
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>

2026-04-05 05:55:32 UTC

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);
}

2026-04-05 05:55:11 UTC

//! 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);
}
}

2026-04-05 05:54:54 UTC

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

2026-04-05 05:54:22 UTC

#![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(())
}

2026-04-05 05:54:11 UTC

#[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)");
}

2026-04-05 05:54:00 UTC

[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 }

2026-04-05 05:53:47 UTC

//! 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);
}

2026-04-05 05:53:36 UTC

2026-04-05 05:53:25 UTC

// n34-relay - A nostr GRASP relay implementation
// Copyright (C) 2025 Awiteb <[email protected]>
//
// 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
}

2026-04-05 05:53:14 UTC

2026-04-05 05:52:54 UTC

<?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>

2026-04-05 05:52:43 UTC

2026-04-05 05:52:32 UTC

2026-04-05 05:52:21 UTC

// n34 - A CLI to interact with NIP-34 and other stuff related to codes in nostr
// Copyright (C) 2025 Awiteb <[email protected]>
//
// 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,
)
}
}

2026-04-05 05:52:07 UTC

- reply

Build manifest for get_file_hash v0.4.7

2026-04-05 05:52:05 UTC

2026-04-05 05:51:57 UTC

2026-04-05 05:51:47 UTC

#![allow(unused)]
// n34 - A CLI to interact with NIP-34 and other stuff related to codes in nostr
// Copyright (C) 2025 Awiteb <[email protected]>
//
// 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>.
/// Command line interface module
pub mod cli;
/// N34 errors
pub mod error;
/// Nostr utils module
pub mod nostr_utils;
use std::{
process::ExitCode,
sync::atomic::{AtomicBool, Ordering},
};
use clap::Parser;
use clap_verbosity_flag::Verbosity;
use tracing::Level;
use tracing_subscriber::{Layer, filter, layer::SubscriberExt};
use self::cli::Cli;
/// Whether the editor is currently open. Prevents logging while the editor is
/// open.
static EDITOR_OPEN: AtomicBool = AtomicBool::new(false);
/// Configures the logging level based on the provided verbosity.
///
/// When verbosity is set to TRACE, includes file and line numbers in logs.
fn set_log_level(verbosity: Verbosity) {
let is_trace = verbosity
.tracing_level()
.is_some_and(|l| l == tracing::Level::TRACE);
let logs_filter = filter::dynamic_filter_fn(move |m, _| {
// Disable all logs while editor is open
verbosity.tracing_level().unwrap_or(Level::ERROR) >= *m.level()
&& !EDITOR_OPEN.load(Ordering::Relaxed)
});
let logs_layer = tracing_subscriber::fmt::layer()
.with_file(is_trace)
.with_line_number(is_trace)
.without_time();
let subscriber = tracing_subscriber::registry().with(logs_layer.with_filter(logs_filter));
tracing::subscriber::set_global_default(subscriber).ok();
}
// ```rust
// #[tokio::main]
// async fn main() -> ExitCode {
// let cli = match cli::post_cli(Cli::parse()) {
// Ok(cli) => cli,
// Err(err) => {
// eprintln!("{err}");
// return ExitCode::FAILURE;
// }
// };
//
// set_log_level(cli.verbosity);
//
// if let Err(err) = cli.run().await {
// tracing::error!("{err}");
// return err.exit_code();
// }
//
// ExitCode::SUCCESS
// }
// ```

2026-04-05 05:51:46 UTC

2026-04-05 05:51:36 UTC

2026-04-05 05:51:30 UTC

2026-04-05 05:51:23 UTC

2026-04-05 05:51:18 UTC

2026-04-05 05:51:12 UTC

2026-04-05 05:51:01 UTC

2026-04-05 05:50:45 UTC

2026-04-05 05:50:42 UTC

2026-04-05 05:50:33 UTC

2026-04-05 05:50:25 UTC

2026-04-05 05:50:19 UTC

2026-04-05 05:50:13 UTC

2026-04-05 05:50:07 UTC

2026-04-05 05:50:02 UTC

2026-04-05 05:49:55 UTC

2026-04-05 05:49:45 UTC

2026-04-05 05:49:44 UTC

2026-04-05 05:49:33 UTC

// n34 - A CLI to interact with NIP-34 and other stuff related to codes in nostr
// Copyright (C) 2025 Awiteb <[email protected]>
//
// 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>.
use std::{iter, str::FromStr, sync::Arc};
use either::Either;
use futures::future;
use nostr::{
event::{Event, EventBuilder, EventId, Kind, Tag, TagKind},
filter::Filter,
hashes::sha1::Hash as Sha1Hash,
nips::{nip10::Marker, nip19::ToBech32},
types::RelayUrl,
};
use super::{
issue::IssueStatus,
patch::PatchStatus,
types::{NaddrOrSet, NostrEvent},
};
use crate::{
cli::traits::{OptionNaddrOrSetVecExt, RelayOrSetVecExt},
nostr_utils::{NostrClient, traits::NaddrsUtils, utils},
};
use crate::{
cli::{CliOptions, patch::GitPatch},
error::{N34Error, N34Result},
nostr_utils::traits::{GitIssueUtils, GitPatchUtils, ReposUtils},
};
/// Updates the issue's status to `new_status` after validating it with
/// `check_fn`.
pub async fn issue_status_command(
options: CliOptions,
issue_id: NostrEvent,
naddrs: Option<Vec<NaddrOrSet>>,
new_status: IssueStatus,
check_fn: impl FnOnce(&IssueStatus) -> N34Result<()>,
) -> N34Result<()> {
let naddrs = utils::naddrs_or_file(
naddrs.flat_naddrs(&options.config.sets)?,
&utils::nostr_address_path()?,
)?;
let relays = options.relays.clone().flat_relays(&options.config.sets)?;
let client = NostrClient::init(&options, &relays).await;
let user_pubk = client.pubkey().await?;
client
.add_relays(&[naddrs.extract_relays(), issue_id.relays].concat())
.await;
let owners = naddrs.extract_owners();
let coordinates = naddrs.clone().into_coordinates();
let repos = client.fetch_repos(&coordinates).await?;
let maintainers = repos.extract_maintainers();
let relay_hint = repos.extract_relays().first().cloned();
client.add_relays(&repos.extract_relays()).await;
let issue_event = client
.fetch_event(Filter::new().id(issue_id.event_id))
.await?
.ok_or(N34Error::CanNotFoundIssue)?;
let issue_status = client
.fetch_issue_status(
issue_id.event_id,
[maintainers.as_slice(), &[issue_event.pubkey], &owners].concat(),
)
.await?;
check_fn(&issue_status)?;
let status_event = EventBuilder::new(new_status.kind(), "")
.pow(options.pow.unwrap_or_default())
.tag(utils::event_reply_tag(
&issue_id.event_id,
relay_hint.as_ref(),
Marker::Root,
))
.tag(Tag::public_key(issue_event.pubkey))
.tags(maintainers.iter().map(|p| Tag::public_key(*p)))
.tags(owners.iter().map(|p| Tag::public_key(*p)))
.tags(
coordinates
.into_iter()
.map(|c| Tag::coordinate(c, relay_hint.clone())),
)
.dedup_tags()
.build(user_pubk);
let event_id = status_event.id.expect("There is an id");
let user_relays_list = client.user_relays_list(user_pubk).await?;
let write_relays = [
relays,
naddrs.extract_relays(),
repos.extract_relays(),
utils::add_write_relays(user_relays_list.as_ref()),
client.read_relays_from_user(issue_event.pubkey).await,
client
.read_relays_from_users(&[maintainers, owners].concat())
.await,
]
.concat();
let success = client
.send_event_to(status_event, user_relays_list.as_ref(), &write_relays)
.await?;
let nevent = utils::new_nevent(event_id, &success)?;
println!("Issue status created: {nevent}");
Ok(())
}
/// Updates the patch's status to `new_status` after validating it with
/// `check_fn`.
pub async fn patch_status_command(
options: CliOptions,
patch_id: NostrEvent,
naddrs: Option<Vec<NaddrOrSet>>,
new_status: PatchStatus,
merge_or_applied_commits: Option<Either<Sha1Hash, Vec<Sha1Hash>>>,
merge_or_applied_patches: Vec<EventId>,
check_fn: impl FnOnce(&PatchStatus) -> N34Result<()>,
) -> N34Result<()> {
let naddrs = utils::naddrs_or_file(
naddrs.flat_naddrs(&options.config.sets)?,
&utils::nostr_address_path()?,
)?;
let relays = options.relays.clone().flat_relays(&options.config.sets)?;
let client = NostrClient::init(&options, &relays).await;
let user_pubk = client.pubkey().await?;
client
.add_relays(&[naddrs.extract_relays(), patch_id.relays].concat())
.await;
let owners = naddrs.extract_owners();
let coordinates = naddrs.clone().into_coordinates();
let repos = client.fetch_repos(&coordinates).await?;
let maintainers = repos.extract_maintainers();
let relay_hint = repos.extract_relays().first().cloned();
client.add_relays(&repos.extract_relays()).await;
let patch_event = client.fetch_patch(patch_id.event_id).await?;
if patch_event.is_revision_patch() && !new_status.is_merged_or_applied() {
return Err(N34Error::InvalidStatus(
"Invalid action for patch revision. Only 'apply' or 'merge' are allowed, 'open', \
'close', and 'draft' are not supported."
.to_owned(),
));
}
let (root_patch, root_revision) = get_patch_root_revision(&patch_event)?;
let patch_status = client
.fetch_patch_status(
root_patch,
root_revision,
[maintainers.as_slice(), &[patch_event.pubkey], &owners].concat(),
)
.await?;
check_fn(&patch_status)?;
let mut status_builder = EventBuilder::new(new_status.kind(), "")
.pow(options.pow.unwrap_or_default())
.tag(utils::event_reply_tag(
&root_patch,
relay_hint.as_ref(),
Marker::Root,
))
.tag(Tag::public_key(patch_event.pubkey))
.tags(maintainers.iter().map(|p| Tag::public_key(*p)))
.tags(owners.iter().map(|p| Tag::public_key(*p)))
.tags(
coordinates
.into_iter()
.map(|c| Tag::coordinate(c, relay_hint.clone())),
);
if new_status.is_merged_or_applied() {
if let Some(merge_commit) = merge_or_applied_commits
.as_ref()
.and_then(|e| e.as_ref().left())
{
let commit = merge_commit.to_string();
status_builder = status_builder
.tag(Tag::custom(
TagKind::custom("merge-commit"),
iter::once(&commit),
))
.tag(Tag::reference(commit));
} else if let Some(applied_commits) = merge_or_applied_commits.and_then(|e| e.right()) {
let commits = applied_commits
.iter()
.map(ToString::to_string)
.collect::<Vec<_>>();
status_builder = status_builder
.tag(Tag::custom(TagKind::custom("applied-as-commits"), &commits))
.tags(commits.into_iter().map(Tag::reference));
};
if let Some(root_revision) = root_revision {
status_builder = status_builder.tag(utils::event_reply_tag(
&root_revision,
relay_hint.as_ref(),
Marker::Reply,
));
}
if !merge_or_applied_patches.is_empty() {
status_builder = status_builder.tags(
build_patches_quote(client.clone(), relay_hint.clone(), merge_or_applied_patches)
.await,
);
}
}
let status_event = status_builder.dedup_tags().build(user_pubk);
let event_id = status_event.id.expect("There is an id");
let user_relays_list = client.user_relays_list(user_pubk).await?;
let write_relays = [
relays,
naddrs.extract_relays(),
repos.extract_relays(),
utils::add_write_relays(user_relays_list.as_ref()),
client.read_relays_from_user(patch_event.pubkey).await,
client
.read_relays_from_users(&[maintainers, owners].concat())
.await,
]
.concat();
let success = client
.send_event_to(status_event, user_relays_list.as_ref(), &write_relays)
.await?;
let nevent = utils::new_nevent(event_id, &success)?;
println!("Patch status created: {nevent}");
Ok(())
}
/// Fetch and display patches and issues for given repositories.
/// If `list_patches` is true, lists patches instead of issues.
/// `limit` controls the maximum number of items to fetch.
pub async fn list_patches_and_issues(
options: CliOptions,
naddrs: Option<Vec<NaddrOrSet>>,
list_patches: bool,
limit: usize,
) -> N34Result<()> {
let naddrs = utils::check_empty_naddrs(utils::naddrs_or_file(
naddrs.flat_naddrs(&options.config.sets)?,
&utils::nostr_address_path()?,
)?)?;
let relays = options.relays.clone().flat_relays(&options.config.sets)?;
let client = NostrClient::init(&options, &relays).await;
client.add_relays(&naddrs.extract_relays()).await;
let coordinates = naddrs.clone().into_coordinates();
let repos = client.fetch_repos(&coordinates).await?;
let authorized_pubkeys = [naddrs.extract_owners(), repos.extract_maintainers()].concat();
client.add_relays(&repos.extract_relays()).await;
// This helps discover issues and their status.
client
.add_relays(&client.read_relays_from_users(&authorized_pubkeys).await)
.await;
let kind = if list_patches {
Kind::GitPatch
} else {
Kind::GitIssue
};
let mut filter = Filter::new()
.coordinates(coordinates.iter())
.kind(kind)
.limit(limit);
if list_patches {
filter = filter.hashtag("root");
}
let arc_client = Arc::new(client);
// Events are sorted by kind in ascending order:
// 1630 (Open), 1631 (Resolved/Applied), 1632 (Closed), 1633 (Draft)
let events = utils::sort_by_key(
future::join_all(
arc_client
.fetch_events(filter)
.await?
.into_iter()
.take(limit)
.map(|event| {
let c = arc_client.clone();
let keys = authorized_pubkeys.clone();
async move {
let status = if list_patches {
let (root, root_revision) = get_patch_root_revision(&event)?;
c.fetch_patch_status(
root,
root_revision,
[keys.as_slice(), &[event.pubkey]].concat(),
)
.await
.map(Either::Left)?
} else {
c.fetch_issue_status(
event.id,
[keys.as_slice(), &[event.pubkey]].concat(),
)
.await
.map(Either::Right)?
};
N34Result::Ok((event, status))
}
}),
)
.await
.into_iter()
.filter_map(|r| r.ok()),
|(_, status)| status.as_ref().either_into::<Kind>(),
);
let lines = events
.map(|(event, status)| format_patch_and_issue(&event, status))
.collect::<Vec<String>>();
let max_width = lines
.iter()
.map(|s| s.split_once('\n').map_or(85, |(l, _)| l.chars().count()))
.max()
.unwrap_or(85)
.max(67); // length of the event id
println!("{}", lines.join(&format!("{}\n", "-".repeat(max_width))));
Ok(())
}
/// Returns a tuple of (root_id, patch_id) if this is a valid root or revision
/// patch.
fn get_patch_root_revision(patch_event: &Event) -> N34Result<(EventId, Option<EventId>)> {
if patch_event.is_revision_patch() {
Ok((
patch_event.root_patch_from_revision()?,
Some(patch_event.id),
))
} else if patch_event.is_root_patch() {
Ok((patch_event.id, None))
} else {
Err(N34Error::NotRootPatch)
}
}
/// Formats an event as either a patch or an issue. For patches, extracts the
/// subject line from the Git patch format. For issues, combines the subject
/// with labels. The output includes status and formatted ID.
fn format_patch_and_issue(event: &Event, status: Either<PatchStatus, IssueStatus>) -> String {
let subject = if status.is_left() {
GitPatch::from_str(&event.content)
.map(|p| p.subject)
.unwrap_or_else(|_| {
event
.content
.lines()
.find(|line| line.trim().starts_with("Subject: "))
.unwrap_or_default()
.trim()
.trim_start_matches("Subject: ")
.to_owned()
})
} else {
let labels = event.extract_issue_labels();
let subject = event.extract_issue_subject();
if labels.is_empty() {
subject.to_owned()
} else {
format!(r#""{subject}" {labels}"#)
}
};
format!(
"({status}) {}\nID: {}\n",
utils::smart_wrap(&subject, 85),
event.id.to_bech32().expect("Infallible")
)
}
/// Generates a list of tags for quoting patches in merge/applied status events.
async fn build_patches_quote(
client: NostrClient,
relay_hint: Option<RelayUrl>,
patches: Vec<EventId>,
) -> Vec<Tag> {
let client = Arc::new(client);
let relay_hint = Arc::new(relay_hint);
future::join_all(patches.into_iter().map(|eid| {
let task_relay = Arc::clone(&relay_hint);
let task_client = Arc::clone(&client);
async move {
Tag::custom(
TagKind::q(),
[
eid.to_hex(),
task_relay
.as_ref()
.as_ref()
.map(|r| r.to_string())
.unwrap_or_default(),
task_client
.event_author(eid)
.await
.ok()
.flatten()
.map(|p| p.to_hex())
.unwrap_or_default(),
],
)
}
}))
.await
}

2026-04-05 05:49:32 UTC

2026-04-05 05:49:22 UTC

2026-04-05 05:49:21 UTC

<?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>

2026-04-05 05:49:10 UTC

2026-04-05 05:48:59 UTC

2026-04-05 05:48:58 UTC

2026-04-05 05:48:47 UTC

2026-04-05 05:48:40 UTC

2026-04-05 05:48:35 UTC

2026-04-05 05:48:29 UTC

2026-04-05 05:48:24 UTC

2026-04-05 05:48:17 UTC

2026-04-05 05:48:12 UTC

2026-04-05 05:48:06 UTC

2026-04-05 05:48:01 UTC

2026-04-05 05:47:55 UTC

2026-04-05 05:47:45 UTC

2026-04-05 05:47:37 UTC

2026-04-05 05:47:34 UTC

2026-04-05 05:47:21 UTC

2026-04-05 05:47:18 UTC

// n34 - A CLI to interact with NIP-34 and other stuff related to codes in nostr
// Copyright (C) 2025 Awiteb <[email protected]>
//
// 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>.
use super::*;
#[test]
fn patch_normal() {
let patch_content = r#"From 24e8522268ad675996fc3b35209ce23951236bdc Mon Sep 17 00:00:00 2001
From: Awiteb <[email protected]>
Date: Tue, 27 May 2025 19:20:42 +0000
Subject: [PATCH] chore: a to abc
Abc patch
---
src/nostr_utils/mod.rs | 1 +
1files changed, 3 insertions(+), 1 deletions(-)
diff --git a/src/nostr_utils/mod.rs b/src/nostr_utils/mod.rs
index 4120f5a..e68783c 100644
--- a/src/nostr_utils/mod.rs
+++ b/src/nostr_utils/mod.rs
@@ -103,31 +103,9 @@ impl CommandRunner for NewArgs {
- a
+ abc
--
2.49.0"#;
let patch = GitPatch::from_str(patch_content).unwrap();
assert_eq!(patch.subject, "[PATCH] chore: a to abc");
assert_eq!(patch.body, "Abc patch");
}
#[test]
fn patch_normal_with_patch_in_content() {
let patch_content = r#"From 24e8522268ad675996fc3b35209ce23951236bdc Mon Sep 17 00:00:00 2001
From: Awiteb <[email protected]>
Date: Tue, 27 May 2025 19:20:42 +0000
Subject: [PATCH] chore: Subject in subject
A good test patch
---
src/nostr_utils/mod.rs | 1 +
1files changed, 3 insertions(+), 1 deletions(-)
diff --git a/src/nostr_utils/mod.rs b/src/nostr_utils/mod.rs
index 4120f5a..e68783c 100644
--- a/src/nostr_utils/mod.rs
+++ b/src/nostr_utils/mod.rs
@@ -103,31 +103,9 @@ impl CommandRunner for NewArgs {
From: Awiteb <[email protected]>
Date: Tue, 27 May 2025 19:20:42 +0000
Subject: [PATCH] chore: What a subject
hi
---
--
2.49.0"#;
let patch = GitPatch::from_str(patch_content).unwrap();
assert_eq!(patch.subject, "[PATCH] chore: Subject in subject");
assert_eq!(patch.body, "A good test patch");
}
#[test]
fn patch_multiline_subject() {
let patch_content = r#"From 24e8522268ad675996fc3b35209ce23951236bdc Mon Sep 17 00:00:00 2001
From: Awiteb <[email protected]>
Date: Tue, 27 May 2025 19:20:42 +0000
Subject: [PATCH] chore: Some long subject yes so long one Some long subject yes
so long one
Abc patch
---
src/nostr_utils/mod.rs | 1 +
1files changed, 3 insertions(+), 1 deletions(-)
diff --git a/src/nostr_utils/mod.rs b/src/nostr_utils/mod.rs
index 4120f5a..e68783c 100644
--- a/src/nostr_utils/mod.rs
+++ b/src/nostr_utils/mod.rs
@@ -103,31 +103,9 @@ impl CommandRunner for NewArgs {
- a
+ abc
--
2.49.0"#;
let patch = GitPatch::from_str(patch_content).unwrap();
assert_eq!(
patch.subject,
"[PATCH] chore: Some long subject yes so long one Some long subject yes so long one"
);
assert_eq!(patch.body, "Abc patch");
}
#[test]
fn patch_multiline_body() {
let patch_content = r#"From 24e8522268ad675996fc3b35209ce23951236bdc Mon Sep 17 00:00:00 2001
From: Awiteb <[email protected]>
Date: Tue, 27 May 2025 19:20:42 +0000
Subject: [PATCH] chore: a to abc
Lorem ipsum dolor sit amet. 33 laborum galisum aut fugiat dicta vel accusamus
aliquam vel quisquam fuga in incidunt voluptas a aliquid neque ab iure pariatur.
Et molestiae vero a consectetur laborum et accusantium sequi. Et ratione
atque et molestiae dolorem in asperiores amet id dolor corporis in adipisci
aspernatur.
---
src/nostr_utils/mod.rs | 1 +
1files changed, 3 insertions(+), 1 deletions(-)
diff --git a/src/nostr_utils/mod.rs b/src/nostr_utils/mod.rs
index 4120f5a..e68783c 100644
--- a/src/nostr_utils/mod.rs
+++ b/src/nostr_utils/mod.rs
@@ -103,31 +103,9 @@ impl CommandRunner for NewArgs {
- a
+ abc
--
2.49.0"#;
let patch = GitPatch::from_str(patch_content).unwrap();
assert_eq!(patch.subject, "[PATCH] chore: a to abc");
assert_eq!(
patch.body,
"Lorem ipsum dolor sit amet. 33 laborum galisum aut fugiat dicta vel accusamus
aliquam vel quisquam fuga in incidunt voluptas a aliquid neque ab iure pariatur.
Et molestiae vero a consectetur laborum et accusantium sequi. Et ratione
atque et molestiae dolorem in asperiores amet id dolor corporis in adipisci
aspernatur."
);
}
#[test]
fn patch_cover_letter() {
let patch_content = r#"From 864f3018f62ab2e1265edb670d5493dafe7d2cb2 Mon Sep 17 00:00:00 2001
From: Awiteb <[email protected]>
Date: Tue, 3 Jun 2025 08:41:12 +0000
Subject: [PATCH v2 0/7] feat: Some test just a test
Cover body
Awiteb (1):
chore: Update `README.md`
README.md | 2 +-
base-commit: f670859b92d525874fd621452080c8479964ac6a
--
2.49.0"#;
let patch = GitPatch::from_str(patch_content).unwrap();
assert_eq!(patch.subject, "[PATCH v2 0/7] feat: Some test just a test");
assert_eq!(
patch.body,
"Cover body
Awiteb (1):
chore: Update `README.md`
README.md | 2 +-
base-commit: f670859b92d525874fd621452080c8479964ac6a"
);
}
#[test]
fn patch_multiline_cover_subject() {
let patch_content = r#"From 864f3018f62ab2e1265edb670d5493dafe7d2cb2 Mon Sep 17 00:00:00 2001
From: Awiteb <[email protected]>
Date: Tue, 3 Jun 2025 08:41:12 +0000
Subject: [PATCH v2 0/7] feat: Some test just a test some test just a test some
test just a test
Cover body
Awiteb (1):
chore: Update `README.md`
README.md | 2 +-
base-commit: f670859b92d525874fd621452080c8479964ac6a
--
2.49.0"#;
let patch = GitPatch::from_str(patch_content).unwrap();
assert_eq!(
patch.subject,
"[PATCH v2 0/7] feat: Some test just a test some test just a test some test just a test"
);
assert_eq!(
patch.body,
"Cover body
Awiteb (1):
chore: Update `README.md`
README.md | 2 +-
base-commit: f670859b92d525874fd621452080c8479964ac6a"
);
}
#[test]
fn patch_multiline_cover_body() {
let patch_content = r#"From 864f3018f62ab2e1265edb670d5493dafe7d2cb2 Mon Sep 17 00:00:00 2001
From: Awiteb <[email protected]>
Date: Tue, 3 Jun 2025 08:41:12 +0000
Subject: [PATCH v2 0/7] feat: Some test just a test some test just a test some
test just a test
Lorem ipsum dolor sit amet. 33 laborum galisum aut fugiat dicta vel accusamus
aliquam vel quisquam fuga in incidunt voluptas a aliquid neque ab iure pariatur.
Et molestiae vero a consectetur laborum et accusantium sequi. Et ratione
atque et molestiae dolorem in asperiores amet id dolor corporis in adipisci
aspernatur.
Awiteb (1):
chore: Update `README.md`
README.md | 2 +-
base-commit: f670859b92d525874fd621452080c8479964ac6a
--
2.49.0"#;
let patch = GitPatch::from_str(patch_content).unwrap();
assert_eq!(
patch.subject,
"[PATCH v2 0/7] feat: Some test just a test some test just a test some test just a test"
);
assert_eq!(
patch.body,
"Lorem ipsum dolor sit amet. 33 laborum galisum aut fugiat dicta vel accusamus
aliquam vel quisquam fuga in incidunt voluptas a aliquid neque ab iure pariatur.
Et molestiae vero a consectetur laborum et accusantium sequi. Et ratione
atque et molestiae dolorem in asperiores amet id dolor corporis in adipisci
aspernatur.
Awiteb (1):
chore: Update `README.md`
README.md | 2 +-
base-commit: f670859b92d525874fd621452080c8479964ac6a"
);
}
#[test]
fn normal_patch_filename() {
let mut patch = GitPatch {
inner: String::new(),
subject: String::new(),
body: String::new(),
};
patch.subject = "[PATCH v2 0/3] feat: Some test just a test".to_owned();
assert_eq!(
patch.filename("").unwrap(),
PathBuf::from("v2-0000-cover-letter.patch")
);
patch.subject = "[PATCH 0/3] feat: Some test just a test".to_owned();
assert_eq!(
patch.filename("").unwrap(),
PathBuf::from("0000-cover-letter.patch")
);
patch.subject = "[PATCH v2 1/3] feat: Some test just a test".to_owned();
assert_eq!(
patch.filename("").unwrap(),
PathBuf::from("v2-0001-feat-some-test-just-a-test.patch")
);
patch.subject = "[PATCH v42 1/3] feat: Some test just a test".to_owned();
assert_eq!(
patch.filename("").unwrap(),
PathBuf::from("v42-0001-feat-some-test-just-a-test.patch")
);
patch.subject = "[PATCH v42 23/30] feat: Some test just a test".to_owned();
assert_eq!(
patch.filename("").unwrap(),
PathBuf::from("v42-0023-feat-some-test-just-a-test.patch")
);
patch.subject = "[PATCH 1/3] feat: Some test just a test".to_owned();
assert_eq!(
patch.filename("").unwrap(),
PathBuf::from("0001-feat-some-test-just-a-test.patch")
);
patch.subject = "[PATCH 32/50] feat: Some test just a test".to_owned();
assert_eq!(
patch.filename("").unwrap(),
PathBuf::from("0032-feat-some-test-just-a-test.patch")
);
patch.subject = "[PATCH v100 32/50] feat: some long subject some long subject some long \
subject some long subject"
.to_owned();
assert_eq!(
patch.filename("").unwrap(),
PathBuf::from("v100-0032-feat-some-long-subject-some-long-subject-some-long-subject.patch")
);
}
#[test]
fn patch_filename_without_patch() {
let mut patch = GitPatch {
inner: String::new(),
subject: "[RFC v5 1/2] Something".to_owned(),
body: String::new(),
};
assert!(patch.filename("").is_err());
patch.subject = "Something".to_owned();
assert!(patch.filename("").is_err());
}
#[test]
fn patch_filename_without_number() {
let mut patch = GitPatch {
inner: String::new(),
subject: "[PATCH v5 /2] Something".to_owned(),
body: String::new(),
};
assert!(patch.filename("").is_err());
patch.subject = "[PATCH v5 2/] Something".to_owned();
assert!(patch.filename("").is_err());
}
#[test]
fn patch_filename_without_version() {
let patch = GitPatch {
inner: String::new(),
subject: "[PATCH 1/2] Something".to_owned(),
body: String::new(),
};
assert!(patch.filename("").is_ok());
}

2026-04-05 05:47:10 UTC

2026-04-05 05:47:04 UTC

2026-04-05 05:46:58 UTC

2026-04-05 05:46:52 UTC

2026-04-05 05:46:47 UTC

2026-04-05 05:46:41 UTC

2026-04-05 05:46:36 UTC

2026-04-05 05:46:26 UTC

2026-04-05 05:46:16 UTC

// n34 - A CLI to interact with NIP-34 and other stuff related to codes in nostr
// Copyright (C) 2025 Awiteb <[email protected]>
//
// 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>.
use std::{iter, str::FromStr, sync::Arc};
use either::Either;
use futures::future;
use nostr::{
event::{Event, EventBuilder, EventId, Kind, Tag, TagKind},
filter::Filter,
hashes::sha1::Hash as Sha1Hash,
nips::{nip10::Marker, nip19::ToBech32},
types::RelayUrl,
};
use super::{
issue::IssueStatus,
patch::PatchStatus,
types::{NaddrOrSet, NostrEvent},
};
use crate::{
cli::traits::{OptionNaddrOrSetVecExt, RelayOrSetVecExt},
nostr_utils::{NostrClient, traits::NaddrsUtils, utils},
};
use crate::{
cli::{CliOptions, patch::GitPatch},
error::{N34Error, N34Result},
nostr_utils::traits::{GitIssueUtils, GitPatchUtils, ReposUtils},
};
/// Updates the issue's status to `new_status` after validating it with
/// `check_fn`.
pub async fn issue_status_command(
options: CliOptions,
issue_id: NostrEvent,
naddrs: Option<Vec<NaddrOrSet>>,
new_status: IssueStatus,
check_fn: impl FnOnce(&IssueStatus) -> N34Result<()>,
) -> N34Result<()> {
let naddrs = utils::naddrs_or_file(
naddrs.flat_naddrs(&options.config.sets)?,
&utils::nostr_address_path()?,
)?;
let relays = options.relays.clone().flat_relays(&options.config.sets)?;
let client = NostrClient::init(&options, &relays).await;
let user_pubk = client.pubkey().await?;
client
.add_relays(&[naddrs.extract_relays(), issue_id.relays].concat())
.await;
let owners = naddrs.extract_owners();
let coordinates = naddrs.clone().into_coordinates();
let repos = client.fetch_repos(&coordinates).await?;
let maintainers = repos.extract_maintainers();
let relay_hint = repos.extract_relays().first().cloned();
client.add_relays(&repos.extract_relays()).await;
let issue_event = client
.fetch_event(Filter::new().id(issue_id.event_id))
.await?
.ok_or(N34Error::CanNotFoundIssue)?;
let issue_status = client
.fetch_issue_status(
issue_id.event_id,
[maintainers.as_slice(), &[issue_event.pubkey], &owners].concat(),
)
.await?;
check_fn(&issue_status)?;
let status_event = EventBuilder::new(new_status.kind(), "")
.pow(options.pow.unwrap_or_default())
.tag(utils::event_reply_tag(
&issue_id.event_id,
relay_hint.as_ref(),
Marker::Root,
))
.tag(Tag::public_key(issue_event.pubkey))
.tags(maintainers.iter().map(|p| Tag::public_key(*p)))
.tags(owners.iter().map(|p| Tag::public_key(*p)))
.tags(
coordinates
.into_iter()
.map(|c| Tag::coordinate(c, relay_hint.clone())),
)
.dedup_tags()
.build(user_pubk);
let event_id = status_event.id.expect("There is an id");
let user_relays_list = client.user_relays_list(user_pubk).await?;
let write_relays = [
relays,
naddrs.extract_relays(),
repos.extract_relays(),
utils::add_write_relays(user_relays_list.as_ref()),
client.read_relays_from_user(issue_event.pubkey).await,
client
.read_relays_from_users(&[maintainers, owners].concat())
.await,
]
.concat();
let success = client
.send_event_to(status_event, user_relays_list.as_ref(), &write_relays)
.await?;
let nevent = utils::new_nevent(event_id, &success)?;
println!("Issue status created: {nevent}");
Ok(())
}
/// Updates the patch's status to `new_status` after validating it with
/// `check_fn`.
pub async fn patch_status_command(
options: CliOptions,
patch_id: NostrEvent,
naddrs: Option<Vec<NaddrOrSet>>,
new_status: PatchStatus,
merge_or_applied_commits: Option<Either<Sha1Hash, Vec<Sha1Hash>>>,
merge_or_applied_patches: Vec<EventId>,
check_fn: impl FnOnce(&PatchStatus) -> N34Result<()>,
) -> N34Result<()> {
let naddrs = utils::naddrs_or_file(
naddrs.flat_naddrs(&options.config.sets)?,
&utils::nostr_address_path()?,
)?;
let relays = options.relays.clone().flat_relays(&options.config.sets)?;
let client = NostrClient::init(&options, &relays).await;
let user_pubk = client.pubkey().await?;
client
.add_relays(&[naddrs.extract_relays(), patch_id.relays].concat())
.await;
let owners = naddrs.extract_owners();
let coordinates = naddrs.clone().into_coordinates();
let repos = client.fetch_repos(&coordinates).await?;
let maintainers = repos.extract_maintainers();
let relay_hint = repos.extract_relays().first().cloned();
client.add_relays(&repos.extract_relays()).await;
let patch_event = client.fetch_patch(patch_id.event_id).await?;
if patch_event.is_revision_patch() && !new_status.is_merged_or_applied() {
return Err(N34Error::InvalidStatus(
"Invalid action for patch revision. Only 'apply' or 'merge' are allowed, 'open', \
'close', and 'draft' are not supported."
.to_owned(),
));
}
let (root_patch, root_revision) = get_patch_root_revision(&patch_event)?;
let patch_status = client
.fetch_patch_status(
root_patch,
root_revision,
[maintainers.as_slice(), &[patch_event.pubkey], &owners].concat(),
)
.await?;
check_fn(&patch_status)?;
let mut status_builder = EventBuilder::new(new_status.kind(), "")
.pow(options.pow.unwrap_or_default())
.tag(utils::event_reply_tag(
&root_patch,
relay_hint.as_ref(),
Marker::Root,
))
.tag(Tag::public_key(patch_event.pubkey))
.tags(maintainers.iter().map(|p| Tag::public_key(*p)))
.tags(owners.iter().map(|p| Tag::public_key(*p)))
.tags(
coordinates
.into_iter()
.map(|c| Tag::coordinate(c, relay_hint.clone())),
);
if new_status.is_merged_or_applied() {
if let Some(merge_commit) = merge_or_applied_commits
.as_ref()
.and_then(|e| e.as_ref().left())
{
let commit = merge_commit.to_string();
status_builder = status_builder
.tag(Tag::custom(
TagKind::custom("merge-commit"),
iter::once(&commit),
))
.tag(Tag::reference(commit));
} else if let Some(applied_commits) = merge_or_applied_commits.and_then(|e| e.right()) {
let commits = applied_commits
.iter()
.map(ToString::to_string)
.collect::<Vec<_>>();
status_builder = status_builder
.tag(Tag::custom(TagKind::custom("applied-as-commits"), &commits))
.tags(commits.into_iter().map(Tag::reference));
};
if let Some(root_revision) = root_revision {
status_builder = status_builder.tag(utils::event_reply_tag(
&root_revision,
relay_hint.as_ref(),
Marker::Reply,
));
}
if !merge_or_applied_patches.is_empty() {
status_builder = status_builder.tags(
build_patches_quote(client.clone(), relay_hint.clone(), merge_or_applied_patches)
.await,
);
}
}
let status_event = status_builder.dedup_tags().build(user_pubk);
let event_id = status_event.id.expect("There is an id");
let user_relays_list = client.user_relays_list(user_pubk).await?;
let write_relays = [
relays,
naddrs.extract_relays(),
repos.extract_relays(),
utils::add_write_relays(user_relays_list.as_ref()),
client.read_relays_from_user(patch_event.pubkey).await,
client
.read_relays_from_users(&[maintainers, owners].concat())
.await,
]
.concat();
let success = client
.send_event_to(status_event, user_relays_list.as_ref(), &write_relays)
.await?;
let nevent = utils::new_nevent(event_id, &success)?;
println!("Patch status created: {nevent}");
Ok(())
}
/// Fetch and display patches and issues for given repositories.
/// If `list_patches` is true, lists patches instead of issues.
/// `limit` controls the maximum number of items to fetch.
pub async fn list_patches_and_issues(
options: CliOptions,
naddrs: Option<Vec<NaddrOrSet>>,
list_patches: bool,
limit: usize,
) -> N34Result<()> {
let naddrs = utils::check_empty_naddrs(utils::naddrs_or_file(
naddrs.flat_naddrs(&options.config.sets)?,
&utils::nostr_address_path()?,
)?)?;
let relays = options.relays.clone().flat_relays(&options.config.sets)?;
let client = NostrClient::init(&options, &relays).await;
client.add_relays(&naddrs.extract_relays()).await;
let coordinates = naddrs.clone().into_coordinates();
let repos = client.fetch_repos(&coordinates).await?;
let authorized_pubkeys = [naddrs.extract_owners(), repos.extract_maintainers()].concat();
client.add_relays(&repos.extract_relays()).await;
// This helps discover issues and their status.
client
.add_relays(&client.read_relays_from_users(&authorized_pubkeys).await)
.await;
let kind = if list_patches {
Kind::GitPatch
} else {
Kind::GitIssue
};
let mut filter = Filter::new()
.coordinates(coordinates.iter())
.kind(kind)
.limit(limit);
if list_patches {
filter = filter.hashtag("root");
}
let arc_client = Arc::new(client);
// Events are sorted by kind in ascending order:
// 1630 (Open), 1631 (Resolved/Applied), 1632 (Closed), 1633 (Draft)
let events = utils::sort_by_key(
future::join_all(
arc_client
.fetch_events(filter)
.await?
.into_iter()
.take(limit)
.map(|event| {
let c = arc_client.clone();
let keys = authorized_pubkeys.clone();
async move {
let status = if list_patches {
let (root, root_revision) = get_patch_root_revision(&event)?;
c.fetch_patch_status(
root,
root_revision,
[keys.as_slice(), &[event.pubkey]].concat(),
)
.await
.map(Either::Left)?
} else {
c.fetch_issue_status(
event.id,
[keys.as_slice(), &[event.pubkey]].concat(),
)
.await
.map(Either::Right)?
};
N34Result::Ok((event, status))
}
}),
)
.await
.into_iter()
.filter_map(|r| r.ok()),
|(_, status)| status.as_ref().either_into::<Kind>(),
);
let lines = events
.map(|(event, status)| format_patch_and_issue(&event, status))
.collect::<Vec<String>>();
let max_width = lines
.iter()
.map(|s| s.split_once('\n').map_or(85, |(l, _)| l.chars().count()))
.max()
.unwrap_or(85)
.max(67); // length of the event id
println!("{}", lines.join(&format!("{}\n", "-".repeat(max_width))));
Ok(())
}
/// Returns a tuple of (root_id, patch_id) if this is a valid root or revision
/// patch.
fn get_patch_root_revision(patch_event: &Event) -> N34Result<(EventId, Option<EventId>)> {
if patch_event.is_revision_patch() {
Ok((
patch_event.root_patch_from_revision()?,
Some(patch_event.id),
))
} else if patch_event.is_root_patch() {
Ok((patch_event.id, None))
} else {
Err(N34Error::NotRootPatch)
}
}
/// Formats an event as either a patch or an issue. For patches, extracts the
/// subject line from the Git patch format. For issues, combines the subject
/// with labels. The output includes status and formatted ID.
fn format_patch_and_issue(event: &Event, status: Either<PatchStatus, IssueStatus>) -> String {
let subject = if status.is_left() {
GitPatch::from_str(&event.content)
.map(|p| p.subject)
.unwrap_or_else(|_| {
event
.content
.lines()
.find(|line| line.trim().starts_with("Subject: "))
.unwrap_or_default()
.trim()
.trim_start_matches("Subject: ")
.to_owned()
})
} else {
let labels = event.extract_issue_labels();
let subject = event.extract_issue_subject();
if labels.is_empty() {
subject.to_owned()
} else {
format!(r#""{subject}" {labels}"#)
}
};
format!(
"({status}) {}\nID: {}\n",
utils::smart_wrap(&subject, 85),
event.id.to_bech32().expect("Infallible")
)
}
/// Generates a list of tags for quoting patches in merge/applied status events.
async fn build_patches_quote(
client: NostrClient,
relay_hint: Option<RelayUrl>,
patches: Vec<EventId>,
) -> Vec<Tag> {
let client = Arc::new(client);
let relay_hint = Arc::new(relay_hint);
future::join_all(patches.into_iter().map(|eid| {
let task_relay = Arc::clone(&relay_hint);
let task_client = Arc::clone(&client);
async move {
Tag::custom(
TagKind::q(),
[
eid.to_hex(),
task_relay
.as_ref()
.as_ref()
.map(|r| r.to_string())
.unwrap_or_default(),
task_client
.event_author(eid)
.await
.ok()
.flatten()
.map(|p| p.to_hex())
.unwrap_or_default(),
],
)
}
}))
.await
}

2026-04-05 05:46:15 UTC

2026-04-05 05:46:03 UTC

2026-04-05 05:45:52 UTC

2026-04-05 05:45:41 UTC

2026-04-05 05:45:27 UTC

2026-04-05 05:45:26 UTC

2026-04-05 05:45:16 UTC

2026-04-05 05:45:05 UTC

2026-04-05 05:44:54 UTC

2026-04-05 05:44:43 UTC

2026-04-05 05:44:23 UTC

2026-04-05 05:44:05 UTC

// n34 - A CLI to interact with NIP-34 and other stuff related to codes in nostr
// Copyright (C) 2025 Awiteb <[email protected]>
//
// 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>.
use super::*;
#[test]
fn patch_normal() {
let patch_content = r#"From 24e8522268ad675996fc3b35209ce23951236bdc Mon Sep 17 00:00:00 2001
From: Awiteb <[email protected]>
Date: Tue, 27 May 2025 19:20:42 +0000
Subject: [PATCH] chore: a to abc
Abc patch
---
src/nostr_utils/mod.rs | 1 +
1files changed, 3 insertions(+), 1 deletions(-)
diff --git a/src/nostr_utils/mod.rs b/src/nostr_utils/mod.rs
index 4120f5a..e68783c 100644
--- a/src/nostr_utils/mod.rs
+++ b/src/nostr_utils/mod.rs
@@ -103,31 +103,9 @@ impl CommandRunner for NewArgs {
- a
+ abc
--
2.49.0"#;
let patch = GitPatch::from_str(patch_content).unwrap();
assert_eq!(patch.subject, "[PATCH] chore: a to abc");
assert_eq!(patch.body, "Abc patch");
}
#[test]
fn patch_normal_with_patch_in_content() {
let patch_content = r#"From 24e8522268ad675996fc3b35209ce23951236bdc Mon Sep 17 00:00:00 2001
From: Awiteb <[email protected]>
Date: Tue, 27 May 2025 19:20:42 +0000
Subject: [PATCH] chore: Subject in subject
A good test patch
---
src/nostr_utils/mod.rs | 1 +
1files changed, 3 insertions(+), 1 deletions(-)
diff --git a/src/nostr_utils/mod.rs b/src/nostr_utils/mod.rs
index 4120f5a..e68783c 100644
--- a/src/nostr_utils/mod.rs
+++ b/src/nostr_utils/mod.rs
@@ -103,31 +103,9 @@ impl CommandRunner for NewArgs {
From: Awiteb <[email protected]>
Date: Tue, 27 May 2025 19:20:42 +0000
Subject: [PATCH] chore: What a subject
hi
---
--
2.49.0"#;
let patch = GitPatch::from_str(patch_content).unwrap();
assert_eq!(patch.subject, "[PATCH] chore: Subject in subject");
assert_eq!(patch.body, "A good test patch");
}
#[test]
fn patch_multiline_subject() {
let patch_content = r#"From 24e8522268ad675996fc3b35209ce23951236bdc Mon Sep 17 00:00:00 2001
From: Awiteb <[email protected]>
Date: Tue, 27 May 2025 19:20:42 +0000
Subject: [PATCH] chore: Some long subject yes so long one Some long subject yes
so long one
Abc patch
---
src/nostr_utils/mod.rs | 1 +
1files changed, 3 insertions(+), 1 deletions(-)
diff --git a/src/nostr_utils/mod.rs b/src/nostr_utils/mod.rs
index 4120f5a..e68783c 100644
--- a/src/nostr_utils/mod.rs
+++ b/src/nostr_utils/mod.rs
@@ -103,31 +103,9 @@ impl CommandRunner for NewArgs {
- a
+ abc
--
2.49.0"#;
let patch = GitPatch::from_str(patch_content).unwrap();
assert_eq!(
patch.subject,
"[PATCH] chore: Some long subject yes so long one Some long subject yes so long one"
);
assert_eq!(patch.body, "Abc patch");
}
#[test]
fn patch_multiline_body() {
let patch_content = r#"From 24e8522268ad675996fc3b35209ce23951236bdc Mon Sep 17 00:00:00 2001
From: Awiteb <[email protected]>
Date: Tue, 27 May 2025 19:20:42 +0000
Subject: [PATCH] chore: a to abc
Lorem ipsum dolor sit amet. 33 laborum galisum aut fugiat dicta vel accusamus
aliquam vel quisquam fuga in incidunt voluptas a aliquid neque ab iure pariatur.
Et molestiae vero a consectetur laborum et accusantium sequi. Et ratione
atque et molestiae dolorem in asperiores amet id dolor corporis in adipisci
aspernatur.
---
src/nostr_utils/mod.rs | 1 +
1files changed, 3 insertions(+), 1 deletions(-)
diff --git a/src/nostr_utils/mod.rs b/src/nostr_utils/mod.rs
index 4120f5a..e68783c 100644
--- a/src/nostr_utils/mod.rs
+++ b/src/nostr_utils/mod.rs
@@ -103,31 +103,9 @@ impl CommandRunner for NewArgs {
- a
+ abc
--
2.49.0"#;
let patch = GitPatch::from_str(patch_content).unwrap();
assert_eq!(patch.subject, "[PATCH] chore: a to abc");
assert_eq!(
patch.body,
"Lorem ipsum dolor sit amet. 33 laborum galisum aut fugiat dicta vel accusamus
aliquam vel quisquam fuga in incidunt voluptas a aliquid neque ab iure pariatur.
Et molestiae vero a consectetur laborum et accusantium sequi. Et ratione
atque et molestiae dolorem in asperiores amet id dolor corporis in adipisci
aspernatur."
);
}
#[test]
fn patch_cover_letter() {
let patch_content = r#"From 864f3018f62ab2e1265edb670d5493dafe7d2cb2 Mon Sep 17 00:00:00 2001
From: Awiteb <[email protected]>
Date: Tue, 3 Jun 2025 08:41:12 +0000
Subject: [PATCH v2 0/7] feat: Some test just a test
Cover body
Awiteb (1):
chore: Update `README.md`
README.md | 2 +-
base-commit: f670859b92d525874fd621452080c8479964ac6a
--
2.49.0"#;
let patch = GitPatch::from_str(patch_content).unwrap();
assert_eq!(patch.subject, "[PATCH v2 0/7] feat: Some test just a test");
assert_eq!(
patch.body,
"Cover body
Awiteb (1):
chore: Update `README.md`
README.md | 2 +-
base-commit: f670859b92d525874fd621452080c8479964ac6a"
);
}
#[test]
fn patch_multiline_cover_subject() {
let patch_content = r#"From 864f3018f62ab2e1265edb670d5493dafe7d2cb2 Mon Sep 17 00:00:00 2001
From: Awiteb <[email protected]>
Date: Tue, 3 Jun 2025 08:41:12 +0000
Subject: [PATCH v2 0/7] feat: Some test just a test some test just a test some
test just a test
Cover body
Awiteb (1):
chore: Update `README.md`
README.md | 2 +-
base-commit: f670859b92d525874fd621452080c8479964ac6a
--
2.49.0"#;
let patch = GitPatch::from_str(patch_content).unwrap();
assert_eq!(
patch.subject,
"[PATCH v2 0/7] feat: Some test just a test some test just a test some test just a test"
);
assert_eq!(
patch.body,
"Cover body
Awiteb (1):
chore: Update `README.md`
README.md | 2 +-
base-commit: f670859b92d525874fd621452080c8479964ac6a"
);
}
#[test]
fn patch_multiline_cover_body() {
let patch_content = r#"From 864f3018f62ab2e1265edb670d5493dafe7d2cb2 Mon Sep 17 00:00:00 2001
From: Awiteb <[email protected]>
Date: Tue, 3 Jun 2025 08:41:12 +0000
Subject: [PATCH v2 0/7] feat: Some test just a test some test just a test some
test just a test
Lorem ipsum dolor sit amet. 33 laborum galisum aut fugiat dicta vel accusamus
aliquam vel quisquam fuga in incidunt voluptas a aliquid neque ab iure pariatur.
Et molestiae vero a consectetur laborum et accusantium sequi. Et ratione
atque et molestiae dolorem in asperiores amet id dolor corporis in adipisci
aspernatur.
Awiteb (1):
chore: Update `README.md`
README.md | 2 +-
base-commit: f670859b92d525874fd621452080c8479964ac6a
--
2.49.0"#;
let patch = GitPatch::from_str(patch_content).unwrap();
assert_eq!(
patch.subject,
"[PATCH v2 0/7] feat: Some test just a test some test just a test some test just a test"
);
assert_eq!(
patch.body,
"Lorem ipsum dolor sit amet. 33 laborum galisum aut fugiat dicta vel accusamus
aliquam vel quisquam fuga in incidunt voluptas a aliquid neque ab iure pariatur.
Et molestiae vero a consectetur laborum et accusantium sequi. Et ratione
atque et molestiae dolorem in asperiores amet id dolor corporis in adipisci
aspernatur.
Awiteb (1):
chore: Update `README.md`
README.md | 2 +-
base-commit: f670859b92d525874fd621452080c8479964ac6a"
);
}
#[test]
fn normal_patch_filename() {
let mut patch = GitPatch {
inner: String::new(),
subject: String::new(),
body: String::new(),
};
patch.subject = "[PATCH v2 0/3] feat: Some test just a test".to_owned();
assert_eq!(
patch.filename("").unwrap(),
PathBuf::from("v2-0000-cover-letter.patch")
);
patch.subject = "[PATCH 0/3] feat: Some test just a test".to_owned();
assert_eq!(
patch.filename("").unwrap(),
PathBuf::from("0000-cover-letter.patch")
);
patch.subject = "[PATCH v2 1/3] feat: Some test just a test".to_owned();
assert_eq!(
patch.filename("").unwrap(),
PathBuf::from("v2-0001-feat-some-test-just-a-test.patch")
);
patch.subject = "[PATCH v42 1/3] feat: Some test just a test".to_owned();
assert_eq!(
patch.filename("").unwrap(),
PathBuf::from("v42-0001-feat-some-test-just-a-test.patch")
);
patch.subject = "[PATCH v42 23/30] feat: Some test just a test".to_owned();
assert_eq!(
patch.filename("").unwrap(),
PathBuf::from("v42-0023-feat-some-test-just-a-test.patch")
);
patch.subject = "[PATCH 1/3] feat: Some test just a test".to_owned();
assert_eq!(
patch.filename("").unwrap(),
PathBuf::from("0001-feat-some-test-just-a-test.patch")
);
patch.subject = "[PATCH 32/50] feat: Some test just a test".to_owned();
assert_eq!(
patch.filename("").unwrap(),
PathBuf::from("0032-feat-some-test-just-a-test.patch")
);
patch.subject = "[PATCH v100 32/50] feat: some long subject some long subject some long \
subject some long subject"
.to_owned();
assert_eq!(
patch.filename("").unwrap(),
PathBuf::from("v100-0032-feat-some-long-subject-some-long-subject-some-long-subject.patch")
);
}
#[test]
fn patch_filename_without_patch() {
let mut patch = GitPatch {
inner: String::new(),
subject: "[RFC v5 1/2] Something".to_owned(),
body: String::new(),
};
assert!(patch.filename("").is_err());
patch.subject = "Something".to_owned();
assert!(patch.filename("").is_err());
}
#[test]
fn patch_filename_without_number() {
let mut patch = GitPatch {
inner: String::new(),
subject: "[PATCH v5 /2] Something".to_owned(),
body: String::new(),
};
assert!(patch.filename("").is_err());
patch.subject = "[PATCH v5 2/] Something".to_owned();
assert!(patch.filename("").is_err());
}
#[test]
fn patch_filename_without_version() {
let patch = GitPatch {
inner: String::new(),
subject: "[PATCH 1/2] Something".to_owned(),
body: String::new(),
};
assert!(patch.filename("").is_ok());
}

2026-04-05 05:43:46 UTC

2026-04-05 05:43:33 UTC

2026-04-05 05:43:21 UTC

2026-04-05 05:43:08 UTC

2026-04-05 05:42:54 UTC