@qntx/nostr-native 0.0.0-stage → 0.12.1

package/cpp/nostr_core.c

@@ -0,0 +1,128 @@
+/*
+ * The vendored libsecp256k1 is compiled as a single translation unit inside this file:
+ * secp256k1.c includes every implementation header plus the modules enabled with
+ * -DENABLE_MODULE_EXTRAKEYS / -DENABLE_MODULE_SCHNORRSIG, so this TU also sees the library's
+ * internal SHA-256 (nostr_native_secp256k1_sha256_*) and
+ * nostr_native_secp256k1_memclear_explicit. Those are internal APIs of the pinned vendor tree —
+ * the NIST SHA-256 vectors in tests/host guard them.
+ *
+ * The vendor script prefixes every secp256k1_ identifier with nostr_native_ (see
+ * scripts/vendor-secp256k1.ts): React Native pods are statically linked into one binary and an
+ * unprefixed libsecp256k1 would collide with any other pod embedding it. This is the only TU
+ * that may include secp256k1.c — the two precomputed-table TUs stay separate. It must come
+ * before nostr_core.h: secp256k1.c defines SECP256K1_BUILD and refuses to be the second
+ * includer of its own public header.
+ */
+#include "../vendor/secp256k1/src/secp256k1.c"
+#include "../vendor/secp256k1/include/secp256k1_extrakeys.h"
+#include "../vendor/secp256k1/include/secp256k1_schnorrsig.h"
+
+#include "nostr_core.h"
+
+void nostr_core_wipe(void *ptr, size_t len) {
+  nostr_native_secp256k1_memclear_explicit(ptr, len);
+}
+
+int nostr_core_verify(const nostr_native_secp256k1_context *ctx, const unsigned char id[32],
+                      const unsigned char pubkey[32], const unsigned char sig[64]) {
+  nostr_native_secp256k1_xonly_pubkey parsed;
+
+  if (ctx == NULL || id == NULL || pubkey == NULL || sig == NULL) {
+    return NOSTR_CORE_INVALID_INPUT;
+  }
+  if (!nostr_native_secp256k1_xonly_pubkey_parse(ctx, &parsed, pubkey)) {
+    return NOSTR_CORE_INVALID_INPUT;
+  }
+  return nostr_native_secp256k1_schnorrsig_verify(ctx, sig, id, 32, &parsed)
+             ? NOSTR_CORE_OK
+             : NOSTR_CORE_VERIFY_FAILED;
+}
+
+int nostr_core_verify_serialized(const nostr_native_secp256k1_context *ctx,
+                                 const unsigned char *serialized, size_t len,
+                                 const unsigned char id[32], const unsigned char pubkey[32],
+                                 const unsigned char sig[64]) {
+  unsigned char digest[32];
+  nostr_native_secp256k1_sha256 sha;
+  const nostr_native_secp256k1_hash_ctx *hash_ctx;
+  size_t i;
+
+  if (ctx == NULL || serialized == NULL || id == NULL || pubkey == NULL || sig == NULL) {
+    return NOSTR_CORE_INVALID_INPUT;
+  }
+
+  hash_ctx = nostr_native_secp256k1_get_hash_context(ctx);
+  nostr_native_secp256k1_sha256_initialize(&sha);
+  nostr_native_secp256k1_sha256_write(hash_ctx, &sha, serialized, len);
+  nostr_native_secp256k1_sha256_finalize(hash_ctx, &sha, digest);
+  for (i = 0; i < 32; i++) {
+    if (digest[i] != id[i]) {
+      return NOSTR_CORE_VERIFY_FAILED;
+    }
+  }
+  return nostr_core_verify(ctx, id, pubkey, sig);
+}
+
+int nostr_core_sign(const nostr_native_secp256k1_context *ctx, const unsigned char id[32],
+                    const unsigned char seckey[32], const unsigned char aux[32],
+                    unsigned char out_sig[64]) {
+  nostr_native_secp256k1_keypair keypair;
+  int ok;
+
+  if (ctx == NULL || id == NULL || seckey == NULL || aux == NULL || out_sig == NULL) {
+    return NOSTR_CORE_INVALID_INPUT;
+  }
+
+  ok = nostr_native_secp256k1_keypair_create(ctx, &keypair, seckey) &&
+       nostr_native_secp256k1_schnorrsig_sign32(ctx, out_sig, id, &keypair, aux);
+  nostr_native_secp256k1_memclear_explicit(&keypair, sizeof(keypair));
+  return ok ? NOSTR_CORE_OK : NOSTR_CORE_INVALID_INPUT;
+}
+
+int nostr_core_public_key(const nostr_native_secp256k1_context *ctx,
+                          const unsigned char seckey[32], unsigned char out_xonly[32]) {
+  nostr_native_secp256k1_keypair keypair;
+  nostr_native_secp256k1_xonly_pubkey pubkey;
+  int ok;
+
+  if (ctx == NULL || seckey == NULL || out_xonly == NULL) {
+    return NOSTR_CORE_INVALID_INPUT;
+  }
+
+  ok = nostr_native_secp256k1_keypair_create(ctx, &keypair, seckey) &&
+       nostr_native_secp256k1_keypair_xonly_pub(ctx, &pubkey, NULL, &keypair) &&
+       nostr_native_secp256k1_xonly_pubkey_serialize(ctx, out_xonly, &pubkey);
+  nostr_native_secp256k1_memclear_explicit(&keypair, sizeof(keypair));
+  return ok ? NOSTR_CORE_OK : NOSTR_CORE_INVALID_INPUT;
+}
+
+#ifdef NOSTR_NATIVE_TEST
+
+nostr_native_secp256k1_context *nostr_native_test_context(void) {
+  static nostr_native_secp256k1_context *ctx;
+  if (ctx == NULL) {
+    ctx = nostr_native_secp256k1_context_create(SECP256K1_CONTEXT_NONE);
+  }
+  return ctx;
+}
+
+void nostr_native_test_sha256(const unsigned char *data, size_t len, unsigned char out32[32]) {
+  nostr_native_secp256k1_context *ctx = nostr_native_test_context();
+  const nostr_native_secp256k1_hash_ctx *hash_ctx = nostr_native_secp256k1_get_hash_context(ctx);
+  nostr_native_secp256k1_sha256 sha;
+  nostr_native_secp256k1_sha256_initialize(&sha);
+  nostr_native_secp256k1_sha256_write(hash_ctx, &sha, data, len);
+  nostr_native_secp256k1_sha256_finalize(hash_ctx, &sha, out32);
+}
+
+int nostr_native_test_schnorr_verify(const unsigned char *msg, size_t msglen,
+                                     const unsigned char pubkey[32], const unsigned char sig[64]) {
+  nostr_native_secp256k1_context *ctx = nostr_native_test_context();
+  nostr_native_secp256k1_xonly_pubkey parsed;
+  if (!nostr_native_secp256k1_xonly_pubkey_parse(ctx, &parsed, pubkey)) {
+    return 0;
+  }
+  return nostr_native_secp256k1_schnorrsig_verify(ctx, sig, msg, msglen, &parsed);
+}
+
+#endif

