<unnamed>

Public Key

npub1xe6ua0ef6ehwhzvyc06jn5mayjc4hkzhcpqv5p858l3897sx3suqy0d9r6

Profile Code

nprofile1qqsrvawwhu5avmht3xzv8aff6d7jfv2mmptuqsx2qn6rlcnjlgrgcwqpz3mhxue69uhhyetvv9ujuerpd46hxtnfduqs6amnwvaz7tmwdaejumr0ds7ut8ks

Publishing to

relay.damus.io

nos.lol

Last Notes

2026-04-05 02:58:58 CEST

- reply

Build manifest for get_file_hash v0.4.4-n34.0

2026-04-05 02:58:45 CEST

<?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 02:58:34 CEST

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 02:58:23 CEST

//! 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 02:58:10 CEST

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 02:57:42 CEST

#![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 02:57:31 CEST

#[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 02:57:20 CEST

[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 02:57:07 CEST

//! 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 02:56:53 CEST

2026-04-05 02:56:42 CEST

// 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 02:56:31 CEST

2026-04-05 02:56:19 CEST

<?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 02:56:07 CEST

2026-04-05 02:55:53 CEST

2026-04-05 02:55:39 CEST

// 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 02:55:25 CEST

2026-04-05 02:55:14 CEST

#![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 02:55:03 CEST

2026-04-05 02:54:52 CEST

2026-04-05 02:54:40 CEST

2026-04-05 02:54:29 CEST

2026-04-05 02:54:18 CEST

2026-04-05 02:54:07 CEST

2026-04-05 02:53:56 CEST

2026-04-05 02:53:45 CEST

2026-04-05 02:53:33 CEST

2026-04-05 02:53:20 CEST

// 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 02:53:09 CEST

2026-04-05 02:52:58 CEST

2026-04-05 02:52:46 CEST

2026-04-05 02:52:35 CEST

2026-04-05 02:52:25 CEST

2026-04-05 02:52:14 CEST

2026-04-05 02:52:03 CEST

2026-04-05 02:51:52 CEST

2026-04-05 02:51:40 CEST

2026-04-05 02:51:27 CEST

// 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 02:51:14 CEST

2026-04-05 02:51:03 CEST

2026-04-05 02:50:51 CEST

2026-04-05 02:50:40 CEST

2026-04-05 02:50:30 CEST

2026-04-05 02:50:19 CEST

2026-04-05 02:50:08 CEST

2026-04-05 02:49:57 CEST

2026-04-05 02:49:46 CEST

2026-04-05 02:49:34 CEST

2026-04-05 02:49:23 CEST

2026-04-05 02:49:12 CEST

2026-04-05 02:49:02 CEST

2026-04-05 02:48:50 CEST

2026-04-05 02:48:39 CEST

2026-04-05 02:48:28 CEST

2026-04-05 02:48:17 CEST

2026-04-05 02:48:06 CEST

2026-04-05 02:47:55 CEST

2026-04-05 02:47:45 CEST

2026-04-05 02:47:34 CEST

2026-04-05 02:47:23 CEST

2026-04-05 02:47:12 CEST

2026-04-05 02:47:02 CEST

#!/usr/bin/env sh
cargo run --bin n34 -- repo view naddr1qqpkuve5qgsqqqqqq9g9uljgjfcyd6dm4fegk8em2yfz0c3qp3tc6mntkrrhawgrqsqqqaueqyf8wumn8ghj7mn0wd68yt35wfejumnvqyt8wumn8ghj7un9d3shjtnswf5k6ctv9ehx2aqpp4mhxue69uhkummn9ekx7mqppamhxue69uhkummnw3ezumt0d5q3gamnwvaz7tmjv4kxz7fwv3sk6atn9e5k7qg5waehxw309ahx7um5wghx77r5wghxgetkxpx8xj

2026-04-05 02:46:51 CEST

unstable_features = true
style_edition = "2024"
blank_lines_upper_bound = 2
combine_control_expr = false
wrap_comments = true
condense_wildcard_suffixes = true
edition = "2024"
enum_discrim_align_threshold = 20
force_multiline_blocks = true
format_code_in_doc_comments = true
format_generated_files = false
format_macro_matchers = true
format_strings = true
imports_layout = "HorizontalVertical"
newline_style = "Unix"
normalize_comments = true
reorder_impl_items = true
group_imports = "StdExternalCrate"
single_line_let_else_max_width = 0
struct_field_align_threshold = 20
use_try_shorthand = true

2026-04-05 02:46:40 CEST

# This file contains NIP-19 `naddr` entities for repositories that accept this
# project's issues and patches.
#
# The file acts as a **read-only reference** for retrieving repository relays
# when embedded in an `naddr` and mentions those repositories when opening
# patches or issues. Modifications here will not affect in the relays, as the
# file is **explicitly untracked**. Its goal is to simplify contributions by
# removing the need for manual address entry.
#
# Each entry must start with "naddr". Embedded relays are **strongly recommended**
# to assist client-side discovery.
#
# Empty lines are ignored. Lines starting with "#" are treated as comments.
naddr1qqpkuve5qgsqqqqqq9g9uljgjfcyd6dm4fegk8em2yfz0c3qp3tc6mntkrrhawgrqsqqqaueqyf8wumn8ghj7mn0wd68yt35wfejumnvqyt8wumn8ghj7un9d3shjtnswf5k6ctv9ehx2aqpp4mhxue69uhkummn9ekx7mqppamhxue69uhkummnw3ezumt0d5q3gamnwvaz7tmjv4kxz7fwv3sk6atn9e5k7qg5waehxw309ahx7um5wghx77r5wghxgetkxpx8xj

2026-04-05 02:46:29 CEST

# This justfile is for the contrbutors of this project, not for the end user.
#
# Requirements for this justfile:
# - Linux distribution
# - just (Of course) <https://github.com/casey/just>
# - cargo (For the build and tests) <https://doc.rust-lang.org/cargo/getting-started/installation.html>
# - mdbook (<https://rust-lang.github.io/mdBook>)
# - git-cliff (<https://git-cliff.org>)
# - taplo (<https://taplo.tamasfe.dev/>)
# - cargo-msrv (<https://github.com/foresterre/cargo-msrv>)
# - nushell (<https://nushell.sh>)
set quiet
set unstable
set shell := ["/usr/bin/env", "bash", "-c"]
set script-interpreter := ["/usr/bin/env", "nu"]
JUST_EXECUTABLE := "just -u -f " + justfile()
header := "Available tasks:\n"
BOOK_DEST_DIR := "dest"
tag_change_body := '''{% for group, commits in commits | group_by(attribute="group") %}
{{ group | upper_first }}
{% for commit in commits %}
- {{ commit.message | split(pat="\n") | first | split(pat=":") | slice(start=1) | join(sep=":") | upper_first | trim }} - by {{ commit.author.name}}{% endfor %}{% endfor %}
'''
export TZ := "UTC"
_default:
@{{JUST_EXECUTABLE}} --list-heading "{{header}}" --list
# Run the CI
ci: && msrv _done_ci
echo "🔨 Building n34..."
cargo build -q
echo "🔍 Checking code formatting..."
cargo fmt -q -- --check
RUST_LOG=none taplo fmt --check --config "./.taplo.toml" || (echo "❌Toml files is not properly formatted" && exit 1)
echo "🧹 Running linter checks..."
cargo clippy -q -- -D warnings
echo "🧪 Running tests..."
cargo test -q
# Check that the current MSRV is correct
msrv:
echo "🔧 Verifying MSRV..."
cargo-msrv verify
echo "✅ MSRV verification passed"
_done_ci:
echo "🎉 CI pipeline completed successfully"
# Update the changelog
[script]
changelog:
def get_hash [] { open "./CHANGELOG.md" | hash sha256 }
let old_hash = get_hash
git-cliff out> "CHANGELOG.md"
if old_hash != get_hash {
git add "CHANGELOG.md"
git commit -m "chore(changelog): Update the changelog"
print "The changes have been added to the changelog file and committed"
} else {
print "No changes have been added to the changelog"
}
# Releases a new version of n34. Requires a clean file tree with no uncommitted changes.
[script]
release version:
let tag_msg = "Version {{ version }}" + (git-cliff --strip all --unreleased --body '{{ tag_change_body }}')
mut cargo_file = open "Cargo.toml"
$cargo_file.package.version = "{{ version }}"
$cargo_file | save -f "Cargo.toml"
RUST_LOG=none taplo fmt --config "./.taplo.toml"
{{ JUST_EXECUTABLE }} ci
git-cliff -t "v{{ version }}" out> "./CHANGELOG.md"
git add .
git commit -m "chore: Bump the version to `v{{ version }}`"
git tag -s -m $tag_msg "v{{ version }}"
git push origin master --tags
cargo publish
# Deploy the book to Github Pages
deploy:
mdbook build --dest-dir {{ BOOK_DEST_DIR }}
cd {{ BOOK_DEST_DIR }}
git init .
git checkout -B gh-pages
touch ".nojekyll"
echo "n34.dev" > "CNAME"
git add .
git commit -m "Deploy the book to github pages"
git remote add origin "[email protected]:TheAwiteb/n34-book"
git push origin gh-pages -f
cd ..
rm -fr {{ BOOK_DEST_DIR }}

2026-04-05 02:46:18 CEST

{
inputs = {
nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
rust-overlay.url = "github:oxalica/rust-overlay";
flake-utils.url = "github:numtide/flake-utils";
};
outputs =
{
nixpkgs,
rust-overlay,
flake-utils,
...
}:
flake-utils.lib.eachDefaultSystem (
system:
let
overlays = [ (import rust-overlay) ];
pkgs = import nixpkgs { inherit system overlays; };
in
with pkgs;
{
devShells.default = mkShell {
packages = [
cargo-msrv
dbus
git-cliff
just
mdbook
nushell
pkg-config
taplo
];
nativeBuildInputs = [
(lib.hiPrio rust-bin.nightly."2025-08-07".rustfmt)
rust-bin.stable.latest.default
rust-analyzer
];
};
packages.default =
let
manifest = (pkgs.lib.importTOML ./Cargo.toml).package;
in
with pkgs;
rustPlatform.buildRustPackage {
pname = manifest.name;
version = manifest.version;
cargoLock.lockFile = ./Cargo.lock;
src = lib.cleanSource ./.;
nativeBuildInputs = [
pkg-config
];
buildInputs = [
dbus
];
meta = {
inherit (manifest) description homepage;
license = lib.licenses.gpl3Plus;
};
};
}
);
}

2026-04-05 02:46:07 CEST

{
"nodes": {
"flake-utils": {
"inputs": {
"systems": "systems"
},
"locked": {
"lastModified": 1731533236,
"narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
"owner": "numtide",
"repo": "flake-utils",
"rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
"type": "github"
},
"original": {
"owner": "numtide",
"repo": "flake-utils",
"type": "github"
}
},
"nixpkgs": {
"locked": {
"lastModified": 1754498491,
"narHash": "sha256-erbiH2agUTD0Z30xcVSFcDHzkRvkRXOQ3lb887bcVrs=",
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "c2ae88e026f9525daf89587f3cbee584b92b6134",
"type": "github"
},
"original": {
"owner": "NixOS",
"ref": "nixos-unstable",
"repo": "nixpkgs",
"type": "github"
}
},
"nixpkgs_2": {
"locked": {
"lastModified": 1744536153,
"narHash": "sha256-awS2zRgF4uTwrOKwwiJcByDzDOdo3Q1rPZbiHQg/N38=",
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "18dd725c29603f582cf1900e0d25f9f1063dbf11",
"type": "github"
},
"original": {
"owner": "NixOS",
"ref": "nixpkgs-unstable",
"repo": "nixpkgs",
"type": "github"
}
},
"root": {
"inputs": {
"flake-utils": "flake-utils",
"nixpkgs": "nixpkgs",
"rust-overlay": "rust-overlay"
}
},
"rust-overlay": {
"inputs": {
"nixpkgs": "nixpkgs_2"
},
"locked": {
"lastModified": 1754575663,
"narHash": "sha256-afOx8AG0KYtw7mlt6s6ahBBy7eEHZwws3iCRoiuRQS4=",
"owner": "oxalica",
"repo": "rust-overlay",
"rev": "6db0fb0e9cec2e9729dc52bf4898e6c135bb8a0f",
"type": "github"
},
"original": {
"owner": "oxalica",
"repo": "rust-overlay",
"type": "github"
}
},
"systems": {
"locked": {
"lastModified": 1681028828,
"narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
"owner": "nix-systems",
"repo": "default",
"rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
"type": "github"
},
"original": {
"owner": "nix-systems",
"repo": "default",
"type": "github"
}
}
},
"root": "root",
"version": 7
}

2026-04-05 02:45:56 CEST

# Modify a Set
> `n34 sets update` command
**Usage:**
```
Modify an existing set
Usage: n34 sets update [OPTIONS] <NAME>
Arguments:
<NAME> Name of the set to update
Options:
--set-relay <RELAYS> Add relay to the set, either as URL or set name to extract its relays. [aliases: `--sr`]
--repo <NADDR-NIP05-OR-SET> Repository address in `naddr` format (`naddr1...`), NIP-05 format (`4rs.nl/n34` or `[email protected]/n34`), or a set name like `kernel`
--override Replace existing relays/repositories instead of adding to them
```
Use this command to update an existing set by its name. By default, providing
relays via `--set-relay` or repositories via `--repo` will add them to the set's
existing entries. To replace the current relays and repositories with the new
values, use the `--override` flag.
[passing repositories]: /commands.html#passing-repositories

2026-04-05 02:45:45 CEST

# Show a Set
> `n34 sets show` command
**Usage:**
```
Show a single set or all the stored sets
Usage: n34 sets show [NAME]
Arguments:
[NAME] Name of the set to display. If not provided, lists all available sets
```
Prints all set names to standard output, each followed by its associated repos
and relays. To view the details for a specific set, provide its name as an
argument.

2026-04-05 02:45:34 CEST

# Remove a Set
> `n34 sets remove` command
**Usage:**
```
Remove a set, or specific repos and relays within it
Usage: n34 sets remove [OPTIONS] <NAME>
Arguments:
<NAME> Set name to delete
Options:
--set-relay <RELAYS> Specific relay to remove it from the set, either as URL or set name to extract its relays. [aliases: `--sr`]
--repo <NADDR-NIP05-OR-SET> Repository address in `naddr` format (`naddr1...`), NIP-05 format (`4rs.nl/n34` or `[email protected]/n34`), or a set name like `kernel`
```
Removes an entire set, or specific repositories and relays from it.
Without options, this command deletes the entire set.
See the [passing repositories] section for more details on supported formats.
[passing repositories]: /commands.html#passing-repositories

2026-04-05 02:45:24 CEST

# Create a Set
> `n34 sets new` command
**Usage:**
```
Create a new set
Usage: n34 sets new [OPTIONS] <NAME>
Arguments:
<NAME> Unique name for the set
Options:
--set-relay <RELAYS> Optional relay to add it to the set, either as URL or set name to extract its relays. [aliases: `--sr`]
--repo <NADDR-NIP05-OR-SET> Repository address in `naddr` format (`naddr1...`), NIP-05 format (`4rs.nl/n34` or `[email protected]/n34`), or a set name like `kernel`
```
Each set requires a unique name, provided as the final argument to the command.
Use the `--set-relays`/`--sr` option to specify the relays for the new set;
this can be a relay URL or the name of an existing set whose relays you wish to
use. To add repositories, use the `--repo` option. Check [passing repositories]
format.
[passing repositories]: /commands.html#passing-repositories

2026-04-05 02:45:13 CEST

# Managing Repository and Relay Sets
Sets are a convenience feature for contributing to projects that do not have a
`nostr-address` file. Instead of manually specifying the project's repositories
and relays for every command, you can define them once as a named "set". You can
then reference this set by its name in commands. This allows you to use the set
as a shortcut for a list of relays (`--relays <set_name>`) or as the project's
address in commands like `issue` and `patch`.
Sets are defined in your configuration file. To use a specific configuration
file, pass its path using the `--config` option.

2026-04-05 02:45:02 CEST

# View Git Repository Details
> `n34 repo view` command
**Usage:**
```
View details of a nostr git repository
Usage: n34 repo view [NADDR-NIP05-OR-SET]...
Arguments:
[NADDR-NIP05-OR-SET]... Repository address in `naddr` format (`naddr1...`), NIP-05 format (`4rs.nl/n34` or `[email protected]/n34`), or a set name like `kernel`
```
This command prints repository details to standard output. If no arguments
are provided, it looks for a `nostr-address` file in the current directory
and displays the details for the address specified within it. See [passing
repositories] for details on accepted formats.
[passing repositories]: /commands.html#passing-repositories

2026-04-05 02:44:51 CEST

# Broadcast and Update a Git Repository
> `n34 repo announce` command
**Usage:**
```
Broadcast and update a git repository
Usage: n34 repo announce [OPTIONS] --id <REPO_ID>
Options:
--id <REPO_ID> Unique identifier for the repository in kebab-case
-n, --name <NAME> A name for the repository
-d, --description <DESCRIPTION> A description for the repository
-w, --web <WEB> Webpage URLs for the repository (if provided by the git server)
-c, --clone <CLONE> URLs for cloning the repository
-m, --maintainers <MAINTAINERS> Additional maintainers of the repository (besides yourself)
-l, --label <LABEL> Labels to categorize the repository. Can be specified multiple times
--force-id Skip kebab-case validation for the repository ID
--address-file If set, creates a `nostr-address` file to enable automatic address discovery by n34
```
This command generates an announcement event to publish your project. It can be
used to announce a new repository or update an existing one.
When updating, you must resubmit all repository fields, not just the fields
you wish to change. The command uses this information to build and publish a
completely new announcement event that will replace the old one.
It is recommended to use the `--address-file` flag. This option creates
a `nostr-address` file that enables `n34` to automatically discover the
repository's address, simplifying the workflow for contributors.

2026-04-05 02:44:40 CEST

# Manage Repositories
In `n34` you can manage your repositories. This includes announcing new ones,
viewing existing ones, and announcing state updates (coming soon).

2026-04-05 02:44:30 CEST

# Reply to Issues and Patches
> `n34 reply` command
**Usage:**
```
Reply to issues and patches
Usage: n34 reply [OPTIONS] <--comment <COMMENT>|--editor> <nevent1-or-note1>
Arguments:
<nevent1-or-note1> The issue, patch, or comment to reply to
Options:
--quote-to Quote the replied-to event in the editor
--repo <NADDR-NIP05-OR-SET> Repository address in `naddr` format (`naddr1...`), NIP-05 format (`4rs.nl/n34` or `[email protected]/n34`), or a set name like `kernel`
-c, --comment <COMMENT> The comment (cannot be used with --editor)
-e, --editor Open editor to write comment (cannot be used with --content)
```
Craft replies ([NIP-22] Comment) to issues, patches, or comments with ease
using the `n34 reply` command. You can either input your reply directly with
the `--comment` option or open an editor for a more detailed response using
`--editor`. Additionally, when using `--editor`, the `--quote-to` option
allows you to include the original content in your editor, enabling precise and
context-aware replies.
[NIP-22]: https://github.com/nostr-protocol/nips/blob/master/22.md

2026-04-05 02:44:19 CEST

# Send Patches to a Repository
> `n34 patch send` command
**Usage:**
```
Send one or more patches to a repository
Usage: n34 patch send [OPTIONS] <PATCH-PATH>...
Arguments:
<PATCH-PATH>... List of patch files to send (space separated)
Options:
--repo <NADDR-NIP05-OR-SET> Repository address in `naddr` format (`naddr1...`), NIP-05 format (`4rs.nl/n34` or `[email protected]/n34`), or a set name like `kernel`
--original-patch <EVENT-ID> Original patch ID if this is a revision of it
```
Send your generated patches to the repositories specified using the `--repo`
option or retrieved from the `nostr-address` file. When submitting a revision
of an existing patch, include the original patch ID to ensure it’s correctly
referenced in your revision patch event.

2026-04-05 02:44:08 CEST

# Reopens a Closed or Drafted Patch
> `n34 patch reopen` command
**Usage:**
```
Reopens a closed or drafted patch
Usage: n34 patch reopen [OPTIONS] <PATCH_ID>
Arguments:
<PATCH_ID> The closed/drafted patch id to reopen it. Must be orignal root patch
Options:
--repo <NADDR-NIP05-OR-SET> Repository address in `naddr` format (`naddr1...`), NIP-05 format (`4rs.nl/n34` or `[email protected]/n34`), or a set name like `kernel`
```
Issue a kind `1632` (Close status) for the specified patch. The patch have to
be closed or drafted.

2026-04-05 02:43:57 CEST

# Merge an Open Patch
> `n34 patch merge` command
**Usage:**
```
Set an open patch status to merged
Usage: n34 patch merge [OPTIONS] <PATCH_ID> <MERGE_COMMIT>
Arguments:
<PATCH_ID> The open patch id to merge it. Must be orignal root patch or revision root
<MERGE_COMMIT> The merge commit id
Options:
--repo <NADDR-NIP05-OR-SET> Repository address in `naddr` format (`naddr1...`), NIP-05 format (`4rs.nl/n34` or `[email protected]/n34`), or a set name like `kernel`
--patches <PATCH-EVENT-ID> Patches that have been merged. Use this when only some patches have been merged, not all
```
Creates a kind `1631` event (Applied/Merged status) for the specified patch. The
patch must be in open status.
You can specify either an original patch or revision patch ID, but the status
event will only reference the original patch. Revision patches will be mentioned
in the event.
You can get the `MERGE_COMMIT` commit using `git rev-parse HEAD` command if
the merge commit in the `HEAD` or use `HEAD~n` where the `n` is the number of
commits the merge commit before the HEAD

2026-04-05 02:43:47 CEST

# List Repositories Patches
> `n34 patch list` command
**Usage:**
```
List the repositories patches
Usage: n34 patch list [OPTIONS] [NADDR-NIP05-OR-SET]...
Arguments:
[NADDR-NIP05-OR-SET]... Repository address in `naddr` format (`naddr1...`), NIP-05 format (`4rs.nl/n34` or `[email protected]/n34`), or a set name like `kernel`
Options:
--limit <LIMIT> Maximum number of patches to list [default: 15]
```
List the repositories patches. By default `n34` will look for `nostr-address`
file and extract the repositories from it.

2026-04-05 02:43:36 CEST

# Fetch a Patch By ID
> `n34 patch fetch` command
**Usage:**
```
Fetches a patch by its id
Usage: n34 patch fetch [OPTIONS] <PATCH_ID>
Arguments:
<PATCH_ID> The patch id to fetch it
Options:
--repo <NADDR-NIP05-OR-SET> Repository address in `naddr` format (`naddr1...`), NIP-05 format (`4rs.nl/n34` or `[email protected]/n34`), or a set name like `kernel`
-o, --output <PATH> Output directory for the patches. Default to the current directory
```
Fetches patches using their original patch ID. All fetched patches will be saved
to the specified output directory (current directory by default). You can then
apply or merge these patches into your branch as needed.

2026-04-05 02:43:26 CEST

# Draft an Open Patch
> `n34 patch draft` command
**Usage:**
```
Converts an open patch to draft state
Usage: n34 patch draft [OPTIONS] <PATCH_ID>
Arguments:
<PATCH_ID> The open patch id to draft it. Must be orignal root patch
Options:
--repo <NADDR-NIP05-OR-SET> Repository address in `naddr` format (`naddr1...`), NIP-05 format (`4rs.nl/n34` or `[email protected]/n34`), or a set name like `kernel`
```
Issue a kind `1633` (Draft status) for the specified patch. The patch have to
be open.

2026-04-05 02:43:15 CEST

# Closes an Open or Drafted Patch
> `n34 patch close` command
**Usage:**
```
Closes an open or drafted patch
Usage: n34 patch close [OPTIONS] <PATCH_ID>
Arguments:
<PATCH_ID> The open/drafted patch id to close it. Must be orignal root patch
Options:
--repo <NADDR-NIP05-OR-SET> Repository address in `naddr` format (`naddr1...`), NIP-05 format (`4rs.nl/n34` or `[email protected]/n34`), or a set name like `kernel`
```
Issue a kind `1632` (Close status) for the specified patch. The patch have to
be open or drafted.

2026-04-05 02:43:04 CEST

# Apply an Open Patch
> `n34 patch apply` command
**Usage:**
```
Set an open patch status to applied
Usage: n34 patch apply [OPTIONS] <PATCH_ID> [APPLIED_COMMITS]...
Arguments:
<PATCH_ID> The open patch id to apply it. Must be orignal root patch or revision root
[APPLIED_COMMITS]... The applied commits
Options:
--repo <NADDR-NIP05-OR-SET> Repository address in `naddr` format (`naddr1...`), NIP-05 format (`4rs.nl/n34` or `[email protected]/n34`), or a set name like `kernel`
--patches <PATCH-EVENT-ID> Patches that have been applied. Use this when only some patches have been applied, not all
```
Creates a kind `1631` event (Applied/Merged status) for the specified patch. The
patch must be in open status.
You can specify either an original patch or revision patch ID, but the status
event will only reference the original patch. Revision patches will be mentioned
in the event.
The `APPLIED_COMMITS` field serves to inform clients about the status of
specific commits, whether they have been applied or not. If you need to retrieve
the list of commits from a specific point (such as the tip of the master branch)
up to the `HEAD`, you can use the following Git command: `git log --pretty=%H
'origin/master..HEAD'`.

2026-04-05 02:42:53 CEST

# Patch Management
In `n34`, patch management is designed to give you complete control. You can
manually generate patch files using `git-format-patch` and then broadcast them
to Nostr relays. This ensures that you have full authority over the content
and structure of your patches, allowing for precise customization as per your
requirements.
Similarly, when fetching patches, `n34` provides them to you without
automatically applying, merging, or checking them. This empowers you to review
the patches at your own pace and decide whether to merge or apply them as
needed. You retain full control over the entire process, ensuring a tailored
approach to patch management.
## Patch Status Management
You can assign a status to original patches, but revision patches do not have
a specific status assigned to them. Instead, they inherit the status of the
original patch. However, if the original patch is marked as `Applied/Merged`,
the revision patch must be explicitly tagged to claim the same status. If not
tagged, the revision patch status will be `Closed`.

2026-04-05 02:42:43 CEST

# View an Issue By ID
> `n34 issue view` command
**Usage:**
```
View an issue by its ID
Usage: n34 issue view [OPTIONS] <ISSUE_ID>
Arguments:
<ISSUE_ID> The issue id to view it
Options:
--repo <NADDR-NIP05-OR-SET> Repository address in `naddr` format (`naddr1...`), NIP-05 format (`4rs.nl/n34` or `[email protected]/n34`), or a set name like `kernel`
```
Simply provide the issue ID in `note` or `nevent` format to retrieve and display
the issue details.

2026-04-05 02:42:31 CEST

# Resolves an Issue
> `n34 issue resolve` command
**Usage:**
```
Resolves an issue
Usage: n34 issue resolve [OPTIONS] <ISSUE_ID>
Arguments:
<ISSUE_ID> The issue id to resolve it
Options:
--repo <NADDR-NIP05-OR-SET> Repository address in `naddr` format (`naddr1...`), NIP-05 format (`4rs.nl/n34` or `[email protected]/n34`), or a set name like `kernel`
```
Issue a kind `1631` (Resolved status) event for the specified issue.

2026-04-05 02:42:20 CEST

# Reopen a Closed Issue
> `n34 issue reopen` command
**Usage:**
```
Reopens a closed issue
Usage: n34 issue reopen [OPTIONS] <ISSUE_ID>
Arguments:
<ISSUE_ID> The ID of the closed issue to reopen
Options:
--repo <NADDR-NIP05-OR-SET> Repository address in `naddr` format (`naddr1...`), NIP-05 format (`4rs.nl/n34` or `[email protected]/n34`), or a set name like `kernel`
```
Issue a kind `1630` (Open status) for the specified issue. The issue have to
be closed.

2026-04-05 02:42:09 CEST

# Create an Issue
> `n34 issue new` Command
**Usage:**
```
Create a new repository issue
Usage: n34 issue new [OPTIONS] <--content <CONTENT>|--editor>
Options:
--repo <NADDR-NIP05-OR-SET> Repository address in `naddr` format (`naddr1...`), NIP-05 format (`4rs.nl/n34` or `[email protected]/n34`), or a set name like `kernel`
-c, --content <CONTENT> Markdown content for the issue. Cannot be used together with the `--editor` flag
-e, --editor Opens the user's default editor to write issue content. The first line will be used as the issue subject
--subject <SUBJECT> The issue subject. Cannot be used together with the `--editor` flag
-l, --label <LABEL> Labels for the issue. Can be specified as arguments (-l bug) or hashtags in content (#bug)
```
Use the `n34 issue new` command to create a new issue in a repository. This
command supports the [NIP-21] (`nostr:` URI scheme) and hashtags within the
issue content. When you mention public keys in the content, they will be
included in the event tags. Additionally, using hashtags like `#bug` in the
issue body will automatically apply them as labels.
You must choose between the `--content` and `--editor` options. With
`--content`, you provide the issue content directly in the command. With
`--editor`, your default `$EDITOR` will open, allowing you to write the issue
content. The first line of the editor's output will be used as the issue
subject.

2026-04-05 02:41:59 CEST

# List Repositories Issues
> `n34 issue list` command
**Usage:**
```
List the repositories issues
Usage: n34 issue list [OPTIONS] [NADDR-NIP05-OR-SET]...
Arguments:
[NADDR-NIP05-OR-SET]... Repository address in `naddr` format (`naddr1...`), NIP-05 format (`4rs.nl/n34` or `[email protected]/n34`), or a set name like `kernel`
Options:
--limit <LIMIT> Maximum number of issues to list [default: 15]
```
List the repositories issues. By default `n34` will look for `nostr-address`
file and extract the repositories from it.

2026-04-05 02:41:48 CEST

# Closes an Open Issue
> `n34 issue close` command
**Usage:**
```
Closes an open issue
Usage: n34 issue close [OPTIONS] <ISSUE_ID>
Arguments:
<ISSUE_ID> The open issue id to close it
Options:
--repo <NADDR-NIP05-OR-SET> Repository address in `naddr` format (`naddr1...`), NIP-05 format (`4rs.nl/n34` or `[email protected]/n34`), or a set name like `kernel`
```
Issue a kind `1632` (Close status) for the specified issue. The issue have to
be open.

2026-04-05 02:41:37 CEST

# Issue Management
Using `n34`, you can manage Git issues stored in Nostr relays, adhering to
the [NIP-34] standard. In Nostr, events are immutable, meaning their IDs are
derived from the SHA-256 hash of their timestamp, content, author, and tags.
As a result, issues cannot be edited directly. However, with `n34`, you can
create new issues, view existing ones, or update their status—such as closing,
resolving, or reopening them.
[NIP-34] introduces support for drafting issues, though this feature is not
currently implemented in `n34` due to the lack of a clear use case for drafting
issues. The inclusion of this functionality may stem from its shared use in both
issues and patches, suggesting it was primarily designed for patch management.
[NIP-34]: https://github.com/nostr-protocol/nips/blob/master/34.md

2026-04-05 02:41:24 CEST

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<meta property="og:title" content="n34 - CLI for NIP-34 and Nostr Code Collaboration">
<meta property="og:description" content="An open source CLI for sending and receiving Git issues, patches and comments over the Nostr protocol.">
<meta property="og:url" content="https://n34.dev">
<meta property="og:type" content="website">
<meta name="twitter:card" content="summary">
<meta name="twitter:title" content="n34 - CLI for NIP-34 and Nostr Code Collaboration">
<meta name="twitter:description" content="An open source CLI for sending and receiving Git issues, patches and comments over the Nostr protocol.">
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>n34 - CLI for NIP-34 and Nostr Code Collaboration</title>
<style>
* {
margin: 0;
padding: 0;
box-sizing: border-box;
}
body {
font-family: "Segoe UI", Tahoma, Geneva, Verdana, sans-serif;
background: radial-gradient(125% 125% at 50% 90%, #000000 40%, #072607 100%);
color: #ffffff;
line-height: 1.6;
min-height: 100vh;
}
.container {
max-width: 800px;
margin: 0 auto;
padding: 60px 20px;
}
.hero {
text-align: center;
margin-bottom: 80px;
}
.hero h1 {
font-size: 4rem;
font-weight: 300;
margin-bottom: 20px;
letter-spacing: 2px;
background: linear-gradient(135deg, #ffffff, #cccccc);
-webkit-background-clip: text;
-webkit-text-fill-color: transparent;
background-clip: text;
}
.hero p {
font-size: 1.2rem;
color: #cccccc;
margin-bottom: 40px;
max-width: 600px;
margin-left: auto;
margin-right: auto;
}
.buttons {
display: flex;
gap: 20px;
justify-content: center;
flex-wrap: wrap;
}
.btn {
display: inline-block;
padding: 14px 28px;
background: transparent;
border: 2px solid #ffffff;
color: #ffffff;
text-decoration: none;
border-radius: 8px;
font-weight: 500;
font-size: 1rem;
transition: all 0.3s ease;
min-width: 120px;
text-align: center;
}
.btn:hover {
background: #ffffff;
color: #0a0a0a;
transform: translateY(-2px);
box-shadow: 0 8px 25px rgba(255, 255, 255, 0.2);
}
.section {
margin-bottom: 60px;
}
.section h2 {
font-size: 2.2rem;
margin-bottom: 30px;
color: #ffffff;
font-weight: 400;
}
.section p {
font-size: 1.1rem;
color: #e0e0e0;
margin-bottom: 20px;
text-align: justify;
}
a {
color: #cccccc;
text-decoration: underline;
font-size: 1rem;
transition: color 0.3s ease;
}
a:hover {
color: #ffffff;
}
.features {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
gap: 30px;
margin-bottom: 60px;
}
.feature {
background: #1a1a1a;
padding: 30px;
border-radius: 12px;
border: 1px solid #333;
transition: transform 0.3s ease, border-color 0.3s ease;
}
.feature:hover {
transform: translateY(-5px);
border-color: #555;
}
.feature h3 {
font-size: 1.3rem;
margin-bottom: 15px;
color: #ffffff;
display: flex;
align-items: center;
gap: 10px;
}
.feature-icon {
font-size: 1.5rem;
}
.feature p {
color: #cccccc;
font-size: 1rem;
text-align: left;
}
.feature-list {
background: #111;
padding: 40px;
border-radius: 12px;
border: 1px solid #333;
margin-bottom: 60px;
}
.feature-grid {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
gap: 20px;
margin-top: 20px;
}
.feature-column ul {
list-style: none;
padding: 0;
}
.feature-column li {
display: flex;
align-items: center;
margin-bottom: 12px;
font-size: 1rem;
padding: 8px 0;
}
.feature-check {
display: inline-block;
width: 20px;
height: 20px;
margin-right: 12px;
border-radius: 3px;
text-align: center;
line-height: 20px;
font-size: 12px;
font-weight: bold;
flex-shrink: 0;
}
.feature-check.completed {
background: #22c55e;
color: #ffffff;
}
.feature-check.pending {
background: #374151;
color: #9ca3af;
border: 1px solid #4b5563;
}
.feature-check.completed::after {
content: "✓";
}
.feature-check.pending::after {
content: "○";
}
.feature-text {
color: #e0e0e0;
}
.feature-text.pending {
color: #9ca3af;
}
.install-section {
background: #111;
padding: 40px;
border-radius: 12px;
border: 1px solid #333;
margin-bottom: 60px;
}
.install-section h2 {
margin-bottom: 20px;
text-align: center;
}
.code-block {
background: #000;
padding: 20px;
border-radius: 8px;
font-family: "Courier New", monospace;
font-size: 1rem;
border: 1px solid #333;
overflow-x: auto;
margin: 15px 0;
}
.code-block p {
color: #00ff00;
}
.code-block p::before {
content: "$ ";
color: #888;
}
.code-block span::before {
content: "$ ";
color: #888;
}
.code-block span {
color: #777;
}
.code-block pre {
color: #00ff00;
}
.links {
margin-top: 30px;
}
.links h3 {
font-size: 1.3rem;
margin-bottom: 15px;
color: #ffffff;
}
.links ul {
list-style: none;
}
.links li {
margin-bottom: 8px;
}
.links a {
color: #cccccc;
text-decoration: none;
font-size: 1rem;
transition: color 0.3s ease;
}
.links a:hover {
color: #ffffff;
}
.links a:before {
content: "→ ";
margin-right: 8px;
}
.status-badge {
display: inline-block;
padding: 4px 12px;
background: #1a4d1a;
color: #4ade80;
border-radius: 16px;
font-size: 0.8rem;
font-weight: 500;
margin-bottom: 20px;
}
.footer {
text-align: center;
padding: 40px 0;
border-top: 1px solid #333;
margin-top: 80px;
color: #888;
}
@media (max-width: 768px) {
.hero h1 {
font-size: 2.5rem;
}
.hero p {
font-size: 1.1rem;
}
.buttons {
flex-direction: column;
align-items: center;
}
.btn {
width: 200px;
}
.section h2 {
font-size: 1.8rem;
}
.features {
grid-template-columns: 1fr;
}
.feature-grid {
grid-template-columns: 1fr;
}
.install-section,
.feature-list {
padding: 20px;
}
}
</style>
</head>
<body>
<div class="container">
<div class="hero">
<div class="status-badge">✨ Looking for feedback</div>
<h1>n34</h1>
<p>
n34 is an open source command-line interface (CLI) tool for
sending and receiving Git issues, patches and comments over the
Nostr protocol. It supports creating, replying to, and managing
issues and patches, making Git collaboration decentralized and
censorship-resistant.
</p>
<div class="buttons">
<a href="https://n34.dev/commands.html" class="btn">Documentation</a>
<a href="https://git.4rs.nl/awiteb/n34.git" class="btn">Git Repository</a>
</div>
</div>
<div class="section">
<h2>Key Features</h2>
<div class="features">
<div class="feature">
<h3><span class="feature-icon">🔄</span>Complete Git Workflow</h3>
<p>Handle the full development lifecycle with patches, issues, replies, and status tracking, all through the decentralized Nostr protocol.</p>
</div>
<div class="feature">
<h3><span class="feature-icon">🔗</span><a href="https://github.com/nostr-protocol/nips/blob/master/34.md" target="_blank" rel="noreferrer">NIP-34</a> Compliant</h3>
<p>Fully implements the <a href="https://github.com/nostr-protocol/nips/blob/master/34.md" target="_blank" rel="noreferrer">NIP-34</a> specification for Git repositories on Nostr, ensuring compatibility with the decentralized ecosystem.</p>
</div>
<div class="feature">
<h3><span class="feature-icon">🛠️</span>Developer Friendly</h3>
<p>Intuitive CLI interface designed for developers who want to integrate Git workflows with Nostr seamlessly.</p>
</div>
<div class="feature">
<h3><span class="feature-icon">🔐</span>Self-Sovereign</h3>
<p>No accounts, no passwords, no centralized servers. You control your identity and data through cryptographic keys.</p>
</div>
</div>
</div>
<div class="feature-list">
<h2>Feature Roadmap</h2>
<p style="text-align: center; margin-bottom: 30px; color: #cccccc;">Current implementation status and upcoming features</p>
<div class="feature-grid">
<div class="feature-column">
<ul>
<li>
<span class="feature-check completed"></span>
<span class="feature-text">Repository announcements</span>
</li>
<li>
<span class="feature-check pending"></span>
<span class="feature-text pending">Repository state announcements</span>
</li>
<li>
<span class="feature-check completed"></span>
<span class="feature-text">Patches (Send, fetch and list)</span>
</li>
<li>
<span class="feature-check completed"></span>
<span class="feature-text">Issues (Send, view and list)</span>
</li>
<li>
<span class="feature-check completed"></span>
<span class="feature-text">Replies</span>
</li>
<li>
<span class="feature-check completed"></span>
<span class="feature-text">Issues and patches status</span>
</li>
<li>
<span class="feature-check pending"></span>
<span class="feature-text pending">Pull requests (<a href="https://github.com/nostr-protocol/nips/pull/1966" target="_blank" rel="noreferrer">nostr-protocol/nips#1966</a>)</span>
</li>
</ul>
</div>
<div class="feature-column">
<ul>
<li>
<span class="feature-check completed"></span>
<span class="feature-text">Gossip Model (<a href="https://github.com/nostr-protocol/nips/blob/master/65.md" target="_blank" rel="noreferrer">NIP-65</a>)</span>
</li>
<li>
<span class="feature-check completed"></span>
<span class="feature-text">Proof of Work (<a href="https://github.com/nostr-protocol/nips/blob/master/13.md" target="_blank" rel="noreferrer">NIP-13</a>)</span>
</li>
<li>
<span class="feature-check completed"></span>
<span class="feature-text">nostr: URI scheme (<a href="https://github.com/nostr-protocol/nips/blob/master/21.md" target="_blank" rel="noreferrer">NIP-21</a>)</span>
</li>
<li>
<span class="feature-check completed"></span>
<span class="feature-text">Signing using bunker (<a href="https://github.com/nostr-protocol/nips/blob/master/46.md" target="_blank" rel="noreferrer">NIP-46</a>)</span>
</li>
<li>
<span class="feature-check completed"></span>
<span class="feature-text pending">Signing using <a href="https://github.com/nostr-protocol/nips/blob/master/07.md" target="_blank" rel="noreferrer">NIP-07</a> proxy (<a href="https://crates.io/crates/nostr-browser-signer-proxy" target="_blank" rel="noreferrer">nostr-browser-signer-proxy</a>)</span>
</li>
<li>
<span class="feature-check completed"></span>
<span class="feature-text">Secret key keyring</span>
</li>
<li>
<span class="feature-check pending"></span>
<span class="feature-text pending">Code Snippets (<a href="https://github.com/nostr-protocol/nips/blob/master/C0.md" target="_blank" rel="noreferrer">NIP-C0</a>)</span>
</li>
<li>
<span class="feature-check completed"></span>
<span class="feature-text">In device relays and repos bookmark</span>
</li>
</ul>
</div>
</div>
</div>
<div class="install-section">
<h2>Quick Start</h2>
<p style="text-align: center; margin-bottom: 20px; color: #cccccc;">Get started with n34 in seconds</p>
<div class="code-block">
<p>cargo install n34</p>
<span># The execautable will be in ~/.cargo/bin/n34</span>
</div>
<p style="text-align: center; margin: 20px 0; color: #888;">or</p>
<div class="code-block">
<p>git clone https://git.4rs.nl/awiteb/n34.git</p>
<p>cd n34 && cargo build --release</p>
<span># The execautable will be in target/release/n34</span>
</div>
<p style="text-align: center; margin: 20px 0; color: #888;">NixOS (Version 0.4.0 or later)</p>
<div class="code-block">
<p>git clone https://git.4rs.nl/awiteb/n34.git</p>
<p>cd n34 && nix build</p>
<span># The execautable will be in result/bin/n34</span>
</div>
<p style="text-align: center; margin: 20px 0; color: #888;">home-manager</p>
<p style="text-align: center; margin-bottom: 20px; color: #cccccc;">Add this to your <code>flake.nix</code> inputs
<br>
Specify the version you want to install, or remove <code>?ref</code> for the unreleased version. You can also use any mirror; it doesn't have to be <code>git.4rs.nl</code>
</p>
<div class="code-block">
<pre>
inputs = {
n34.url = "git+https://git.4rs.nl/awiteb/n34.git?ref=refs/tags/vx.y.x";
};</pre>
</div>
<p style="text-align: center; margin-bottom: 20px; color: #cccccc;">And this in your home packages</p>
<div class="code-block">
<pre>packages = [ inputs.n34.packages."${pkgs.system}".default ];</pre>
</div>
<p style="text-align: center; margin-top: 20px; color: #cccccc;">Once installed, run <code style="background: #333; padding: 2px 6px; border-radius: 4px;">n34 --help</code> to see available commands.</p>
</div>
<div class="section">
<h2>Why Nostr?</h2>
<p>
Nostr is fundamentally different from traditional platforms because it's not an application or service, it's a decentralized protocol. This means any tool or app can integrate with it, enabling open, permissionless collaboration
without relying on centralized gatekeepers. Unlike proprietary systems, Nostr doesn't require emails, passwords, or accounts. You interact directly through relays, whether you self-host your own or use public ones, ensuring no
single point of failure or control.
</p>
<p>
What makes Nostr uniquely resilient is its design, the protocol itself is just a set of rules, not a company or product that can disappear. Your Git issues, patches, and comments persist as long as relays choose to store them,
immune to the whims of corporate shutdowns or policy changes. Nostr is infrastructure in its purest form, an idea that outlives any temporary implementation. n34 taps into a future-proof foundation for decentralized collaboration.
</p>
<div class="links">
<h3>More about Nostr</h3>
<ul>
<li><a href="https://nostr.com">nostr.com</a></li>
<li><a href="https://nostr.org">nostr.org</a></li>
<li><a href="https://nostr.how/en/what-is-nostr">nostr.how/en/what-is-nostr</a></li>
</ul>
</div>
</div>
<div class="footer">
<p>Built with ❤️ for the decentralized future</p>
</div>
</div>
</body>
</html>

2026-04-05 02:41:13 CEST

# Fallback Relays
> `n34 config relays` command
**Usage:**
```
Sets the default fallback relays if none provided. Use this relays for read and write
Usage: n34 config relays [OPTIONS] [RELAYS]...
Arguments:
[RELAYS]... List of relay URLs to append to fallback relays. If empty, removes all fallback relays
Options:
--override Replace existing fallback relays instead of appending new ones
```
This command configures the default fallback relays, which `n34` uses to read
from and write to. To add relays, provide their URLs as arguments to append
them to the current list. Use the `--override` flag to replace the existing list
entirely. To clear all fallback relays, run the command without any arguments.

2026-04-05 02:41:02 CEST

# Default PoW Difficulty
> `n34 config pow`
**Usage:**
```
Sets the default PoW difficulty (0 if not specified)
Usage: n34 config pow <DIFFICULTY>
Arguments:
<DIFFICULTY> The new default PoW difficulty
```
This command configures the default Proof of Work (PoW) difficulty for newly
created events. This setting is applied to most generated events, but it
intentionally skips patch events. Because patches can be numerous, calculating
PoW for each one would significantly slow down operations.
If you want to disable the PoW just make it 0.

2026-04-05 02:40:51 CEST

# NIP-07 Browser Signer Proxy
> `n34 config nip07`
**Usage:**
```
Manage the NIP-07 browser signer proxy by enabling or disabling it and configuring the `ip:port` address.
Usage: n34 config nip07 [OPTIONS] <--enable|--disable>
Options:
--enable Enable NIP-07 as the default signer
--disable Disable NIP-07 as the default signer
--addr <ADDR> Set the `ip:port` for the browser signer proxy (default: 127.0.0.1:51034)
```
Use [NIP-07] (Browser Extension Signer) as your default signer. This is achieved
by running a proxy at the specified `ADDR`, which defaults to `127.0.0.1:51034`.
The proxy forwards `n34` requests to the browser signer and relays the responses
back.
[NIP-07]: https://github.com/nostr-protocol/nips/blob/master/07.md

2026-04-05 02:40:40 CEST

# Secret Key Keyring
> `n34 config keyring` command
**Usage:**
```
Manages the secret key keyring, including enabling, disabling, or resetting it.
Usage: n34 config keyring <--enable|--disable|--reset>
Options:
--enable Enables the secret key keyring. You will be prompted for your key one last time to store it.
--disable Disables the secret key keyring. This removes the stored key and prevents new ones from being saved.
--reset Resets the keyring. This deletes the current key, allowing a new one to be stored on the next use.
```
To avoid entering your private key for every command, you can enable the keyring
to store it securely. First, run `n34 config keyring --enable`. The next time
you run an `n34` command that requires your private key, it will be saved
to your system's keyring. You will not need to enter it again for subsequent
commands.
To replace the stored key with a new one, use the `--reset` flag. To stop using
the keyring and remove the stored key, use the `--disable` flag.
`n34` uses your operating system's native secret management system. For example,
it uses `keyutils` on Linux and `Keychain` on macOS.

2026-04-05 02:40:30 CEST

# NIP-46 Bunker
> `n34 config bunker` command
**Usage:**
```
Sets a URL of NIP-46 bunker server used for signing events
Usage: n34 config bunker [BUNKER_URL]
Arguments:
[BUNKER_URL] Nostr Connect URL for the bunker. Omit this to remove the current bunker URL
```
This command configures `n34` to use a remote signer ([NIP-46]), known as a
bunker, for all cryptographic operations.
When `n34` communicates with the bunker, it uses a persistent, locally-generated
keypair. You should add this keypair's public key to your bunker's list of
authorized applications. This allows `n34` to operate securely without needing
direct access to your main private key.
Once configured, actions such as fetching your public key or signing events are
delegated to the bunker. To remove the bunker configuration, run the command
again without providing a URL.
[NIP-46]: https://github.com/nostr-protocol/nips/blob/master/46.md

2026-04-05 02:40:19 CEST

# Manage Configuration
Configuration allows you to set default values for various command parameters,
such as fallback relays, Proof of Work (PoW) difficulty, a default bunker URL,
and your Nostr private key (keyring). This avoids the need to enter your private key,
bunker URL, relays, or PoW difficulty for every command, making `n34` more
convenient to use.

2026-04-05 02:40:08 CEST

# Command-Line Usage
## Options
The `n34` command-line tool accepts the following options:
- `-s`, `--secret-key`: Your Nostr secret key (in `nsec` format), used for
signing events.
- `-b`, `--bunker-url`: The URL of a NIP-46 bunker service used for remote
signing of events.
- `-7`, `--nip07`: Enables signing events using the browser's NIP-07
extension. Listens on `127.0.0.1:51034`. You can configure the address with `n34
config nip07`
- `-r`, `--relays`: A relay to read from and write to. This option can be
specified multiple times to connect to several relays.
- `--pow`: Sets the Proof of Work difficulty required when creating events.
- `--config`: Specifies a custom path to the configuration file (Default:
`$HOME/.config/n34/config.toml`).
- `-v`, `--verbose...`: Increases the logging verbosity. Can be used multiple
times for more detail (e.g., `-v`, `-vv`).
**Note:** The `--secret-key` and `--bunker-url` options are mutually exclusive.
You must provide exactly one signing method.
## Multiple Repositories
Commands that interact with a repository, such as submitting an issue or a
patch, can accept multiple repository addresses (`naddr`). This feature is
useful for projects with multiple maintainers who each have their own repository
fork.
> **Important:** When you provide multiple repositories, `n34` does not
create a separate issue or patch for each one. Instead, it creates a single
event that references all of the specified repositories.
## The `nostr-address` File
The `nostr-address` file is a plain text file that stores a list of project
repository addresses. This allows the `n34` to find and use them
without requiring you to enter the addresses manually.
### Format
- Each line must contain a single addressable event coordinate `naddr` which is
the repository address.
- Lines beginning with a `#` are treated as comments and are ignored.
- Empty lines are also ignored.
## Passing repositories
By default, `n34` will look for a `nostr-address` file to extract repositories
from it. This is why repositories are not required for commands like `patch
send` and `issue new`. You can also pass repositories using the `--repo`
option or the `<NADDR-NIP05-OR-SET>` argument for commands that accept them. The
supported formats for manual input are:
- A [NIP-19] addressable event coordinate `naddr`.
- A [NIP-05] identifier and repository name, in the format
`<nip05>/<repo-name>`.
- A set name that contains repository addresses.
You do not need to specify relays for these commands if your `naddr` or `NIP-05`
identifier already includes relays; `n34` will automatically extract them.
[NIP-19]: https://github.com/nostr-protocol/nips/blob/master/19.md
[NIP-05]: https://github.com/nostr-protocol/nips/blob/master/05.md