Nostr notes by

{ "nodes": { "flake-utils": { "inputs": { ...

2026-04-05T05:37:44Z

{
"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
}

# Fetch a Patch By ID > `n34 patch fetch` command Usage: ...

2026-04-05T05:37:38Z

# 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 `_@4rs.nl/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.

# Modify a Set > `n34 sets update` command Usage: ``` ...

2026-04-05T05:37:31Z

# 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 `_@4rs.nl/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

# Draft an Open Patch > `n34 patch draft` command Usage: ...

2026-04-05T05:37:21Z

# 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 `_@4rs.nl/n34`), or a set name like `kernel`
```

Issue a kind `1633` (Draft status) for the specified patch. The patch have to
be open.

# Show a Set > `n34 sets show` command Usage: ``` Show a ...

2026-04-05T05:37:11Z

# 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.

# Closes an Open or Drafted Patch > `n34 patch close` command ...

2026-04-05T05:37:07Z

# 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 `_@4rs.nl/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.

# Remove a Set > `n34 sets remove` command Usage: ``` ...

2026-04-05T05:36:58Z

# 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 `_@4rs.nl/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

# Apply an Open Patch > `n34 patch apply` command Usage: ...

2026-04-05T05:36:56Z

# 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 `_@4rs.nl/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'`.

# Create a Set > `n34 sets new` command Usage: ``` Create ...

2026-04-05T05:36:46Z

# 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 `_@4rs.nl/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

# Patch Management In `n34`, patch management is designed to give ...

2026-04-05T05:36:40Z

# 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`.

# Managing Repository and Relay Sets Sets are a convenience ...

2026-04-05T05:36:34Z

# 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.

# View an Issue By ID > `n34 issue view` command Usage: ...

2026-04-05T05:36:29Z

# 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 `_@4rs.nl/n34`), or a set name like `kernel`
```

Simply provide the issue ID in `note` or `nevent` format to retrieve and display
the issue details.

# View Git Repository Details > `n34 repo view` command ...

2026-04-05T05:36:23Z

# 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 `_@4rs.nl/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

# Resolves an Issue > `n34 issue resolve` command Usage: ...

2026-04-05T05:36:17Z

# 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 `_@4rs.nl/n34`), or a set name like `kernel`
```

Issue a kind `1631` (Resolved status) event for the specified issue.

# Broadcast and Update a Git Repository > `n34 repo announce` ...

2026-04-05T05:36:12Z

# 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.

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

2026-04-05T05:24:06Z

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

2026-04-05T05:24:04Z

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

2026-04-05T05:23:55Z

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

2026-04-05T05:23:53Z

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

use std::{collections::BTreeSet, sync::Arc};

use either::Either;
use nostr::{event::Event, filter::Filter, message::MachineReadablePrefix, util::BoxedFuture};
use nostr_relay_builder::builder::{
QueryPolicy,
QueryPolicyResult,
WritePolicy,
WritePolicyResult,
};
use tonic::transport::Channel;

use self::plugins_api::{
Empty,
PluginInfo,
PluginPriority,
PluginRequest,
PluginType,
plugin_request::PluginRequestBody,
plugin_response::PluginResponseBody,
plugins_service_client::PluginsServiceClient,
};
use crate::{relay::plugins_manager::PluginsManagerTrait, relay_config::RelayConfig};

mod plugins_api {
tonic::include_proto!("plugins");
}

type GrpcResult<T> = Result<T, GrpcError>;
type PluginClient = PluginsServiceClient<Channel>;

/// gRPC errors
#[derive(Debug, thiserror::Error)]
pub enum GrpcError {
#[error("Transport: {0:?}")]
Transport(#[from] tonic::transport::Error),
#[error("Call error: {0}")]
CallErr(String),
#[error("A plugin service without any plugin {0}")]
NoPlugins(hyper::Uri),
#[error("Unknown plugin type: {0}")]
UnknownPluginType(i32),
#[error("Unknown plugin priority: {0}")]
UnknownPluginPriority(i32),
}

/// Represents a gRPC plugin.
#[derive(Debug)]
pub struct GrpcPlugin {
/// The name of the plugin.
name: String,
/// Indicates whether the plugin is for writing or querying.
is_write: bool,
/// Plugin priority, `all` or `any`
is_all: bool,
}

/// Handles gRPC plugin service.
#[derive(Debug)]
pub struct GrpcPluginService {
/// Service uri
pub uri: hyper::Uri,
/// The gRPC client used to call the `RunPlugin` RPC.
pub grpc_client: PluginClient,
/// Write plugins of type `all`
pub all_write_plugins: Vec<GrpcPlugin>,
/// Write plugins of type `any`
pub any_write_plugins: Vec<GrpcPlugin>,
/// Query plugins of type `all`
pub all_query_plugins: Vec<GrpcPlugin>,
/// Query plugins of type `any`
pub any_query_plugins: Vec<GrpcPlugin>,
}

/// Manages multiple gRPC plugin services.
///
/// This is safe to clone as it uses an internal reference counter.
#[derive(Debug, Clone)]
pub struct GrpcPluginsManager {
/// A collection of gRPC services, each of which contains multiple plugins.
pub services: Arc<Vec<GrpcPluginService>>,
}

impl GrpcPluginService {
/// Create a new service and connect to it
pub async fn new(service_uri: hyper::Uri) -> GrpcResult<Self> {
tracing::debug!(service_uri = %service_uri, "connecting to a plugins service");
let mut client = PluginClient::connect(service_uri.clone()).await?;

tracing::debug!(service_uri = %service_uri, "calling `GetPlugins` RPC");
let mut plugins = client
.get_plugins(Empty {})
.await
.map_err(|err| GrpcError::CallErr(err.to_string()))?
.into_inner()
.plugins;

// Sort and remove all duplicates
plugins.sort_unstable_by_key(|plugin| plugin.name.clone());
plugins.dedup_by_key(|plugin: &mut PluginInfo| plugin.name.clone());
tracing::debug!(service_uri = %service_uri, "received {} plugins: {plugins:?}", plugins.len());

if plugins.is_empty() {
return Err(GrpcError::NoPlugins(service_uri));
}

let mut all_write_plugins = Vec::new();
let mut any_write_plugins = Vec::new();
let mut all_query_plugins = Vec::new();
let mut any_query_plugins = Vec::new();

for plugin in plugins.into_iter().map(GrpcPlugin::try_from) {
let plugin = plugin?;
match (plugin.is_write, plugin.is_all) {
(true, true) => all_write_plugins.push(plugin),
(true, false) => any_write_plugins.push(plugin),
(false, true) => all_query_plugins.push(plugin),
(false, false) => any_query_plugins.push(plugin),
}
}

Ok(Self {
uri: service_uri,
grpc_client: client,
all_write_plugins,
any_write_plugins,
all_query_plugins,
any_query_plugins,
})
}
}

impl GrpcPluginsManager {
/// Initializes a gRPC plugins manager using the provided services.
///
/// Connects to each service to retrieve its available plugins.
pub async fn with_services(services: &[hyper::Uri]) -> GrpcResult<Self> {
let mut manager_services = Vec::new();

for service in services {
manager_services.push(GrpcPluginService::new(service.clone()).await?);
}

Ok(Self {
services: Arc::new(manager_services),
})
}

/// Gets the manager if gRPC plugins are configured, otherwise returns None.
/// Logs an error if initialization fails.
pub async fn maybe_manager(config: &RelayConfig) -> Option<Self> {
if config.plugins.grpc.is_empty() {
tracing::info!("gRPC plugins list is empty, skipping connection");
return None;
}

match GrpcPluginsManager::with_services(&config.plugins.grpc).await {
Ok(manager) => {
tracing::info!("Successfully initialized gRPC plugins manager");
Some(manager)
}
Err(err) => {
tracing::error!("Failed to initialize gRPC plugins. Error: {}", err);
None
}
}
}
}

impl GrpcPlugin {
/// Run the plugin
pub async fn run(
&self,
uri: &hyper::Uri,
client: &mut PluginClient,
body: Either<&Event, &Filter>,
) -> Result<(), String> {
let request = if self.is_write {
assert!(body.is_left());
write_plugin_request(&self.name, body.unwrap_left())
} else {
assert!(body.is_right());
query_plugin_request(&self.name, body.unwrap_right().clone())
};

match client
.run_plugin(request)
.await
.map(|r| r.into_inner().plugin_response_body)
{
Ok(Some(PluginResponseBody::Accept(..))) => Ok(()),
Ok(Some(PluginResponseBody::RejectMsg(msg))) => Err(msg),
Ok(None) => {
tracing::warn!(service_uri = %uri, plugin_name = %self.name, "plugin returns none body");
Ok(())
}
Err(err) => {
tracing::error!(service_uri = %uri, plugin_name = %self.name, "plugin returns error: {err:?}");
Ok(())
}
}
}
}

impl GrpcPluginService {
/// Executes the provided `all_plugins` and `any_plugins` with the given
/// `body`.
///
/// The `all_plugins` must all accept the `body` (either an `Event` or
/// `Filter`). If they do, the `any_plugins` are then checked. If at
/// least one `any_plugin` accepts the `body`, the function returns
/// `Ok(())`. Otherwise, it returns an `Err` with the rejection message
/// from the first `any_plugin` that rejected the `body`.
async fn run_plugins(
&self,
body: Either<&Event, &Filter>,
all_plugins: &[GrpcPlugin],
any_plugins: &[GrpcPlugin],
) -> Result<(), String> {
if all_plugins.is_empty() && any_plugins.is_empty() {
return Ok(());
}

let mut client = self.grpc_client.clone();

// All `all_plugins` must accept the `body` to proceed.
for plugin in all_plugins {
plugin.run(&self.uri, &mut client, body).await?
}

// If there are no `any_plugins`, the `body` is accepted.
if any_plugins.is_empty() {
return Ok(());
}

let mut reject_msg = None;
for plugin in any_plugins {
match plugin.run(&self.uri, &mut client, body).await {
// If any `any_plugin` accepts the `body`, return `Ok(())`.
Ok(()) => return Ok(()),
// Store the rejection message from the first `any_plugin` that rejects the `body`.
Err(msg) if reject_msg.is_none() => reject_msg = Some(msg),
_ => (),
}
}

// If no `any_plugin` accepts the `body`, return the first rejection message.
Err(reject_msg.unwrap())
}

/// Executes the write plugins for the given `event`.
///
/// Returns `Ok(())` if all `all_plugins` accept the `event` and at least
/// one `any_plugin` accepts it. Otherwise, returns `Err(reject_msg)`
/// with the rejection message.
pub async fn run_write_plugins(&self, event: &Event) -> Result<(), String> {
self.run_plugins(
Either::Left(event),
&self.all_write_plugins,
&self.any_write_plugins,
)
.await
}

/// Executes the query plugins for the given `event`.
///
/// Returns `Ok(())` if all `all_plugins` accept the `event` and at least
/// one `any_plugin` accepts it. Otherwise, returns `Err(reject_msg)`
/// with the rejection message.
pub async fn run_query_plugins(&self, query: &Filter) -> Result<(), String> {
self.run_plugins(
Either::Right(query),
&self.all_query_plugins,
&self.any_query_plugins,
)
.await
}
}

impl TryFrom<PluginInfo> for GrpcPlugin {
type Error = GrpcError;

fn try_from(plugin: PluginInfo) -> Result<Self, Self::Error> {
tracing::debug!(
plugin_name = %plugin.name,
plugin_type = %plugin.plugin_type,
plugin_priority = %plugin.priority,
"processing plugin info"
);

let is_write = PluginType::try_from(plugin.plugin_type)
.map_err(|_| GrpcError::UnknownPluginType(plugin.plugin_type))?
== PluginType::Write;

let is_all = PluginPriority::try_from(plugin.priority)
.map_err(|_| GrpcError::UnknownPluginPriority(plugin.priority))?
== PluginPriority::All;

Ok(Self {
name: plugin.name,
is_write,
is_all,
})
}
}

impl WritePolicy for GrpcPluginsManager {
fn admit_event<'a>(
&'a self,
event: &'a Event,
_: &'a std::net::SocketAddr,
) -> BoxedFuture<'a, WritePolicyResult> {
Box::pin(async {
for service in self.services.iter() {
if let Err(reject_msg) = service.run_write_plugins(event).await {
tracing::debug!(service_url = %service.uri, "event rejected: {}", event.id);
return WritePolicyResult::reject(MachineReadablePrefix::Blocked, reject_msg);
}
}

WritePolicyResult::Accept
})
}
}

impl QueryPolicy for GrpcPluginsManager {
fn admit_query<'a>(
&'a self,
query: &'a Filter,
_: &'a std::net::SocketAddr,
) -> BoxedFuture<'a, QueryPolicyResult> {
Box::pin(async move {
for service in self.services.iter() {
if let Err(reject_msg) = service.run_query_plugins(query).await {
tracing::debug!(service_url = %service.uri, "query rejected: {query:?}");
return QueryPolicyResult::reject(MachineReadablePrefix::Blocked, reject_msg);
}
}

QueryPolicyResult::Accept
})
}
}

impl PluginsManagerTrait for GrpcPluginsManager {}

/// Make a new write plugin request
fn write_plugin_request(plugin_name: &str, event: &Event) -> PluginRequest {
let tags = event
.tags
.iter()
.map(|tag| {
plugins_api::Tag {
tag_kind: tag.kind().as_str().to_owned(),
values: tag.as_slice()[1..].to_vec(),
}
})
.collect();

PluginRequest {
plugin_name: plugin_name.to_owned(),
plugin_request_body: Some(PluginRequestBody::Event(plugins_api::Event {
tags,
id: event.id.to_hex(),
public_key: event.pubkey.to_hex(),
created_at: event.created_at.as_secs(),
kind: event.kind.as_u16() as u32,
content: event.content.clone(),
signature: event.sig.to_string(),
})),
}
}

/// Make a new query plugin request
fn query_plugin_request(plugin_name: &str, filter: Filter) -> PluginRequest {
let tags = filter
.generic_tags
.iter()
.map(|(tag, values)| {
plugins_api::Tag {
tag_kind: tag.as_str().to_owned(),
values: values.clone().into_iter().collect(),
}
})
.collect();

PluginRequest {
plugin_name: plugin_name.to_owned(),
plugin_request_body: Some(PluginRequestBody::Filter(plugins_api::Filter {
tags,
ids: map_set(filter.ids, |id| id.to_hex()),
authors: map_set(filter.authors, |pkey| pkey.to_hex()),
kinds: map_set(filter.kinds, |kind| kind.as_u16() as u32),
since: filter.since.map(|t| t.as_secs()),
until: filter.until.map(|t| t.as_secs()),
limit: filter
.limit
.map(|limit| limit.try_into().unwrap_or(u64::MAX)),
})),
}
}

fn map_set<T, R>(option_set: Option<BTreeSet<T>>, map_fn: impl FnMut(T) -> R) -> Vec<R> {
option_set
.map(|set| set.into_iter().map(map_fn).collect())
.unwrap_or_default()
}

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

2026-04-05T05:23:39Z

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

use std::sync::Arc;

use nostr::{
event::{Event, EventId, Kind, Tag, TagKind, TagStandard},
filter::{Alphabet, Filter, SingleLetterTag},
message::MachineReadablePrefix,
nips::{nip01::Coordinate, nip19::ToBech32},
util::BoxedFuture,
};
use nostr_database::NostrDatabase;
use nostr_relay_builder::builder::WritePolicyResult;

use crate::{
ext_traits::WritePolicyResultExt,
git_server::utils as git_utils,
relay::plugins_manager::RelayPlugin,
utils,
};

/// Determines if a repository announcement event is valid.
pub struct ValidateRepoEvent;

/// Checks if a repository is a GRASP repository and rejects it if not.
pub struct GraspRepo {
domain: String,
}

/// Accept events that tag or tagged by accepted git repository announcement or
/// accepted issues or patches
pub struct AcceptMention {
pub db: Arc<dyn NostrDatabase>,
}

/// Rejects the repository state announcement if we don't have the repository
pub struct RejectRepoState {
pub db: Arc<dyn NostrDatabase>,
}

/// Checks if the repository state announcement is valid.
/// This ensures the `d` tag is correct, `HEAD` is present, and the `HEAD` ref
/// exists.
pub struct ValidateRepoState;

impl GraspRepo {
/// Constructs a new [GraspRepo] plugin
#[inline]
pub fn new(relay_domain: impl Into<String>) -> Self {
GraspRepo {
domain: relay_domain.into(),
}
}
}

impl AcceptMention {
#[inline]
/// Constructs a new [AcceptMention] plugin
pub fn new(db: Arc<dyn NostrDatabase>) -> Self {
Self { db }
}

/// Checks if any event matching the given filter in the database.
async fn db_contains(&self, filter: Filter) -> bool {
match self.db.count(filter.clone()).await {
Ok(count) => count != 0,
Err(err) => {
tracing::error!(error = %err, filter = ?filter, "Failed to query the database");
false
}
}
}
}

impl RejectRepoState {
#[inline]
/// Constructs a new [RejectRepoState] plugin
pub fn new(db: Arc<dyn NostrDatabase>) -> Self {
Self { db }
}
}

impl RelayPlugin for ValidateRepoEvent {
fn check_event<'a>(&'a self, event: &'a Event) -> BoxedFuture<'a, Option<WritePolicyResult>> {
Box::pin(async {
if event.kind != Kind::GitRepoAnnouncement {
return None;
}

// At least one relay
if event
.tags
.find(TagKind::Relays)
.is_none_or(|relays| relays.content().is_none())
{
return Some(WritePolicyResult::blocked_reject(
"No relays in the repository announcement",
));
}

// At least one clone url
if event
.tags
.find(TagKind::Clone)
.is_none_or(|clones| clones.content().is_none())
{
return Some(WritePolicyResult::blocked_reject(
"No clone urls in the repository announcement",
));
}

if event.tags.filter(TagKind::d()).count() > 1 {
return Some(WritePolicyResult::blocked_reject(
"More than one `d` tag in the repository announcement",
));
}

let Some(repo_name) = event.tags.identifier() else {
return Some(WritePolicyResult::blocked_reject(
"The repository announcement must contains `d` tag",
));
};

if repo_name.chars().count() > 30 {
return Some(WritePolicyResult::blocked_reject(
"Repository name exceeds maximum length of 30 characters",
));
}

// Check if it's a valid name. All ascii and no whitespace
if repo_name
.chars()
.any(|c| !c.is_ascii_alphanumeric() && c != '-' && c != '_')
{
return Some(WritePolicyResult::blocked_reject(format!(
"Invalid repository name '{repo_name}'. Repository names can only contain \
ASCII letters, numbers, hyphens (-), and underscores (_)."
)));
}

Some(WritePolicyResult::Accept)
})
}
}

impl RelayPlugin for GraspRepo {
fn check_event<'a>(&'a self, event: &'a Event) -> BoxedFuture<'a, Option<WritePolicyResult>> {
Box::pin(async {
if event.kind != Kind::GitRepoAnnouncement {
return None;
}

let repo_name = event
.tags
.identifier()
.expect("Verified in ValidateRepoEvent");

let relays = event
.tags
.find(TagKind::Relays)
.map(|t| &t.as_slice()[1..])
.expect("Verified in ValidateRepoEvent");

let clones = event
.tags
.find(TagKind::Clone)
.map(|t| &t.as_slice()[1..])
.expect("Verified in ValidateRepoEvent");

let repo_clone_url = format!(
"{}/{}/{repo_name}.git",
self.domain,
event.pubkey.to_bech32().expect("Infallible")
);

if !relays
.iter()
.any(|relay| utils::remove_proto(relay).starts_with(&self.domain))
{
return Some(WritePolicyResult::blocked_reject(format!(
"`{}` relay is not listed in the 'relays' tag of the announcement",
self.domain
)));
}

if !clones
.iter()
.any(|clone_url| utils::remove_proto(clone_url) == repo_clone_url)
{
return Some(WritePolicyResult::blocked_reject(format!(
"`{}` relay does not match any URLs in the 'clone' tag of the announcement",
self.domain
)));
}

Some(WritePolicyResult::Accept)
})
}
}

impl RelayPlugin for AcceptMention {
fn check_event<'a>(&'a self, event: &'a Event) -> BoxedFuture<'a, Option<WritePolicyResult>> {
Box::pin(async {
// from GRASP protocol:
// "MUST accept other events that tag, or are tagged by, either:
// 1. accepted git repository announcements; or
// 2. accepted issues or patches"

// Check if the event tag a repository announcement
if self
.db_contains(Filter::new().coordinates(repos_coordinate(event)))
.await
{
return Some(WritePolicyResult::Accept);
}

// Check if the event tag a patch or an issue
if self
.db_contains(
Filter::new()
.kinds([Kind::GitPatch, Kind::GitIssue])
.ids(tagged_events(event)),
)
.await
{
return Some(WritePolicyResult::Accept);
}

// Check if the event is tagged by a patch or an issue. By either `e` tag or `q`
// tag
if self
.db_contains(
Filter::new()
.kinds([Kind::GitPatch, Kind::GitIssue])
.event(event.id),
)
.await
|| self
.db_contains(
Filter::new()
.kinds([Kind::GitPatch, Kind::GitIssue])
.custom_tag(SingleLetterTag::lowercase(Alphabet::Q), event.id),
)
.await
{
return Some(WritePolicyResult::Accept);
}

None
})
}
}

impl RelayPlugin for ValidateRepoState {
fn check_event<'a>(&'a self, event: &'a Event) -> BoxedFuture<'a, Option<WritePolicyResult>> {
Box::pin(async {
if event.kind != Kind::RepoState {
return None;
}

if event.tags.filter(TagKind::d()).count() > 1 {
return Some(WritePolicyResult::blocked_reject(
"Invalid repository state announcement. More than one `d` tag",
));
}

let Some(repo_name) = event.tags.identifier() else {
return Some(WritePolicyResult::blocked_reject(
"Invalid repository state announcement. No `d` tag",
));
};

if repo_name.chars().count() > 30 {
return Some(WritePolicyResult::blocked_reject(
"Repository name exceeds maximum length of 30 characters",
));
}

let Some(mut head) = event.tags.find(TagKind::Head).and_then(Tag::content) else {
return Some(WritePolicyResult::blocked_reject(
"No `HEAD` tag in the repository state announcement",
));
};

if !head.starts_with("ref: refs/heads/") {
return Some(WritePolicyResult::blocked_reject(
"The `HEAD` tag must start with `ref: refs/heads/`",
));
}

for (ref_name, commit) in git_utils::extract_refs(event) {
if !utils::is_valid_sha1(commit) {
return Some(WritePolicyResult::blocked_reject(format!(
"`{ref_name}` has an invalid sha1 commit id"
)));
}
}

head = head.trim_start_matches("ref: ").trim();
if !git_utils::extract_refs(event).any(|(ref_name, _)| ref_name == head) {
return Some(WritePolicyResult::blocked_reject(format!(
"No ref for the head `{head}`"
)));
}

Some(WritePolicyResult::Accept)
})
}
}

impl RelayPlugin for RejectRepoState {
fn check_event<'a>(&'a self, event: &'a Event) -> BoxedFuture<'a, Option<WritePolicyResult>> {
Box::pin(async {
if event.kind != Kind::RepoState {
return None;
}

let repo_name = event
.tags
.identifier()
.expect("Verified in ValidateRepoState");

// Get the repositories with the same identifier
let events = match self
.db
.query(
Filter::new()
.kind(Kind::GitRepoAnnouncement)
.identifier(repo_name)
.limit(100),
)
.await
{
Ok(events) => events,
Err(err) => {
tracing::error!("Database error: {err}");
return Some(WritePolicyResult::reject(
MachineReadablePrefix::Error,
"Database error",
));
}
};

// Accept the state announcement if the repository state author is an author or
// a maintainer in any of the repositories
if events.iter().any(|repo_announcement| {
repo_announcement.pubkey == event.pubkey
|| utils::get_maintainers(repo_announcement)
.any(|maintainer| maintainer == &event.pubkey)
}) {
Some(WritePolicyResult::Accept)
} else {
Some(WritePolicyResult::blocked_reject(
"You don't have a repository for this state announcement in the relay.",
))
}
})
}
}

/// Extracts up to 20 repository coordinates from an event's tags.
/// Only includes coordinates marked as Git repository announcements.
fn repos_coordinate(event: &Event) -> impl Iterator<Item = &Coordinate> {
event
.tags
.as_slice()
.iter()
.filter_map(|t| {
if let TagStandard::Coordinate { coordinate, .. } = t.as_standardized()?
&& coordinate.kind == Kind::GitRepoAnnouncement
{
return Some(coordinate);
}
None
})
.take(20)
}

/// Extract up to 20 tagged events from an event's tags.
fn tagged_events(event: &Event) -> impl Iterator<Item = EventId> {
event
.tags
.as_slice()
.iter()
.filter_map(|t| {
if let TagStandard::Event { event_id, .. } = t.as_standardized()? {
return Some(*event_id);
}
None
})
.take(20)
}

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

2026-04-05T05:23:39Z

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

2026-04-05T05:23:28Z

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

2026-04-05T05:23:28Z

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

2026-04-05T05:23:17Z

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

2026-04-05T05:23:17Z

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

2026-04-05T05:23:03Z

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

2026-04-05T05:23:03Z

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

2026-04-05T05:22:53Z

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

2026-04-05T05:22:52Z

// Copyright 2025 Thomas Profelt // // Permission is hereby ...

2026-04-05T05:22:42Z

// Copyright 2025 Thomas Profelt
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the “Software”), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.

// This implementation is derived from the original work authored by Thomas
// Profelt in the `axum-raw-websocket` library.
//
// Source: https://github.com/tompro/axum-raw-websocket/blob/master/src/lib.rs
// Licensed under the MIT License.
//
// Note: Only this specific file is licensed under MIT. The remainder of the
// project is licensed under AGPLv3.

use std::future::Future;

use axum::body::Body;
use axum::extract::FromRequestParts;
use axum::extract::ws::rejection::InvalidProtocolPseudoheader;
use axum::extract::ws::rejection::{
ConnectionNotUpgradable,
InvalidConnectionHeader,
InvalidUpgradeHeader,
InvalidWebSocketVersionHeader,
MethodNotConnect,
MethodNotGet,
WebSocketKeyHeaderMissing,
WebSocketUpgradeRejection,
};
use axum::http::{
Method,
StatusCode,
Version,
header::{self, HeaderMap, HeaderName, HeaderValue},
request::Parts,
};
use axum::{Error, body::Bytes, response::Response};
use hyper::upgrade::Upgraded;
use hyper_util::rt::TokioIo;
use sha1::{Digest, Sha1};

/// This websocket upgrade is based on the axum integrated one
/// [WebSocketUpgrade](axum::extract::ws::WebSocketUpgrade).
///
/// The main difference is that it will onvoke the on_upgrade callback with the
/// raw socket which allow the socket to be used by other libraries than the
/// default tokio-tungstenite.
///
/// For HTTP/1.1 requests, this extractor requires the request method to be
/// `GET`; in later versions, `CONNECT` is used instead.
/// To support both, it should be used with [`any`](axum::routing::any).
///
/// See the [module docs](axum::extract::ws) for an example.
///
/// [`MethodFilter`]: axum::routing::MethodFilter
#[cfg_attr(docsrs, doc(cfg(feature = "ws")))]
pub struct RawSocketUpgrade<F = DefaultOnFailedUpgrade> {
/// `None` if HTTP/2+ WebSockets are used.
sec_websocket_key: Option<HeaderValue>,
on_upgrade: hyper::upgrade::OnUpgrade,
on_failed_upgrade: F,
sec_websocket_protocol: Option<HeaderValue>,
}

impl<F> std::fmt::Debug for RawSocketUpgrade<F> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("RelayUpgrade")
.field("sec_websocket_key", &self.sec_websocket_key)
.field("sec_websocket_protocol", &self.sec_websocket_protocol)
.finish_non_exhaustive()
}
}

impl<F> RawSocketUpgrade<F> {
#[allow(dead_code)]
pub fn on_failed_upgrade<C>(self, callback: C) -> RawSocketUpgrade<C>
where
C: OnFailedUpgrade,
{
RawSocketUpgrade {
sec_websocket_key: self.sec_websocket_key,
on_upgrade: self.on_upgrade,
on_failed_upgrade: callback,
sec_websocket_protocol: self.sec_websocket_protocol,
}
}

/// Finalize upgrading the connection and call the provided callback with
/// the stream.
#[must_use = "to set up the WebSocket connection, this response must be returned"]
pub fn on_upgrade<C, Fut>(self, callback: C) -> Response
where
C: FnOnce(TokioIo<Upgraded>) -> Fut + Send + 'static,
Fut: Future<Output = ()> + Send + 'static,
F: OnFailedUpgrade,
{
let on_upgrade = self.on_upgrade;
let on_failed_upgrade = self.on_failed_upgrade;

tokio::spawn(async move {
let upgraded = match on_upgrade.await {
Ok(upgraded) => upgraded,
Err(err) => {
on_failed_upgrade.call(Error::new(err));
return;
}
};
let upgraded: TokioIo<Upgraded> = TokioIo::new(upgraded);
callback(upgraded).await;
});

if let Some(sec_websocket_key) = &self.sec_websocket_key {
// If `sec_websocket_key` was `Some`, we are using HTTP/1.1.

#[allow(clippy::declare_interior_mutable_const)]
const UPGRADE: HeaderValue = HeaderValue::from_static("upgrade");
#[allow(clippy::declare_interior_mutable_const)]
const WEBSOCKET: HeaderValue = HeaderValue::from_static("websocket");

Response::builder()
.status(StatusCode::SWITCHING_PROTOCOLS)
.header(header::CONNECTION, UPGRADE)
.header(header::UPGRADE, WEBSOCKET)
.header(
header::SEC_WEBSOCKET_ACCEPT,
sign(sec_websocket_key.as_bytes()),
)
.body(Body::empty())
.unwrap()
} else {
Response::new(Body::empty())
}
}
}

/// What to do when a connection upgrade fails.
///
/// See [`RawSocketUpgrade::on_failed_upgrade`] for more details.
pub trait OnFailedUpgrade: Send + 'static {
/// Call the callback.
fn call(self, error: Error);
}

impl<F> OnFailedUpgrade for F
where
F: FnOnce(Error) + Send + 'static,
{
fn call(self, error: Error) {
self(error)
}
}

/// The default `OnFailedUpgrade` used by `RawSocketUpgrade`.
///
/// It simply ignores the error.
#[non_exhaustive]
#[derive(Debug)]
pub struct DefaultOnFailedUpgrade;

impl OnFailedUpgrade for DefaultOnFailedUpgrade {
#[inline]
fn call(self, _error: Error) {}
}

impl<S> FromRequestParts<S> for RawSocketUpgrade<DefaultOnFailedUpgrade>
where
S: Send + Sync,
{
type Rejection = WebSocketUpgradeRejection;

async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
let sec_websocket_key = if parts.version <= Version::HTTP_11 {
if parts.method != Method::GET {
return Err(WebSocketUpgradeRejection::MethodNotGet(
MethodNotGet::default(),
));
}

if !header_contains(&parts.headers, header::CONNECTION, "upgrade") {
return Err(WebSocketUpgradeRejection::InvalidConnectionHeader(
InvalidConnectionHeader::default(),
));
}

if !header_eq(&parts.headers, header::UPGRADE, "websocket") {
return Err(WebSocketUpgradeRejection::InvalidUpgradeHeader(
InvalidUpgradeHeader::default(),
));
}

Some(
parts
.headers
.get(header::SEC_WEBSOCKET_KEY)
.ok_or(WebSocketUpgradeRejection::WebSocketKeyHeaderMissing(
WebSocketKeyHeaderMissing::default(),
))?
.clone(),
)
} else {
if parts.method != Method::CONNECT {
return Err(WebSocketUpgradeRejection::MethodNotConnect(
MethodNotConnect::default(),
));
}

if parts
.extensions
.get::<hyper::ext::Protocol>()
.is_none_or(|p| p.as_str() != "websocket")
{
return Err(WebSocketUpgradeRejection::InvalidProtocolPseudoheader(
InvalidProtocolPseudoheader::default(),
));
}

None
};

if !header_eq(&parts.headers, header::SEC_WEBSOCKET_VERSION, "13") {
return Err(WebSocketUpgradeRejection::InvalidWebSocketVersionHeader(
InvalidWebSocketVersionHeader::default(),
));
}

let on_upgrade = parts
.extensions
.remove::<hyper::upgrade::OnUpgrade>()
.ok_or(WebSocketUpgradeRejection::ConnectionNotUpgradable(
ConnectionNotUpgradable::default(),
))?;

let sec_websocket_protocol = parts.headers.get(header::SEC_WEBSOCKET_PROTOCOL).cloned();

Ok(Self {
sec_websocket_key,
on_upgrade,
sec_websocket_protocol,
on_failed_upgrade: DefaultOnFailedUpgrade,
})
}
}

fn header_eq(headers: &HeaderMap, key: HeaderName, value: &'static str) -> bool {
if let Some(header) = headers.get(&key) {
header.as_bytes().eq_ignore_ascii_case(value.as_bytes())
} else {
false
}
}

fn header_contains(headers: &HeaderMap, key: HeaderName, value: &'static str) -> bool {
let header = if let Some(header) = headers.get(&key) {
header
} else {
return false;
};

if let Ok(header) = std::str::from_utf8(header.as_bytes()) {
header.to_ascii_lowercase().contains(value)
} else {
false
}
}

fn sign(key: &[u8]) -> HeaderValue {
use base64::engine::Engine as _;

let mut sha1 = Sha1::default();
sha1.update(key);
sha1.update(b"258EAFA5-E914-47DA-95CA-C5AB0DC85B11");
let b64 = Bytes::from(base64::engine::general_purpose::STANDARD.encode(sha1.finalize()));
HeaderValue::from_maybe_shared(b64).expect("base64 is a valid value")
}

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

2026-04-05T05:22:38Z

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

2026-04-05T05:22:31Z

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

2026-04-05T05:22:27Z

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

2026-04-05T05:22:20Z

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

2026-04-05T05:22:16Z

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

2026-04-05T05:22:08Z

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

2026-04-05T05:22:04Z

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

2026-04-05T05:21:57Z

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

2026-04-05T05:21:53Z

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

2026-04-05T05:21:46Z

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

2026-04-05T05:21:42Z

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

2026-04-05T05:21:34Z

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

2026-04-05T05:21:22Z

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

2026-04-05T05:21:22Z

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

2026-04-05T05:21:11Z

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

2026-04-05T05:21:11Z

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

2026-04-05T05:21:00Z

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

2026-04-05T05:21:00Z

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

2026-04-05T05:20:50Z

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

2026-04-05T05:20:48Z

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

2026-04-05T05:20:38Z

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

2026-04-05T05:20:35Z

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

2026-04-05T05:20:27Z

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

2026-04-05T05:20:24Z

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

2026-04-05T05:20:15Z

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

2026-04-05T05:20:13Z

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

2026-04-05T05:20:01Z

#!/usr/bin/env sh N34_RELAY_BASE_DIR=./bin RUST_LOG=debug cargo ...

2026-04-05T05:17:36Z

#!/usr/bin/env sh
N34_RELAY_BASE_DIR=./bin RUST_LOG=debug cargo run -p n34-relay

<svg width="38" height="38" viewBox="0 0 ...

2026-04-05T05:17:25Z

unstable_features = true style_edition = "2024" ...

2026-04-05T05:17:25Z

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

// This protobuf contract defines the interface for managing and ...

2026-04-05T05:17:14Z

// This protobuf contract defines the interface for managing and interacting
// with plugins in a server.
//
// Plugins can be of two types: `WRITE` (for processing events) or `QUERY` (for
// processing filters). Each plugin has a priority level (`ALL` or `ANY`) that
// determines its execution behavior:
// - `ALL`: The plugin must process the event/query.
// - `ANY`: The plugin can skip processing if another plugin accepts the
// event/query.

syntax = "proto3";
package plugins;

// Empty rpc request.
message Empty {}

// Represents the type of plugin, either for writing or querying.
enum PluginType {
WRITE = 0;
QUERY = 1;
}

// Defines the priority level for plugin event/query handling.
//
// `ALL` ensures the plugin must process the event/query.
// `ANY` allows the plugin to skip processing if another plugin accepts the
// event.
enum PluginPriority {
// It must accept the event
ALL = 0;
// Plugins with this priority can skip processing if another plugin accepts
// the event. Commonly used for whitelisting purposes.
ANY = 1;
}

// Information about a plugin.
message PluginInfo {
// Unique name used to identify and call the plugin.
string name = 1;
// Type of plugin indicating when it should be executed.
PluginType plugin_type = 2;
// Priority level determining plugin execution order.
PluginPriority priority = 3;
}

// Event tag `["p", "<pubkey>", "<relay-url>"]`
message Tag {
// Tag kind. e.g. "p"
string tag_kind = 1;
// Tag values. e.g. `["<pubkey>", "<relay-url>"]`
repeated string values = 2;
}

// Query filter
message Filter {
repeated string ids = 1;
repeated string authors = 2;
repeated uint32 kinds = 3;
repeated Tag tags = 4;
optional uint64 since = 5;
optional uint64 until = 6;
optional uint64 limit = 7;
}

// Nostr event
message Event {
// Event id
string id = 1;
// Author's public key. In hex
string public_key = 2;
// Event created at
uint64 created_at = 3;
// Event kind
uint32 kind = 4;
// Event tags
repeated Tag tags = 5;
// Event content
string content = 6;
// Event signature
string signature = 7;
}

// Represents the plugins available on the server.
message ServicePlugins { repeated PluginInfo plugins = 1; }

// Represents a request to a plugin, where the plugin type determines the
// content. Query plugins receive a filter, while write plugins receive an event.
message PluginRequest {
// The plugin that should be run.
string plugin_name = 1;
// The plugin request, which must contain either a filter for query plugins or
// an event for write plugins.
oneof plugin_request_body {
// A filter request sent to query-type plugins.
Filter filter = 2;
// An event request sent to write-type plugins.
Event event = 3;
}
}

// Represents a response from a plugin, indicating whether an event or query is
// accepted or rejected.
//
// If the plugin accepts the event or query, `accept` is used without additional data.
// If the plugin rejects it, `reject_msg` contains the reason for the rejection.
message PluginResponse {
// Indicates whether the event or query is accepted or rejected.
oneof plugin_response_body {
// Indicates that the event or query is accepted.
Empty accept = 1;
// Provides the reason for rejecting the event or query.
string reject_msg = 2;
}
}

service PluginsService {
// Returns the service plugins
rpc GetPlugins(Empty) returns (ServicePlugins);
// Run a plugin
rpc RunPlugin(PluginRequest) returns (PluginResponse);
}

# Grasp - Git Relays Authorized via Signed-Nostr Proofs Status: ...

2026-04-05T05:17:14Z

# Grasp - Git Relays Authorized via Signed-Nostr Proofs

Status: DRAFT - expect breaking changes

Contributions to open-source projects shouldn't be permissioned by a platform like GitHub. Git repoistory hosting should be distributed. Grasp is a protocol like blossom, but for git.

## Overview

There may be many grasp servers anywhere -- like Blossom servers -- that host repositories from anyone (maybe they'll ask for a pre-payment, maybe they will have a free quota for some Nostr users and so on) that you can just push your repositories to. And your pushes are pre-authorized by publishing a Nostr event beforehand that says what is your repository state (branch=commit, HEAD=branch or something like that).

Then when announcing your repository you can include multiple git+http URLs to these servers that people can clone the project from. And Git-enabled Nostr clients can contact these servers to download and display source code and Git history data.

## Specification

GRASP-01 is required. Everything else is optional.

* GRASP-01 - Core Service Requirements
* GRASP-02 - Proactive Sync
* GRASP-05 - Archive

Reference implementation - [ngit-relay](https://gitworkshop.dev/npub15qydau2hjma6ngxkl2cyar74wzyjshvl65za5k5rl69264ar2exs5cyejr/ngit-relay)

TODO:
- Service Announcements and Discovery

<svg width="38" height="38" viewBox="0 0 ...

2026-04-05T05:17:01Z

MIT License Copyright (c) 2025 DanConwayDev Permission is hereby ...

2026-04-05T05:17:01Z

MIT License

Copyright (c) 2025 DanConwayDev

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

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

2026-04-05T05:04:25Z

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

use clap::{ArgGroup, Args};

use crate::{
cli::{Cli, CliOptions, traits::CommandRunner},
error::N34Result,
};

#[derive(Args, Debug)]
#[clap(
group(
ArgGroup::new("options")
.required(true)
)
)]
pub struct KeyringArgs {
/// Turns on secret key keyring. Requires entering the key once when
/// enabled.
#[arg(long, group = "options")]
enable: bool,
/// Turns off secret key keyring. Removes any existing key and prevents
/// storing new ones.
#[arg(long, group = "options")]
disable: bool,
/// Deletes current key and stores the next provided key.
#[arg(long, group = "options")]
reset: bool,
}

impl CommandRunner for KeyringArgs {
const NEED_SIGNER: bool = false;

async fn run(self, mut options: CliOptions) -> N34Result<()> {
let keyring = nostr_keyring::NostrKeyring::new(Cli::N34_KEYRING_SERVICE_NAME);

if self.enable {
options.config.keyring_secret_key = true;
} else if self.disable {
options.config.keyring_secret_key = false;
}

if self.reset || self.disable {
let _ = keyring.delete(Cli::USER_KEY_PAIR_ENTRY);
}

options.config.dump()
}
}

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

2026-04-05T05:04:03Z

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

# `build.rs` Documentation This document explains the ...

2026-04-05T05:03:58Z

# `build.rs` Documentation

This document explains the functionality of the `build.rs` script in this project. The `build.rs` script is a special Rust file that, if present, Cargo will compile and run *before* compiling the rest of your package. It's typically used for tasks that need to be performed during the build process, such as generating code, setting environment variables, or performing conditional compilation.

## Core Functionality

The `build.rs` script in this project performs the following key functions:

1. **Environment Variable Injection:** It computes various project-related values at compile time and injects them as environment variables (`CARGO_RUSTC_ENV=...`) that can be accessed by the main crate using `env!("VAR_NAME")`. This includes:
* `CARGO_PKG_NAME`: The name of the current package (from `Cargo.toml`).
* `CARGO_PKG_VERSION`: The version of the current package (from `Cargo.toml`).
* `GIT_COMMIT_HASH`: The full commit hash of the current Git HEAD (if in a Git repository).
* `GIT_BRANCH`: The name of the current Git branch (if in a Git repository).
* `CARGO_TOML_HASH`: The SHA-256 hash of the `Cargo.toml` file.
* `LIB_HASH`: The SHA-256 hash of the `src/lib.rs` file.
* `BUILD_HASH`: The SHA-256 hash of the `build.rs` file itself.

2. **Rerun Conditions:** It tells Cargo when to re-run the build script. This ensures that the injected environment variables and any conditional compilation logic are up-to-date if relevant files change:
* `Cargo.toml`
* `src/lib.rs`
* `build.rs`
* `.git/HEAD` (to detect changes in the Git repository like new commits or branch switches).
* `src/get_file_hash_core/src/online_relays_gps.csv` (conditionally, if the file exists).

3. **Conditional Nostr Event Publishing (Release Builds with `nostr` feature):**
If the project is being compiled in **release mode (`--release`)** and the **`nostr` feature is enabled (`--features nostr`)**, the `build.rs` script will connect to Nostr relays and publish events. This is intended for "deterministic Nostr event build examples" as indicated by the comments in the file.

* **Relay Management:** It retrieves a list of default relay URLs. During event publishing, it identifies and removes "unfriendly" or unresponsive relays (e.g., those with timeout, connection issues, or spam blocks) from the list for subsequent publications.
* **File Hashing and Key Generation:** For each Git-tracked file (when in a Git repository), it computes its SHA-256 hash. This hash is then used to derive a Nostr `SecretKey`.
* **Event Creation:**
* **Individual File Events:** For each Git-tracked file, a Nostr `text_note` event is created. This event includes tags for:
* `#file`: The path of the file.
* `#version`: The package version.
* `#commit`: The Git commit hash (if in a Git repository).
* `#branch`: The Git branch name (if in a Git repository).
* **Metadata Event:** It publishes a metadata event using `get_file_hash_core::publish_metadata_event`.
* **Linking Event (Build Manifest):** After processing all individual files, if any events were published, a final "build manifest" `text_note` event is created. This event links to all the individual file events that were published during the build using event tags.
* **Output Storage:** The JSON representation of successfully published Nostr events (specifically the `EventId`) is saved to `~/.gnostr/build/{package_version}/{file_path_str_sanitized}/{hash}/{public_key}/{event_id}.json`. This provides a local record of what was published.

### `publish_nostr_event_if_release` Function

This asynchronous helper function is responsible for:
* Adding relays to the Nostr client.
* Connecting to relays.
* Signing the provided `EventBuilder` to create an `Event`.
* Sending the event to the configured relays.
* Logging success or failure for each relay.
* Identifying and removing unresponsive relays from the `relay_urls` list.
* Saving the published event's JSON to the local filesystem.

### `should_remove_relay` Function

This helper function determines if a relay should be considered "unfriendly" or unresponsive based on common error messages received during Nostr event publication.

## Usage

To prevent 'Too many open files' errors, especially during builds and tests involving numerous file operations or subprocesses (like `git ls-files` or parallel test execution), it may be necessary to increase the file descriptor limit.

* **For local development**: Run `ulimit -n 4096` in your terminal session before executing `cargo build` or `cargo test`. This setting is session-specific.
* **For CI environments**: The `.github/workflows/rust.yml` workflow is configured to set `ulimit -n 4096` for relevant test steps to ensure consistent execution.

The values set by `build.rs` can be accessed in your Rust code (e.g., `src/lib.rs`) at compile time using the `env!` macro. For example:
```rust
pub const CARGO_PKG_VERSION: &str = env!("CARGO_PKG_VERSION");
```

The Nostr event publishing functionality of `build.rs` is primarily for release builds with the `nostr` feature enabled, allowing for the automatic, deterministic publication of project state to the Nostr network as part of the CI/CD pipeline.

## Example Commands

To interact with the `build.rs` script's features, especially those related to Nostr event publishing, you can use the following `cargo` commands:

* **Build in release mode with Nostr feature (verbose output):**
```bash
cargo build --release --workspace --features nostr -vv
```

* **Run tests for `get_file_hash_core` sequentially with Nostr feature and verbose logging (as in CI):**
```bash
RUST_LOG=info,nostr_sdk=debug,frost=debug cargo test -p get_file_hash_core --features nostr -- --test-threads 1 --nocapture
```

* **Run all workspace tests in release mode with Nostr feature:**
```bash
cargo test --workspace --release --features nostr
```

* **Build `get_file_hash_core` in release mode with Nostr feature (very verbose output):**
```bash
cargo build --release --features nostr -vv -p get_file_hash_core
```

* **Run `get_file_hash_core` tests in release mode with Nostr feature (very verbose output):**
```bash
cargo test --release --features nostr -vv -p get_file_hash_core
```

Nostr event nevent1qqsd5attuq7eaae70mgp8w8p55pnng0wmnpfu9dyfhezenjl4el4xwgzyptmj32nj8lt658t74lretj59vennwa847lj5yjgfwvdmesyy8dsvc3gkxw

2026-04-05T05:03:44Z

plan-dist-manifest.json

# This file contains NIP-19 `naddr` entities for repositories ...

2026-04-05T05:03:41Z

# 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

name: Rust on: push: branches: [ "*" ] pull_request: ...

2026-04-05T05:03:30Z

name: Rust

on:
push:
branches: [ "*" ]
pull_request:
branches: [ "*" ]

env:
CARGO_TERM_COLOR: always
FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: true
RUST_LOG: info

jobs:
build:

runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [ubuntu-latest, macos-15-intel, macos-latest, windows-latest]
features_args: ["", "--no-default-features", "--features nostr"]

steps:
- uses: actions/checkout@v4
- name: Install system deps (dbus)
if: runner.os == 'Linux'
shell: bash
run: |
sudo apt-get update
sudo apt-get install -y pkg-config libdbus-1-dev
- name: Install protobuf (protoc)
shell: bash
run: |
set -euxo pipefail
if [[ "${{ runner.os }}" == "macOS" ]]; then
brew update
brew install protobuf
elif [[ "${{ runner.os }}" == "Linux" ]]; then
sudo apt-get update
sudo apt-get install -y protobuf-compiler
elif [[ "${{ runner.os }}" == "Windows" ]]; then
choco install -y protoc
fi
- name: Build ${{ matrix.features_args }}
run: cargo build --workspace --verbose ${{ matrix.features_args }}
- name: Run workspace tests ${{ matrix.features_args }}
run: |
cargo test --workspace ${{ matrix.features_args }} -- --test-threads 1
- name: Run get_file_hash_core tests ${{ matrix.features_args }}
shell: bash
run: |
if [[ "${{ matrix.features_args }}" == "--features nostr" ]]; then
cargo test -p get_file_hash_core ${{ matrix.features_args }} -- --test-threads 1 --nocapture
else
cargo test -p get_file_hash_core ${{ matrix.features_args }} -- --test-threads 1
fi
- name: Run get_file_hash tests ${{ matrix.features_args }}
shell: bash
run: |
if [[ "${{ matrix.features_args }}" == "--features nostr" ]]; then
cargo test -p get_file_hash ${{ matrix.features_args }} -- --test-threads 1 --nocapture
else
cargo test -p get_file_hash ${{ matrix.features_args }} -- --test-threads 1
fi
- name: Build Release ${{ matrix.features_args }}
run: cargo build --workspace --release ${{ matrix.features_args }}

{ inputs = { nixpkgs.url = ...

2026-04-05T05:03:16Z

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

# This file was autogenerated by dist: ...

2026-04-05T05:03:09Z

# This file was autogenerated by dist: https://axodotdev.github.io/cargo-dist
#
# Copyright 2022-2024, axodotdev
# SPDX-License-Identifier: MIT or Apache-2.0
#
# CI that:
#
# * checks for a Git Tag that looks like a release
# * builds artifacts with dist (archives, installers, hashes)
# * uploads those artifacts to temporary workflow zip
# * on success, uploads the artifacts to a GitHub Release
#
# Note that the GitHub Release will be created with a generated
# title/body based on your changelogs.

name: Release
permissions:
"contents": "write"

# This task will run whenever you push a git tag that looks like a version
# like "1.0.0", "v0.1.0-prerelease.1", "my-app/0.1.0", "releases/v1.0.0", etc.
# Various formats will be parsed into a VERSION and an optional PACKAGE_NAME, where
# PACKAGE_NAME must be the name of a Cargo package in your workspace, and VERSION
# must be a Cargo-style SemVer Version (must have at least major.minor.patch).
#
# If PACKAGE_NAME is specified, then the announcement will be for that
# package (erroring out if it doesn't have the given version or isn't dist-able).
#
# If PACKAGE_NAME isn't specified, then the announcement will be for all
# (dist-able) packages in the workspace with that version (this mode is
# intended for workspaces with only one dist-able package, or with all dist-able
# packages versioned/released in lockstep).
#
# If you push multiple tags at once, separate instances of this workflow will
# spin up, creating an independent announcement for each one. However, GitHub
# will hard limit this to 3 tags per commit, as it will assume more tags is a
# mistake.
#
# If there's a prerelease-style suffix to the version, then the release(s)
# will be marked as a prerelease.
on:
pull_request:
push:
tags:
- '**[0-9]+.[0-9]+.[0-9]+*'

jobs:
# Run 'dist plan' (or host) to determine what tasks we need to do
install-deps:
runs-on: "ubuntu-latest"
outputs:
val: ${{ steps.plan.outputs.manifest }}
tag: ${{ !github.event.pull_request && github.ref_name || '' }}
tag-flag: ${{ !github.event.pull_request && format('--tag={0}', github.ref_name) || '' }}
publishing: ${{ !github.event.pull_request }}
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
steps:
- uses: actions/checkout@v4
with:
persist-credentials: false
submodules: recursive

- name: Install-deps
shell: bash
run: |
if [[ "${{ runner.os }}" == "Linux" ]]; then
sudo apt-get update
sudo apt-get install -y pkg-config libdbus-1-dev curl unzip

# Install a pinned modern protoc
PROTOC_ZIP=protoc-25.3-linux-x86_64.zip
curl -LO https://github.com/protocolbuffers/protobuf/releases/download/v25.3/$PROTOC_ZIP
sudo unzip -o $PROTOC_ZIP -d /usr/local bin/protoc
sudo unzip -o $PROTOC_ZIP -d /usr/local 'include/*'
rm -f $PROTOC_ZIP

elif [[ "${{ runner.os }}" == "macOS" ]]; then
brew install protobuf
elif [[ "${{ runner.os }}" == "Windows" ]]; then
choco install protoc --no-progress
echo "C:\ProgramData\chocolatey\bin" >> $GITHUB_PATH
fi

protoc --version

plan:
needs:
- install-deps
runs-on: "ubuntu-latest"
outputs:
val: ${{ steps.plan.outputs.manifest }}
tag: ${{ !github.event.pull_request && github.ref_name || '' }}
tag-flag: ${{ !github.event.pull_request && format('--tag={0}', github.ref_name) || '' }}
publishing: ${{ !github.event.pull_request }}
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
steps:
- uses: actions/checkout@v4
with:
persist-credentials: false
submodules: recursive
- name: Install dist
# we specify bash to get pipefail; it guards against the `curl` command
# failing. otherwise `sh` won't catch that `curl` returned non-0
shell: bash
run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.30.3/cargo-dist-installer.sh | sh"
- name: Cache dist
uses: actions/upload-artifact@v4
with:
name: cargo-dist-cache
path: ~/.cargo/bin/dist
# sure would be cool if github gave us proper conditionals...
# so here's a doubly-nested ternary-via-truthiness to try to provide the best possible
# functionality based on whether this is a pull_request, and whether it's from a fork.
# (PRs run on the *source* but secrets are usually on the *target* -- that's *good*
# but also really annoying to build CI around when it needs secrets to work right.)
- id: plan
run: |
dist ${{ (!github.event.pull_request && format('host --steps=create --tag={0}', github.ref_name)) || 'plan' }} --output-format=json > plan-dist-manifest.json
echo "dist ran successfully"
cat plan-dist-manifest.json
echo "manifest=$(jq -c "." plan-dist-manifest.json)" >> "$GITHUB_OUTPUT"
- name: "Upload dist-manifest.json"
uses: actions/upload-artifact@v4
with:
name: artifacts-plan-dist-manifest
path: plan-dist-manifest.json

# Build and packages all the platform-specific things
build-local-artifacts:
name: build-local-artifacts (${{ join(matrix.targets, ', ') }})
# Let the initial task tell us to not run (currently very blunt)
needs:
- plan
- install-deps
if: ${{ fromJson(needs.plan.outputs.val).ci.github.artifacts_matrix.include != null && (needs.plan.outputs.publishing == 'true' || fromJson(needs.plan.outputs.val).ci.github.pr_run_mode == 'upload') }}
strategy:
fail-fast: false
# Target platforms/runners are computed by dist in create-release.
# Each member of the matrix has the following arguments:
#
# - runner: the github runner
# - dist-args: cli flags to pass to dist
# - install-dist: expression to run to install dist on the runner
#
# Typically there will be:
# - 1 "global" task that builds universal installers
# - N "local" tasks that build each platform's binaries and platform-specific installers
matrix: ${{ fromJson(needs.plan.outputs.val).ci.github.artifacts_matrix }}
runs-on: ${{ matrix.runner }}
container: ${{ matrix.container && matrix.container.image || null }}
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
BUILD_MANIFEST_NAME: target/distrib/${{ join(matrix.targets, '-') }}-dist-manifest.json
steps:
- name: enable windows longpaths
run: |
git config --global core.longpaths true
- uses: actions/checkout@v4
with:
persist-credentials: false
submodules: recursive
- name: Install Rust non-interactively if not already installed
if: ${{ matrix.container }}
run: |
if ! command -v cargo > /dev/null 2>&1; then
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
echo "$HOME/.cargo/bin" >> $GITHUB_PATH
fi
- name: Install dist
run: ${{ matrix.install_dist.run }}
# Get the dist-manifest
- name: Fetch local artifacts
uses: actions/download-artifact@v4
with:
pattern: artifacts-*
path: target/distrib/
merge-multiple: true
- name: Install dependencies
run: |
${{ matrix.packages_install }}
- name: Install-deps
shell: bash
run: |
if [[ "${{ runner.os }}" == "Linux" ]]; then
sudo apt-get update
sudo apt-get install -y pkg-config libdbus-1-dev curl unzip

# Install a pinned modern protoc
PROTOC_ZIP=protoc-25.3-linux-x86_64.zip
curl -LO https://github.com/protocolbuffers/protobuf/releases/download/v25.3/$PROTOC_ZIP
sudo unzip -o $PROTOC_ZIP -d /usr/local bin/protoc
sudo unzip -o $PROTOC_ZIP -d /usr/local 'include/*'
rm -f $PROTOC_ZIP

elif [[ "${{ runner.os }}" == "macOS" ]]; then
brew install protobuf
elif [[ "${{ runner.os }}" == "Windows" ]]; then
choco install protoc --no-progress
echo "C:\ProgramData\chocolatey\bin" >> $GITHUB_PATH
fi

protoc --version

- name: Configure Cargo for Windows builds
if: runner.os == 'Windows'
shell: bash
run: |
# Put target dir somewhere short and less likely to be locked
echo "CARGO_TARGET_DIR=D:/cargo-target" >> $GITHUB_ENV
# Reduce file-handle pressure / parallel writes
echo "CARGO_BUILD_JOBS=2" >> $GITHUB_ENV
# Avoid incremental artifacts (less churn, fewer locks)
echo "CARGO_INCREMENTAL=0" >> $GITHUB_ENV

- name: Build artifacts
run: |
# Actually do builds and make zips and whatnot
dist build ${{ needs.plan.outputs.tag-flag }} --print=linkage --output-format=json ${{ matrix.dist_args }} > dist-manifest.json
echo "dist ran successfully"
- id: cargo-dist
name: Post-build
# We force bash here just because github makes it really hard to get values up
# to "real" actions without writing to env-vars, and writing to env-vars has
# inconsistent syntax between shell and powershell.
shell: bash
run: |
# Parse out what we just built and upload it to scratch storage
echo "paths<<EOF" >> "$GITHUB_OUTPUT"
dist print-upload-files-from-manifest --manifest dist-manifest.json >> "$GITHUB_OUTPUT"
echo "EOF" >> "$GITHUB_OUTPUT"

cp dist-manifest.json "$BUILD_MANIFEST_NAME"
- name: "Upload artifacts"
uses: actions/upload-artifact@v4
with:
name: artifacts-build-local-${{ join(matrix.targets, '_') }}
path: |
${{ steps.cargo-dist.outputs.paths }}
${{ env.BUILD_MANIFEST_NAME }}

# Build and package all the platform-agnostic(ish) things
build-global-artifacts:
needs:
- plan
- install-deps
- build-local-artifacts
runs-on: "ubuntu-latest"
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
BUILD_MANIFEST_NAME: target/distrib/global-dist-manifest.json
steps:
- uses: actions/checkout@v4
with:
persist-credentials: false
submodules: recursive
- name: Install cached dist
uses: actions/download-artifact@v4
with:
name: cargo-dist-cache
path: ~/.cargo/bin/
- run: chmod +x ~/.cargo/bin/dist
- name: Install-deps
shell: bash
run: |
if [[ "${{ runner.os }}" == "Linux" ]]; then
sudo apt-get update
sudo apt-get install -y pkg-config libdbus-1-dev curl unzip

# Install a pinned modern protoc
PROTOC_ZIP=protoc-25.3-linux-x86_64.zip
curl -LO https://github.com/protocolbuffers/protobuf/releases/download/v25.3/$PROTOC_ZIP
sudo unzip -o $PROTOC_ZIP -d /usr/local bin/protoc
sudo unzip -o $PROTOC_ZIP -d /usr/local 'include/*'
rm -f $PROTOC_ZIP

elif [[ "${{ runner.os }}" == "macOS" ]]; then
brew install protobuf
elif [[ "${{ runner.os }}" == "Windows" ]]; then
choco install protoc --no-progress
echo "C:\ProgramData\chocolatey\bin" >> $GITHUB_PATH
fi

protoc --version

# Get all the local artifacts for the global tasks to use (for e.g. checksums)
- name: Fetch local artifacts
uses: actions/download-artifact@v4
with:
pattern: artifacts-*
path: target/distrib/
merge-multiple: true
- id: cargo-dist
shell: bash
run: |
dist build ${{ needs.plan.outputs.tag-flag }} --output-format=json "--artifacts=global" > dist-manifest.json
echo "dist ran successfully"

# Parse out what we just built and upload it to scratch storage
echo "paths<<EOF" >> "$GITHUB_OUTPUT"
jq --raw-output ".upload_files[]" dist-manifest.json >> "$GITHUB_OUTPUT"
echo "EOF" >> "$GITHUB_OUTPUT"

cp dist-manifest.json "$BUILD_MANIFEST_NAME"
- name: "Upload artifacts"
uses: actions/upload-artifact@v4
with:
name: artifacts-build-global
path: |
${{ steps.cargo-dist.outputs.paths }}
${{ env.BUILD_MANIFEST_NAME }}
# Determines if we should publish/announce
host:
needs:
- plan
- install-deps
- build-local-artifacts
- build-global-artifacts
# Only run if we're "publishing", and only if plan, local and global didn't fail (skipped is fine)
if: ${{ always() && needs.plan.result == 'success' && needs.plan.outputs.publishing == 'true' && (needs.build-global-artifacts.result == 'skipped' || needs.build-global-artifacts.result == 'success') && (needs.build-local-artifacts.result == 'skipped' || needs.build-local-artifacts.result == 'success') }}
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
runs-on: "ubuntu-latest"
outputs:
val: ${{ steps.host.outputs.manifest }}
steps:
- uses: actions/checkout@v4
with:
persist-credentials: false
submodules: recursive
- name: Install cached dist
uses: actions/download-artifact@v4
with:
name: cargo-dist-cache
path: ~/.cargo/bin/
- run: chmod +x ~/.cargo/bin/dist
# Fetch artifacts from scratch-storage
- name: Fetch artifacts
uses: actions/download-artifact@v4
with:
pattern: artifacts-*
path: target/distrib/
merge-multiple: true
- id: host
shell: bash
run: |
dist host ${{ needs.plan.outputs.tag-flag }} --steps=upload --steps=release --output-format=json > dist-manifest.json
echo "artifacts uploaded and released successfully"
cat dist-manifest.json
echo "manifest=$(jq -c "." dist-manifest.json)" >> "$GITHUB_OUTPUT"
- name: "Upload dist-manifest.json"
uses: actions/upload-artifact@v4
with:
# Overwrite the previous copy
name: artifacts-dist-manifest
path: dist-manifest.json
# Create a GitHub Release while uploading all files to it
- name: "Download GitHub Artifacts"
uses: actions/download-artifact@v4
with:
pattern: artifacts-*
path: artifacts
merge-multiple: true
- name: Cleanup
run: |
# Remove the granular manifests
rm -f artifacts/*-dist-manifest.json
- name: Create GitHub Release
env:
PRERELEASE_FLAG: "${{ fromJson(steps.host.outputs.manifest).announcement_is_prerelease && '--prerelease' || '' }}"
ANNOUNCEMENT_TITLE: "${{ fromJson(steps.host.outputs.manifest).announcement_title }}"
ANNOUNCEMENT_BODY: "${{ fromJson(steps.host.outputs.manifest).announcement_github_body }}"
RELEASE_COMMIT: "${{ github.sha }}"
run: |
# Write and read notes from a file to avoid quoting breaking things
echo "$ANNOUNCEMENT_BODY" > $RUNNER_TEMP/notes.txt

gh release create "${{ needs.plan.outputs.tag }}" --target "$RELEASE_COMMIT" $PRERELEASE_FLAG --title "$ANNOUNCEMENT_TITLE" --notes-file "$RUNNER_TEMP/notes.txt" artifacts/*

publish-homebrew-formula:
needs:
- plan
- host
- install-deps
- build-local-artifacts
- build-global-artifacts
runs-on: "ubuntu-latest"
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
PLAN: ${{ needs.plan.outputs.val }}
GITHUB_USER: "axo bot"
GITHUB_EMAIL: "admin+bot@axo.dev"
if: ${{ !fromJson(needs.plan.outputs.val).announcement_is_prerelease || fromJson(needs.plan.outputs.val).publish_prereleases }}
steps:
- uses: actions/checkout@v4
with:
persist-credentials: true
repository: "gnostr-org/homebrew-gnostr"
token: ${{ secrets.HOMEBREW_TAP_TOKEN }}
# So we have access to the formula
- name: Fetch homebrew formulae
uses: actions/download-artifact@v4
with:
pattern: artifacts-*
path: Formula/
merge-multiple: true
# This is extra complex because you can make your Formula name not match your app name
# so we need to find releases with a *.rb file, and publish with that filename.
- name: Commit formula files
run: |
git config --global user.name "${GITHUB_USER}"
git config --global user.email "${GITHUB_EMAIL}"

for release in $(echo "$PLAN" | jq --compact-output '.releases[] | select([.artifacts[] | endswith(".rb")] | any)'); do
filename=$(echo "$release" | jq '.artifacts[] | select(endswith(".rb"))' --raw-output)
name=$(echo "$filename" | sed "s/\.rb$//")
version=$(echo "$release" | jq .app_version --raw-output)

export PATH="/home/linuxbrew/.linuxbrew/bin:$PATH"
brew update
# We avoid reformatting user-provided data such as the app description and homepage.
brew style --except-cops FormulaAudit/Homepage,FormulaAudit/Desc,FormulaAuditStrict --fix "Formula/${filename}" || true

git add "Formula/${filename}"
git commit -m "${name} ${version}"
done
git push

announce:
needs:
- plan
- install-deps
- build-local-artifacts
- build-global-artifacts
- host
- publish-homebrew-formula
# use "always() && ..." to allow us to wait for all publish jobs while
# still allowing individual publish jobs to skip themselves (for prereleases).
# "host" however must run to completion, no skipping allowed!
if: ${{ always() && needs.host.result == 'success' && (needs.publish-homebrew-formula.result == 'skipped' || needs.publish-homebrew-formula.result == 'success') }}
runs-on: "ubuntu-latest"
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
steps:
- uses: actions/checkout@v4
with:
persist-credentials: false
submodules: recursive

# View an Issue By ID > `n34 issue view` command Usage: ...

2026-04-05T04:59:23Z

# Resolves an Issue > `n34 issue resolve` command Usage: ...

2026-04-05T04:59:11Z

# Reopen a Closed Issue > `n34 issue reopen` command ...

2026-04-05T04:59:00Z

# 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 `_@4rs.nl/n34`), or a set name like `kernel`
```

Issue a kind `1630` (Open status) for the specified issue. The issue have to
be closed.

# Create an Issue > `n34 issue new` Command Usage: ``` ...

2026-04-05T04:58:49Z

# 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 `_@4rs.nl/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.

# Draft an Open Patch > `n34 patch draft` command Usage: ...

2026-04-05T04:34:41Z

use frost_secp256k1_tr as frost; use frost::{Identifier, ...

2026-04-05T04:34:34Z

use frost_secp256k1_tr as frost;
use frost::{Identifier, keys::IdentifierList, round1, round2};
use rand_chacha::ChaCha20Rng;
use rand_chacha::rand_core::SeedableRng;
use std::fs;

#[cfg(feature = "nostr")]
fn main() -> Result<(), Box<dyn std::error::Error>> {
// 1. SETUP: Initial Key Generation (The "Genesis" event)
let mut dealer_rng = ChaCha20Rng::from_seed([0u8; 32]);
let min_signers = 2;
let (shares, pubkey_package) = frost::keys::generate_with_dealer(
3, min_signers, IdentifierList::Default, &mut dealer_rng
)?;

// 2. PERSISTENCE: Save Participant 1's KeyPackage to a file
let p1_id = Identifier::try_from(1u16)?;
let p1_key_pkg = frost::keys::KeyPackage::new(
p1_id,
*shares[&p1_id].signing_share(),
frost::keys::VerifyingShare::from(*shares[&p1_id].signing_share()),
*pubkey_package.verifying_key(),
min_signers,
);

// Serialize to JSON (standard for many Nostr/Git tools)
let p1_json = serde_json::to_string_pretty(&p1_key_pkg)?;
fs::write("p1_key.json", p1_json)?;

let pub_json = serde_json::to_string_pretty(&pubkey_package)?;
fs::write("group_public.json", pub_json)?;

println!("--- BIP-64MOD: Key Persistence ---");
println!("✅ Saved p1_key.json and group_public.json to disk.");

// 3. RELOAD: Simulate a Signer waking up later
let p1_loaded_json = fs::read_to_string("p1_key.json")?;
let p1_reloaded_pkg: frost::keys::KeyPackage = serde_json::from_str(&p1_loaded_json)?;

println!("✅ Reloaded KeyPackage for Participant: {:?}", p1_reloaded_pkg.identifier());

// 4. SIGN: Use the reloaded key to sign a new Git Commit Hash
let mut rng = ChaCha20Rng::from_seed([100u8; 32]); // Fresh seed for this specific signing session
let (nonces, commitments) = round1::commit(p1_reloaded_pkg.signing_share(), &mut rng);

println!("\nGenerated Nonce for new session:");
println!(" Commitment: {}", hex::encode(commitments.serialize()?));

// Cleanup files for the example
// fs::remove_file("p1_key.json")?;
// fs::remove_file("group_public.json")?;

Ok(())
}

#[cfg(not(feature = "nostr"))]
fn main() { println!("Enable nostr feature."); }

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

2026-04-05T04:34:33Z

# Reopens a Closed or Drafted Patch > `n34 patch reopen` ...

2026-04-05T04:34:33Z

# 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 `_@4rs.nl/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.

# Issue Management Using `n34`, you can manage Git issues stored ...

2026-04-05T04:34:33Z

# 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

# Reopen a Closed Issue > `n34 issue reopen` command ...

2026-04-05T04:34:33Z

# Closes an Open or Drafted Patch > `n34 patch close` command ...

2026-04-05T04:34:30Z

use frost_secp256k1_tr as frost; use frost::{Identifier, ...

2026-04-05T04:34:23Z

use frost_secp256k1_tr as frost;
use frost::{Identifier, keys::IdentifierList, round1, round2};
use rand_chacha::ChaCha20Rng;
use rand_chacha::rand_core::SeedableRng;
use std::collections::BTreeMap;

#[cfg(feature = "nostr")]
fn main() -> Result<(), Box<dyn std::error::Error>> {
// 1. RECREATE CONTEXT (Same as Signer)
let mut dealer_rng = ChaCha20Rng::from_seed([0u8; 32]);
let min_signers = 2;
let (shares, pubkey_package) = frost::keys::generate_with_dealer(
3, min_signers, IdentifierList::Default, &mut dealer_rng
)?;

let p1_id = Identifier::try_from(1u16)?;
let p2_id = Identifier::try_from(2u16)?;

// 2. SIMULATE SIGNING (Round 1 & 2)
let mut rng1 = ChaCha20Rng::from_seed([1u8; 32]);
let (p1_nonces, p1_commitments) = round1::commit(shares[&p1_id].signing_share(), &mut rng1);
let mut rng2 = ChaCha20Rng::from_seed([2u8; 32]);
let (p2_nonces, p2_commitments) = round1::commit(shares[&p2_id].signing_share(), &mut rng2);

let message = b"gnostr-gcc-verification-test";
let mut commitments_map = BTreeMap::new();
commitments_map.insert(p1_id, p1_commitments);
commitments_map.insert(p2_id, p2_commitments);
let signing_package = frost::SigningPackage::new(commitments_map, message);

// Generate shares (using the KeyPackage method we perfected)
let p1_key_pkg = frost::keys::KeyPackage::new(p1_id, *shares[&p1_id].signing_share(),
frost::keys::VerifyingShare::from(*shares[&p1_id].signing_share()),
*pubkey_package.verifying_key(), min_signers);
let p2_key_pkg = frost::keys::KeyPackage::new(p2_id, *shares[&p2_id].signing_share(),
frost::keys::VerifyingShare::from(*shares[&p2_id].signing_share()),
*pubkey_package.verifying_key(), min_signers);

let p1_sig_share = round2::sign(&signing_package, &p1_nonces, &p1_key_pkg)?;
let p2_sig_share = round2::sign(&signing_package, &p2_nonces, &p2_key_pkg)?;

// 3. COORDINATOR: AGGREGATION
println!("--- BIP-64MOD: Coordinator Aggregation ---");

let mut shares_map = BTreeMap::new();
shares_map.insert(p1_id, p1_sig_share);
shares_map.insert(p2_id, p2_sig_share);

let final_signature = frost::aggregate(
&signing_package,
&shares_map,
&pubkey_package
)?;

let sig_bytes = final_signature.serialize()?;
println!("✅ Aggregation Successful!");
println!("Final Signature (Hex): {}", hex::encode(&sig_bytes));

// 4. VERIFICATION (The moment of truth)
pubkey_package.verifying_key().verify(message, &final_signature)?;
println!("🛡️ Signature Verified against Group Public Key!");

Ok(())
}

#[cfg(not(feature = "nostr"))]
fn main() { println!("Enable nostr feature."); }

# Create an Issue > `n34 issue new` Command Usage: ``` ...

2026-04-05T04:34:22Z

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

2026-04-05T04:34:22Z

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

use std::net::SocketAddr;

use clap::{ArgGroup, Args};

use crate::{
cli::{CliOptions, options_state::DEFAULT_NIP07_PROXY_ADDR, traits::CommandRunner},
error::N34Result,
};

#[derive(Args, Debug)]
#[clap(
group(
ArgGroup::new("options")
.required(true)
)
)]
pub struct Nip07Args {
/// Enable NIP-07 as the default signer.
#[arg(long, group = "options")]
enable: bool,
/// Disable NIP-07 as the default signer.
#[arg(long, group = "options", group = "disable_options")]
disable: bool,
/// Set the default `ip:port` for the browser signer proxy.
#[arg(long, group = "disable_options")]
addr: Option<SocketAddr>,
}

impl CommandRunner for Nip07Args {
const NEED_SIGNER: bool = false;

async fn run(self, mut options: CliOptions) -> N34Result<()> {
if self.enable {
let addr = self.addr.unwrap_or(DEFAULT_NIP07_PROXY_ADDR);
options.config.nip07 = Some(addr)
} else {
options.config.nip07 = None
}

options.config.dump()
}
}

<!DOCTYPE html> <html lang="en"> <head> ...

2026-04-05T04:34:22Z

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

# Merge an Open Patch > `n34 patch merge` command Usage: ...

2026-04-05T04:34:22Z

# 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 `_@4rs.nl/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

# Apply an Open Patch > `n34 patch apply` command Usage: ...

2026-04-05T04:34:19Z

use rand_chacha::ChaCha20Rng; use ...

2026-04-05T04:34:12Z

use rand_chacha::ChaCha20Rng;
use rand_chacha::rand_core::SeedableRng;
use frost_secp256k1_tr as frost;
use frost::{Identifier, keys::IdentifierList, round1, round2};
use std::collections::BTreeMap;

#[cfg(feature = "nostr")]
fn main() -> Result<(), Box<dyn std::error::Error>> {
let mut dealer_rng = ChaCha20Rng::from_seed([0u8; 32]);
let min_signers = 2;
let (shares, pubkey_package) = frost::keys::generate_with_dealer(
3, min_signers, IdentifierList::Default, &mut dealer_rng
)?;

// 1. Setup Signer (P1) and peer (P2)
let p1_id = Identifier::try_from(1u16)?;
let p2_id = Identifier::try_from(2u16)?;

// 2. Round 1: Both signers generate nonces (Simulating P2's contribution)
let mut rng1 = ChaCha20Rng::from_seed([1u8; 32]);
let (p1_nonces, p1_commitments) = round1::commit(shares[&p1_id].signing_share(), &mut rng1);

let mut rng2 = ChaCha20Rng::from_seed([2u8; 32]);
let (_p2_nonces, p2_commitments) = round1::commit(shares[&p2_id].signing_share(), &mut rng2);

// 3. Coordinator: Create a valid SigningPackage with 2 signers
let message = b"gnostr-gcc-verification-test";
let mut commitments_map = BTreeMap::new();
commitments_map.insert(p1_id, p1_commitments);
commitments_map.insert(p2_id, p2_commitments); // Added P2 to satisfy threshold

let signing_package = frost::SigningPackage::new(commitments_map, message);

println!("--- BIP-64MOD Round 2: Signer Validation ---");

// 4. SIGNER-SIDE CHECK (Manual)
if !signing_package.signing_commitments().contains_key(&p1_id) {
return Err("Validation Failed: My commitment is missing!".into());
}

let commitment_count = signing_package.signing_commitments().len() as u16;
if commitment_count < min_signers {
return Err(format!("Validation Failed: Only {} commitments provided, need {}.", commitment_count, min_signers).into());
}

println!("✅ Signing Package validated ({} signers).", commitment_count);
println!("Proceeding to sign message: {:?}", String::from_utf8_lossy(message));

// 5. Generate the Share
let p1_verifying_share = frost::keys::VerifyingShare::from(*shares[&p1_id].signing_share());
let p1_key_package = frost::keys::KeyPackage::new(
p1_id,
*shares[&p1_id].signing_share(),
p1_verifying_share,
*pubkey_package.verifying_key(),
min_signers,
);

let p1_signature_share = round2::sign(&signing_package, &p1_nonces, &p1_key_package)?;

println!("\nPartial Signature Share for P1:");
println!("{}", hex::encode(p1_signature_share.serialize()));

Ok(())
}

#[cfg(not(feature = "nostr"))]
fn main() { println!("Enable nostr feature."); }

# Fallback Relays > `n34 config relays` command Usage: ``` ...

2026-04-05T04:34:12Z

# 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.

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

2026-04-05T04:34:10Z

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

/// `config bunker` subcommand
mod bunker;
/// `config keyring` subcommand
mod keyring;
/// `config nip07` subcommand
mod nip07;
/// `config pow` subcommand
mod pow;
/// `config relays` subcommand
mod relays;

use clap::Subcommand;

use self::bunker::BunkerArgs;
use self::keyring::KeyringArgs;
use self::nip07::Nip07Args;
use self::pow::PowArgs;
use self::relays::RelaysArgs;
use super::CliOptions;
use crate::{cli::traits::CommandRunner, error::N34Result};

#[derive(Subcommand, Debug)]
pub enum ConfigSubcommands {
/// Sets the default PoW difficulty (0 if not specified)
Pow(PowArgs),
/// Sets the default fallback relays if none provided. Use this relays for
/// read and write.
Relays(RelaysArgs),
/// Sets a URL of NIP-46 bunker server used for signing events.
Bunker(BunkerArgs),
/// Managing the secret key keyring, including enabling, disabling, or
/// resetting it.
Keyring(KeyringArgs),
/// Controls the NIP-07 browser signer proxy, turning it on or off, and
/// configures the `ip:port` address.
Nip07(Nip07Args),
}

impl CommandRunner for ConfigSubcommands {
async fn run(self, options: CliOptions) -> N34Result<()> {
crate::run_command!(self, options, & Pow Relays Bunker Keyring Nip07)
}
}

# List Repositories Issues > `n34 issue list` command ...

2026-04-05T04:34:10Z

# 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 `_@4rs.nl/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.

# List Repositories Patches > `n34 patch list` command ...

2026-04-05T04:34:10Z

# 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 `_@4rs.nl/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.

# Patch Management In `n34`, patch management is designed to give ...

2026-04-05T04:34:08Z

use rand_chacha::ChaCha20Rng; use ...

2026-04-05T04:34:01Z

use rand_chacha::ChaCha20Rng;
use rand_chacha::rand_core::SeedableRng;
use frost_secp256k1_tr as frost;
use frost::{Identifier, keys::IdentifierList, round1};
use std::collections::BTreeMap;

#[cfg(feature = "nostr")]
fn main() -> Result<(), Box<dyn std::error::Error>> {
// 1. Setup deterministic dealer (Genesis State)
let mut dealer_rng = ChaCha20Rng::from_seed([0u8; 32]);
let (shares, _pubkey_package) = frost::keys::generate_with_dealer(
3, 2, IdentifierList::Default, &mut dealer_rng
)?;

// 2. Setup Participant 1
let p1_id = Identifier::try_from(1u16)?;
let p1_share = &shares[&p1_id];

// 3. Setup Nonce RNG
let mut nonce_rng = ChaCha20Rng::from_seed([1u8; 32]);

println!("--- BIP-64MOD Round 1: Batch Nonce Generation ---");
println!("Participant: {:?}", p1_id);
println!("Generating 10 Nonce Pairs...\n");

let mut batch_commitments = BTreeMap::new();
let mut batch_secrets = Vec::new();

for i in 0..10 {
// Generate a single pair
let (nonces, commitments) = round1::commit(p1_share.signing_share(), &mut nonce_rng);

// Store the secret nonces locally (index i)
batch_secrets.push(nonces);

// Store the public commitments in a map to share with the Coordinator
batch_commitments.insert(i, commitments);

println!("Nonce Pair [{}]:", i);
println!(" Hiding: {}", hex::encode(commitments.hiding().serialize()?));
println!(" Binding: {}", hex::encode(commitments.binding().serialize()?));
}

// 4. Persistence Simulation
// In a real GCC app, you would save `batch_secrets` to an encrypted file
// and send `batch_commitments` to a Nostr Relay (Kind 1351).
println!("\n✅ Batch generation complete.");
println!("Ready to sign up to 10 independent Git commits.");

Ok(())
}

#[cfg(not(feature = "nostr"))]
fn main() { println!("Run with --features nostr"); }

# Default PoW Difficulty > `n34 config pow` Usage: ``` ...

2026-04-05T04:34:00Z

# 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.

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

2026-04-05T04:33:59Z

# Closes an Open Issue > `n34 issue close` command Usage: ...

2026-04-05T04:33:59Z

# 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 `_@4rs.nl/n34`), or a set name like `kernel`
```

Issue a kind `1632` (Close status) for the specified issue. The issue have to
be open.

# Fetch a Patch By ID > `n34 patch fetch` command Usage: ...

2026-04-05T04:33:59Z

Nostr notes by

{ "nodes": { "flake-utils": { "inputs": { ...

# Fetch a Patch By ID > `n34 patch fetch` command **Usage:** ...

# Modify a Set > `n34 sets update` command **Usage:** ``` ...

# Draft an Open Patch > `n34 patch draft` command **Usage:** ...

# Show a Set > `n34 sets show` command **Usage:** ``` Show a ...

# Closes an Open or Drafted Patch > `n34 patch close` command ...

# Remove a Set > `n34 sets remove` command **Usage:** ``` ...

# Apply an Open Patch > `n34 patch apply` command **Usage:** ...

# Create a Set > `n34 sets new` command **Usage:** ``` Create ...

# Patch Management In `n34`, patch management is designed to give ...

# Managing Repository and Relay Sets Sets are a convenience ...

# View an Issue By ID > `n34 issue view` command **Usage:** ...

# View Git Repository Details > `n34 repo view` command ...

# Resolves an Issue > `n34 issue resolve` command **Usage:** ...

# Broadcast and Update a Git Repository > `n34 repo announce` ...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Copyright 2025 Thomas Profelt // // Permission is hereby ...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#!/usr/bin/env sh N34_RELAY_BASE_DIR=./bin RUST_LOG=debug cargo ...

<svg width="38" height="38" viewBox="0 0 ...

unstable_features = true style_edition = "2024" ...

// This protobuf contract defines the interface for managing and ...

# Grasp - Git Relays Authorized via Signed-Nostr Proofs Status: ...

<svg width="38" height="38" viewBox="0 0 ...

MIT License Copyright (c) 2025 DanConwayDev Permission is hereby ...

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

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

# `build.rs` Documentation This document explains the ...

Nostr event nevent1qqsd5attuq7eaae70mgp8w8p55pnng0wmnpfu9dyfhezenjl4el4xwgzyptmj32nj8lt658t74lretj59vennwa847lj5yjgfwvdmesyy8dsvc3gkxw

# This file contains NIP-19 `naddr` entities for repositories ...

name: Rust on: push: branches: [ "*" ] pull_request: ...

{ inputs = { nixpkgs.url = ...

# This file was autogenerated by dist: ...

# View an Issue By ID > `n34 issue view` command **Usage:** ...

# Resolves an Issue > `n34 issue resolve` command **Usage:** ...

# Reopen a Closed Issue > `n34 issue reopen` command ...

# Create an Issue > `n34 issue new` Command **Usage:** ``` ...

# Draft an Open Patch > `n34 patch draft` command **Usage:** ...

use frost_secp256k1_tr as frost; use frost::{Identifier, ...

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

# Fetch a Patch By ID > `n34 patch fetch` command Usage: ...

# Modify a Set > `n34 sets update` command Usage: ``` ...

# Draft an Open Patch > `n34 patch draft` command Usage: ...

# Show a Set > `n34 sets show` command Usage: ``` Show a ...

# Remove a Set > `n34 sets remove` command Usage: ``` ...

# Apply an Open Patch > `n34 patch apply` command Usage: ...

# Create a Set > `n34 sets new` command Usage: ``` Create ...

# View an Issue By ID > `n34 issue view` command Usage: ...

# Resolves an Issue > `n34 issue resolve` command Usage: ...

# View an Issue By ID > `n34 issue view` command Usage: ...

# Resolves an Issue > `n34 issue resolve` command Usage: ...

# Create an Issue > `n34 issue new` Command Usage: ``` ...

# Draft an Open Patch > `n34 patch draft` command Usage: ...

# Create an Issue > `n34 issue new` Command Usage: ``` ...

# Merge an Open Patch > `n34 patch merge` command Usage: ...

# Apply an Open Patch > `n34 patch apply` command Usage: ...

# Fallback Relays > `n34 config relays` command Usage: ``` ...

# Default PoW Difficulty > `n34 config pow` Usage: ``` ...

# Closes an Open Issue > `n34 issue close` command Usage: ...

# Fetch a Patch By ID > `n34 patch fetch` command Usage: ...