package/cpp/nostr_core.h

@@ -0,0 +1,65 @@
+#ifndef NOSTR_CORE_H
+#define NOSTR_CORE_H
+
+#include <stddef.h>
+
+#include "../vendor/secp256k1/include/secp256k1.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Platform-independent secp256k1 operations shared by the React Native layer
+ * (nostr_native.c) and the wasm32 layer (packages/nostr-wasm/c/nostr_wasm.c).
+ * Every entry point takes the caller's context; status codes:
+ */
+
+/* Success, or the signature verified. */
+#define NOSTR_CORE_OK 0
+/* The hash or signature check failed. */
+#define NOSTR_CORE_VERIFY_FAILED 1
+/* NULL argument, invalid scalar, or a non-point public key. */
+#define NOSTR_CORE_INVALID_INPUT 2
+
+/* BIP-340 verify of the 32-byte `id` for the x-only `pubkey`. */
+int nostr_core_verify(const nostr_native_secp256k1_context *ctx, const unsigned char id[32],
+                      const unsigned char pubkey[32], const unsigned char sig[64]);
+
+/* `sha256(serialized[0..len])` must equal `id`, then BIP-340 verify. */
+int nostr_core_verify_serialized(const nostr_native_secp256k1_context *ctx,
+                                 const unsigned char *serialized, size_t len,
+                                 const unsigned char id[32], const unsigned char pubkey[32],
+                                 const unsigned char sig[64]);
+
+/* BIP-340 sign the 32-byte `id` with caller-supplied `aux` randomness; writes
+ * 64 signature bytes on NOSTR_CORE_OK. The keypair is wiped on every path. */
+int nostr_core_sign(const nostr_native_secp256k1_context *ctx, const unsigned char id[32],
+                    const unsigned char seckey[32], const unsigned char aux[32],
+                    unsigned char out_sig[64]);
+
+/* Write the 32-byte x-only public key of `seckey` to `out_xonly`. */
+int nostr_core_public_key(const nostr_native_secp256k1_context *ctx,
+                          const unsigned char seckey[32], unsigned char out_xonly[32]);
+
+/* Secure wipe for platform layers that must clear caller-provided regions. */
+void nostr_core_wipe(void *ptr, size_t len);
+
+#ifdef NOSTR_NATIVE_TEST
+/* Test-only entry points (host suite only): expose the SHA-256 and Schnorr halves individually
+ * so BIP-340 vectors with arbitrary-length messages and raw SHA-256 vectors can run. */
+
+/* A lazily created context owned by the test binary; never destroyed. */
+nostr_native_secp256k1_context *nostr_native_test_context(void);
+
+void nostr_native_test_sha256(const unsigned char *data, size_t len, unsigned char out32[32]);
+
+int nostr_native_test_schnorr_verify(const unsigned char *msg, size_t msglen,
+                                     const unsigned char pubkey[32], const unsigned char sig[64]);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* NOSTR_CORE_H */

package/cpp/nostr_native.c

@@ -0,0 +1,54 @@
+#include "nostr_native.h"
+
+#include "nostr_core.h"
+
+#include <pthread.h>
+#include <stdlib.h>
+#include <string.h>
+
+/*
+ * React Native platform layer: owns the process context (pthread_once creation plus an
+ * arc4random seed) and delegates the crypto work to nostr_core.c — the single TU that
+ * compiles the vendored libsecp256k1. CONTEXT_NONE runs the library self test; randomizing
+ * with an arc4random seed blinds ecmult_gen against side-channel leakage of the secret key
+ * while signing. Every public entry point resolves the context first.
+ */
+static nostr_native_secp256k1_context *module_ctx;
+static pthread_once_t module_ctx_once = PTHREAD_ONCE_INIT;
+
+static void init_module_context(void) {
+  unsigned char seed[32];
+  nostr_native_secp256k1_context *created =
+      nostr_native_secp256k1_context_create(SECP256K1_CONTEXT_NONE);
+  if (created == NULL) {
+    abort();
+  }
+  arc4random_buf(seed, sizeof(seed));
+  if (!nostr_native_secp256k1_context_randomize(created, seed)) {
+    abort();
+  }
+  nostr_core_wipe(seed, sizeof(seed));
+  module_ctx = created;
+}
+
+static nostr_native_secp256k1_context *module_context(void) {
+  pthread_once(&module_ctx_once, init_module_context);
+  return module_ctx;
+}
+
+int nostr_native_verify_serialized(const unsigned char *serialized, size_t len,
+                                   const unsigned char id[32],
+                                   const unsigned char pubkey[32],
+                                   const unsigned char sig[64]) {
+  return nostr_core_verify_serialized(module_context(), serialized, len, id, pubkey, sig) ==
+         NOSTR_CORE_OK;
+}
+
+int nostr_native_public_key(const unsigned char seckey[32], unsigned char out_xonly[32]) {
+  return nostr_core_public_key(module_context(), seckey, out_xonly) == NOSTR_CORE_OK;
+}
+
+int nostr_native_sign(const unsigned char id[32], const unsigned char seckey[32],
+                      const unsigned char aux_rand[32], unsigned char out_sig[64]) {
+  return nostr_core_sign(module_context(), id, seckey, aux_rand, out_sig) == NOSTR_CORE_OK;
+}

package/cpp/nostr_native.h

@@ -0,0 +1,47 @@
+#ifndef NOSTR_NATIVE_H
+#define NOSTR_NATIVE_H
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Return 1 iff `sha256(serialized[0..len])` equals `id` and `sig` is a valid BIP-340 signature of
+ * `id` for the x-only `pubkey`. `id`/`pubkey` are 32 bytes and `sig` is 64 bytes; NULL pointers
+ * return 0.
+ */
+int nostr_native_verify_serialized(const unsigned char *serialized, size_t len,
+                                   const unsigned char id[32],
+                                   const unsigned char pubkey[32],
+                                   const unsigned char sig[64]);
+
+/**
+ * Write the 32-byte x-only BIP-340 public key of `seckey` to `out_xonly`.
+ * Returns 1 on success; 0 on NULL input or an invalid secret key (zero or >= group order).
+ */
+int nostr_native_public_key(const unsigned char seckey[32], unsigned char out_xonly[32]);
+
+/**
+ * Write the 64-byte BIP-340 signature of `id` by `seckey` with `aux_rand` auxiliary randomness
+ * to `out_sig`. Returns 1 on success; 0 on NULL input or an invalid secret key.
+ */
+int nostr_native_sign(const unsigned char id[32], const unsigned char seckey[32],
+                      const unsigned char aux_rand[32], unsigned char out_sig[64]);
+
+#ifdef NOSTR_NATIVE_TEST
+/* Test-only entry points (host suite only): expose the SHA-256 and Schnorr halves individually
+ * so BIP-340 vectors with arbitrary-length messages and raw SHA-256 vectors can run. */
+
+void nostr_native_test_sha256(const unsigned char *data, size_t len, unsigned char out32[32]);
+
+int nostr_native_test_schnorr_verify(const unsigned char *msg, size_t msglen,
+                                     const unsigned char pubkey[32], const unsigned char sig[64]);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* NOSTR_NATIVE_H */

package/dist/index.d.mts

@@ -0,0 +1,15 @@
+import { SerializedEventVerifier, SigningBackend } from "@qntx/nostr/core";
+//#region src/index.d.ts
+/**
+ * `SerializedEventVerifier` backed by native libsecp256k1 — plug into `createEventVerifier` from
+ * `@qntx/nostr/core`. The Nitro hybrid object is created once at module load.
+ */
+export declare const verifySerialized: SerializedEventVerifier;
+/**
+ * `SigningBackend` backed by native libsecp256k1 — plug into `Keys.fromSecretKey(secretKey,
+ * signing)` or `Keys.generate(signing)` so signing runs on the same randomized context as
+ * verification. Throws on an invalid secret key or wrong-length input.
+ */
+export declare const signing: SigningBackend;
+//#endregion
+//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -0,0 +1,26 @@
+import { NitroModules } from "react-native-nitro-modules";
+//#region src/index.ts
+const nostrNative = NitroModules.createHybridObject("NostrNative");
+function asArrayBuffer(view) {
+	const { buffer, byteOffset, byteLength } = view;
+	if (buffer instanceof ArrayBuffer && byteOffset === 0 && byteLength === buffer.byteLength) return buffer;
+	return new Uint8Array(view).buffer;
+}
+/**
+* `SerializedEventVerifier` backed by native libsecp256k1 — plug into `createEventVerifier` from
+* `@qntx/nostr/core`. The Nitro hybrid object is created once at module load.
+*/
+const verifySerialized = (serializedUtf8, id, pubkey, sig) => nostrNative.verifySerialized(asArrayBuffer(serializedUtf8), asArrayBuffer(id), asArrayBuffer(pubkey), asArrayBuffer(sig));
+/**
+* `SigningBackend` backed by native libsecp256k1 — plug into `Keys.fromSecretKey(secretKey,
+* signing)` or `Keys.generate(signing)` so signing runs on the same randomized context as
+* verification. Throws on an invalid secret key or wrong-length input.
+*/
+const signing = {
+	publicKey: (secretKey) => new Uint8Array(nostrNative.publicKey(asArrayBuffer(secretKey))),
+	sign: (id, secretKey, auxRand) => new Uint8Array(nostrNative.sign(asArrayBuffer(id), asArrayBuffer(secretKey), asArrayBuffer(auxRand)))
+};
+//#endregion
+export { signing, verifySerialized };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["import { NitroModules } from \"react-native-nitro-modules\";\n\nimport type { SerializedEventVerifier, SigningBackend } from \"@qntx/nostr/core\";\n\nimport type { NostrNative } from \"./specs/nostr-native.nitro.ts\";\n\nconst nostrNative = NitroModules.createHybridObject<NostrNative>(\"NostrNative\");\n\nfunction asArrayBuffer(view: Uint8Array): ArrayBuffer {\n  const { buffer, byteOffset, byteLength } = view;\n  if (buffer instanceof ArrayBuffer && byteOffset === 0 && byteLength === buffer.byteLength) {\n    return buffer;\n  }\n  return new Uint8Array(view).buffer;\n}\n\n/**\n * `SerializedEventVerifier` backed by native libsecp256k1 — plug into `createEventVerifier` from\n * `@qntx/nostr/core`. The Nitro hybrid object is created once at module load.\n */\nexport const verifySerialized: SerializedEventVerifier = (serializedUtf8, id, pubkey, sig) =>\n  nostrNative.verifySerialized(\n    asArrayBuffer(serializedUtf8),\n    asArrayBuffer(id),\n    asArrayBuffer(pubkey),\n    asArrayBuffer(sig),\n  );\n\n/**\n * `SigningBackend` backed by native libsecp256k1 — plug into `Keys.fromSecretKey(secretKey,\n * signing)` or `Keys.generate(signing)` so signing runs on the same randomized context as\n * verification. Throws on an invalid secret key or wrong-length input.\n */\nexport const signing: SigningBackend = {\n  publicKey: (secretKey) => new Uint8Array(nostrNative.publicKey(asArrayBuffer(secretKey))),\n  sign: (id, secretKey, auxRand) =>\n    new Uint8Array(\n      nostrNative.sign(asArrayBuffer(id), asArrayBuffer(secretKey), asArrayBuffer(auxRand)),\n    ),\n};\n"],"mappings":";;AAMA,MAAM,cAAc,aAAa,mBAAgC,aAAa;AAE9E,SAAS,cAAc,MAA+B;CACpD,MAAM,EAAE,QAAQ,YAAY,eAAe;CAC3C,IAAI,kBAAkB,eAAe,eAAe,KAAK,eAAe,OAAO,YAC7E,OAAO;CAET,OAAO,IAAI,WAAW,IAAI,CAAC,CAAC;AAC9B;;;;;AAMA,MAAa,oBAA6C,gBAAgB,IAAI,QAAQ,QACpF,YAAY,iBACV,cAAc,cAAc,GAC5B,cAAc,EAAE,GAChB,cAAc,MAAM,GACpB,cAAc,GAAG,CACnB;;;;;;AAOF,MAAa,UAA0B;CACrC,YAAY,cAAc,IAAI,WAAW,YAAY,UAAU,cAAc,SAAS,CAAC,CAAC;CACxF,OAAO,IAAI,WAAW,YACpB,IAAI,WACF,YAAY,KAAK,cAAc,EAAE,GAAG,cAAc,SAAS,GAAG,cAAc,OAAO,CAAC,CACtF;AACJ"}

package/nitro.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "https://nitro.margelo.com/nitro.schema.json",
+  "cxxNamespace": ["nostrnative"],
+  "ios": {
+    "iosModuleName": "NostrNative"
+  },
+  "android": {
+    "androidNamespace": ["nostrnative"],
+    "androidCxxLibName": "NostrNative"
+  },
+  "autolinking": {
+    "NostrNative": {
+      "all": {
+        "language": "c++",
+        "implementationClassName": "HybridNostrNative"
+      }
+    }
+  }
+}

package/nitrogen/generated/.gitattributes

@@ -0,0 +1 @@
+** linguist-generated=true

package/nitrogen/generated/android/NostrNative+autolinking.cmake

@@ -0,0 +1,81 @@
+#
+# NostrNative+autolinking.cmake
+# This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+# https://github.com/mrousavy/nitro
+# Copyright © Marc Rousavy @ Margelo
+#
+
+# This is a CMake file that adds all files generated by Nitrogen
+# to the current CMake project.
+#
+# To use it, add this to your CMakeLists.txt:
+# ```cmake
+# include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/NostrNative+autolinking.cmake)
+# ```
+
+# Define a flag to check if we are building properly
+add_definitions(-DBUILDING_NOSTRNATIVE_WITH_GENERATED_CMAKE_PROJECT)
+
+# Enable Raw Props parsing in react-native (for Nitro Views)
+add_definitions(-DRN_SERIALIZABLE_STATE)
+
+# Add all headers that were generated by Nitrogen
+include_directories(
+  "../nitrogen/generated/shared/c++"
+  "../nitrogen/generated/android/c++"
+  "../nitrogen/generated/android/"
+)
+
+# Add all .cpp sources that were generated by Nitrogen
+target_sources(
+  # CMake project name (Android C++ library name)
+  NostrNative PRIVATE
+  # Autolinking Setup
+  ../nitrogen/generated/android/NostrNativeOnLoad.cpp
+  # Shared Nitrogen C++ sources
+  ../nitrogen/generated/shared/c++/HybridNostrNativeSpec.cpp
+  # Android-specific Nitrogen C++ sources
+  
+)
+
+# From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake
+# Used in node_modules/react-native/ReactAndroid/cmake-utils/ReactNative-application.cmake
+target_compile_definitions(
+  NostrNative PRIVATE
+  -DFOLLY_NO_CONFIG=1
+  -DFOLLY_HAVE_CLOCK_GETTIME=1
+  -DFOLLY_USE_LIBCPP=1
+  -DFOLLY_CFG_NO_COROUTINES=1
+  -DFOLLY_MOBILE=1
+  -DFOLLY_HAVE_RECVMMSG=1
+  -DFOLLY_HAVE_PTHREAD=1
+  # Once we target android-23 above, we can comment
+  # the following line. NDK uses GNU style stderror_r() after API 23.
+  -DFOLLY_HAVE_XSI_STRERROR_R=1
+)
+
+# Add all libraries required by the generated specs
+find_package(fbjni REQUIRED) # <-- Used for communication between Java <-> C++
+find_package(ReactAndroid REQUIRED) # <-- Used to set up React Native bindings (e.g. CallInvoker/TurboModule)
+find_package(react-native-nitro-modules REQUIRED) # <-- Used to create all HybridObjects and use the Nitro core library
+
+# Link all libraries together
+target_link_libraries(
+        NostrNative
+        fbjni::fbjni                              # <-- Facebook C++ JNI helpers
+        ReactAndroid::jsi                         # <-- RN: JSI
+        react-native-nitro-modules::NitroModules  # <-- NitroModules Core :)
+)
+
+# Link react-native (different prefab between RN 0.75 and RN 0.76)
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+    target_link_libraries(
+        NostrNative
+        ReactAndroid::reactnative                 # <-- RN: Native Modules umbrella prefab
+    )
+else()
+    target_link_libraries(
+        NostrNative
+        ReactAndroid::react_nativemodule_core     # <-- RN: TurboModules Core
+    )
+endif()

package/nitrogen/generated/android/NostrNative+autolinking.gradle

@@ -0,0 +1,27 @@
+///
+/// NostrNative+autolinking.gradle
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/// This is a Gradle file that adds all files generated by Nitrogen
+/// to the current Gradle project.
+///
+/// To use it, add this to your build.gradle:
+/// ```gradle
+/// apply from: '../nitrogen/generated/android/NostrNative+autolinking.gradle'
+/// ```
+
+logger.warn("[NitroModules] 🔥 NostrNative is boosted by nitro!")
+
+android {
+  sourceSets {
+    main {
+      java.srcDirs += [
+        // Nitrogen files
+        "${project.projectDir}/../nitrogen/generated/android/kotlin"
+      ]
+    }
+  }
+}

package/nitrogen/generated/android/NostrNativeOnLoad.cpp

@@ -0,0 +1,49 @@
+///
+/// NostrNativeOnLoad.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#ifndef BUILDING_NOSTRNATIVE_WITH_GENERATED_CMAKE_PROJECT
+#error NostrNativeOnLoad.cpp is not being built with the autogenerated CMakeLists.txt project. Is a different CMakeLists.txt building this?
+#endif
+
+#include "NostrNativeOnLoad.hpp"
+
+#include <jni.h>
+#include <fbjni/fbjni.h>
+#include <NitroModules/HybridObjectRegistry.hpp>
+
+#include "HybridNostrNative.hpp"
+
+namespace margelo::nitro::nostrnative {
+
+int initialize(JavaVM* vm) {
+  return facebook::jni::initialize(vm, []() {
+    ::margelo::nitro::nostrnative::registerAllNatives();
+  });
+}
+
+
+
+void registerAllNatives() {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::nostrnative;
+
+  // Register native JNI methods
+  
+
+  // Register Nitro Hybrid Objects
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "NostrNative",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridNostrNative>,
+                    "The HybridObject \"HybridNostrNative\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridNostrNative>();
+    }
+  );
+}
+
+} // namespace margelo::nitro::nostrnative

package/nitrogen/generated/android/NostrNativeOnLoad.hpp

@@ -0,0 +1,34 @@
+///
+/// NostrNativeOnLoad.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <jni.h>
+#include <functional>
+#include <NitroModules/NitroDefines.hpp>
+
+namespace margelo::nitro::nostrnative {
+
+  [[deprecated("Use registerNatives() instead.")]]
+  int initialize(JavaVM* vm);
+
+  /**
+   * Register the native (C++) part of NostrNative, and autolinks all Hybrid Objects.
+   * Call this in your `JNI_OnLoad` function (probably inside `cpp-adapter.cpp`),
+   * inside a `facebook::jni::initialize(vm, ...)` call.
+   * Example:
+   * ```cpp (cpp-adapter.cpp)
+   * JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+   *   return facebook::jni::initialize(vm, []() {
+   *     // register all NostrNative HybridObjects
+   *     margelo::nitro::nostrnative::registerNatives();
+   *     // any other custom registrations go here.
+   *   });
+   * }
+   * ```
+   */
+  void registerAllNatives();
+
+} // namespace margelo::nitro::nostrnative

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nostrnative/NostrNativeOnLoad.kt

@@ -0,0 +1,35 @@
+///
+/// NostrNativeOnLoad.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.nostrnative
+
+import android.util.Log
+
+internal class NostrNativeOnLoad {
+  companion object {
+    private const val TAG = "NostrNativeOnLoad"
+    private var didLoad = false
+    /**
+     * Initializes the native part of "NostrNative".
+     * This method is idempotent and can be called more than once.
+     */
+    @JvmStatic
+    fun initializeNative() {
+      if (didLoad) return
+      try {
+        Log.i(TAG, "Loading NostrNative C++ library...")
+        System.loadLibrary("NostrNative")
+        Log.i(TAG, "Successfully loaded NostrNative C++ library!")
+        didLoad = true
+      } catch (e: Error) {
+        Log.e(TAG, "Failed to load NostrNative C++ library! Is it properly installed and linked? " +
+                    "Is the name correct? (see `CMakeLists.txt`, at `add_library(...)`)", e)
+        throw e
+      }
+    }
+  }
+}

package/nitrogen/generated/ios/NostrNative+autolinking.rb

@@ -0,0 +1,62 @@
+#
+# NostrNative+autolinking.rb
+# This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+# https://github.com/mrousavy/nitro
+# Copyright © Marc Rousavy @ Margelo
+#
+
+# This is a Ruby script that adds all files generated by Nitrogen
+# to the given podspec.
+#
+# To use it, add this to your .podspec:
+# ```ruby
+# Pod::Spec.new do |spec|
+#   # ...
+#
+#   # Add all files generated by Nitrogen
+#   load 'nitrogen/generated/ios/NostrNative+autolinking.rb'
+#   add_nitrogen_files(spec)
+# end
+# ```
+
+def add_nitrogen_files(spec)
+  Pod::UI.puts "[NitroModules] 🔥 NostrNative is boosted by nitro!"
+
+  spec.dependency "NitroModules"
+
+  current_source_files = Array(spec.attributes_hash['source_files'])
+  spec.source_files = current_source_files + [
+    # Generated cross-platform specs
+    "nitrogen/generated/shared/**/*.{h,hpp,c,cpp,swift}",
+    # Generated bridges for the cross-platform specs
+    "nitrogen/generated/ios/**/*.{h,hpp,c,cpp,mm,swift}",
+  ]
+
+  current_public_header_files = Array(spec.attributes_hash['public_header_files'])
+  spec.public_header_files = current_public_header_files + [
+    # Generated specs
+    "nitrogen/generated/shared/**/*.{h,hpp}",
+    # Swift to C++ bridging helpers
+    "nitrogen/generated/ios/NostrNative-Swift-Cxx-Bridge.hpp"
+  ]
+
+  current_private_header_files = Array(spec.attributes_hash['private_header_files'])
+  spec.private_header_files = current_private_header_files + [
+    # iOS specific specs
+    "nitrogen/generated/ios/c++/**/*.{h,hpp}",
+    # Views are framework-specific and should be private
+    "nitrogen/generated/shared/**/views/**/*"
+  ]
+
+  current_pod_target_xcconfig = spec.attributes_hash['pod_target_xcconfig'] || {}
+  spec.pod_target_xcconfig = current_pod_target_xcconfig.merge({
+    # Use C++ 20
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+    # Enables C++ <-> Swift interop (by default it's only ObjC)
+    "SWIFT_OBJC_INTEROP_MODE" => "objcxx",
+    # Enables stricter modular headers
+    "DEFINES_MODULE" => "YES",
+    # Disable auto-generated ObjC header for Swift (Static linkage on Xcode 26.4 breaks here)
+    "SWIFT_INSTALL_OBJC_HEADER" => "NO",
+  })
+end