@qntx/wallet-native 0.0.0-stage → 0.4.0

package/nitrogen/generated/shared/c++/KernelExitReason.hpp

@@ -0,0 +1,84 @@
+///
+/// KernelExitReason.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::qntxwallet {
+
+  /**
+   * An enum which can be represented as a JavaScript union (KernelExitReason).
+   */
+  enum class KernelExitReason {
+    LOCKED      SWIFT_NAME(locked) = 0,
+    CRASHED      SWIFT_NAME(crashed) = 1,
+    INTEGRITY      SWIFT_NAME(integrity) = 2,
+    BACKGROUND      SWIFT_NAME(background) = 3,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::qntxwallet
+
+namespace margelo::nitro {
+
+  // C++ KernelExitReason <> JS KernelExitReason (union)
+  template <>
+  struct JSIConverter<margelo::nitro::qntxwallet::KernelExitReason> final {
+    static inline margelo::nitro::qntxwallet::KernelExitReason fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("locked"): return margelo::nitro::qntxwallet::KernelExitReason::LOCKED;
+        case hashString("crashed"): return margelo::nitro::qntxwallet::KernelExitReason::CRASHED;
+        case hashString("integrity"): return margelo::nitro::qntxwallet::KernelExitReason::INTEGRITY;
+        case hashString("background"): return margelo::nitro::qntxwallet::KernelExitReason::BACKGROUND;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum KernelExitReason - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::qntxwallet::KernelExitReason arg) {
+      switch (arg) {
+        case margelo::nitro::qntxwallet::KernelExitReason::LOCKED: return JSIConverter<std::string>::toJSI(runtime, "locked");
+        case margelo::nitro::qntxwallet::KernelExitReason::CRASHED: return JSIConverter<std::string>::toJSI(runtime, "crashed");
+        case margelo::nitro::qntxwallet::KernelExitReason::INTEGRITY: return JSIConverter<std::string>::toJSI(runtime, "integrity");
+        case margelo::nitro::qntxwallet::KernelExitReason::BACKGROUND: return JSIConverter<std::string>::toJSI(runtime, "background");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert KernelExitReason to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("locked"):
+        case hashString("crashed"):
+        case hashString("integrity"):
+        case hashString("background"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

package/package.json

@@ -1,6 +1,63 @@
 {
   "name": "@qntx/wallet-native",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.4.0",
+  "description": "Native kernel runtime host for the qntx wallet — CBOR transport, KernelHost adapter and createNativeWallet",
+  "license": "MIT OR Apache-2.0",
+  "author": "QuantX <x@qntx.org>",
+  "files": [
+    "dist",
+    "cpp",
+    "android",
+    "kernel/generated",
+    "nitrogen",
+    "scripts",
+    "react-native.config.js",
+    "WalletNative.podspec",
+    "!android/build",
+    "!android/.cxx",
+    "!**/.gradle",
+    "!tests"
+  ],
+  "type": "module",
+  "main": "dist/index.mjs",
+  "types": "dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "test": "vp test",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "codegen": "nitrogen",
+    "check:pkg": "vp pack && bun ../../scripts/check-dist-deps.ts . && publint && attw --pack . --profile esm-only && bun ../../scripts/check-native-pack.ts ."
+  },
+  "dependencies": {
+    "cborg": "6.1.4"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "0.18.5",
+    "@qntx/nostr": "0.15.3",
+    "@qntx/nostr-native": "0.15.3",
+    "@qntx/spark": "0.5.2",
+    "@qntx/spark-native": "0.5.2",
+    "@qntx/tsconfig": "1.0.1",
+    "@scure/base": "2.4.0",
+    "nitrogen": "0.37.1",
+    "publint": "0.3.25",
+    "react-native-nitro-modules": "0.37.1"
+  },
+  "peerDependencies": {
+    "@qntx/nostr-native": "0.15.3",
+    "@qntx/spark-native": "0.5.2",
+    "@qntx/wallet": "0.4.0",
+    "react-native": "~0.88.0",
+    "react-native-nitro-modules": "~0.37.1"
+  }
+}

package/react-native.config.js

@@ -0,0 +1,14 @@
+// oxlint-disable import/no-commonjs, unicorn/prefer-module -- the RN CLI loads
+// react-native.config.js via require; CJS is the required format.
+
+// https://github.com/react-native-community/cli/blob/main/docs/dependencies.md
+module.exports = {
+  dependency: {
+    platforms: {
+      /** @type {import("@react-native-community/cli-types").IOSDependencyParams} */
+      ios: {},
+      /** @type {import("@react-native-community/cli-types").AndroidDependencyParams} */
+      android: {},
+    },
+  },
+};

package/scripts/compile-kernel.mjs

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+/**
+ * Compile the shipped kernel bundle to Hermes bytecode with the consuming app's own hermesc,
+ * resolved through its installed react-native → hermes-compiler. Hermes only loads its own bytecode
+ * version, so the bytecode is compiled at the app's native build time, never shipped.
+ *
+ * Usage: node compile-kernel.mjs <outDir> Emits <outDir>/kernel.hpp (KERNEL_BYTECODE /
+ * KERNEL_BYTECODE_SIZE), rewritten only when the content changes so incremental builds do not
+ * recompile C++.
+ */
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const { 2: outDirArg, 3: reactNativeDir } = process.argv;
+if (
+  outDirArg === undefined ||
+  outDirArg === "" ||
+  reactNativeDir === undefined ||
+  reactNativeDir === ""
+) {
+  console.error("usage: node compile-kernel.mjs <outDir> <reactNativeDir>");
+  process.exit(2);
+}
+const outDir = resolve(outDirArg);
+const packageDir = fileURLToPath(new URL("..", import.meta.url));
+const generated = resolve(packageDir, "kernel", "generated");
+const entry = resolve(generated, "kernel-entry.js");
+const manifestPath = resolve(generated, "kernel.manifest.json");
+
+// The manifest's bundle SHA is the contract: a tampered or stale bundle must
+// fail the native build instead of shipping a kernel nobody recorded.
+/**
+ * @param {unknown} value
+ * @returns {value is { bundles?: { file: string; sha256: string }[] }}
+ */
+function isManifest(value) {
+  return typeof value === "object" && value !== null && "bundles" in value;
+}
+const parsed = /** @type {unknown} */ (JSON.parse(readFileSync(manifestPath, "utf8")));
+if (!isManifest(parsed)) {
+  console.error("kernel.manifest.json: expected an object with a bundles field");
+  process.exit(1);
+}
+const declared = parsed.bundles?.find((b) => b.file === "kernel-entry.js")?.sha256;
+const actual = createHash("sha256").update(readFileSync(entry)).digest("hex");
+if (typeof declared !== "string" || declared !== actual) {
+  console.error(
+    `kernel-entry.js sha256 mismatch: kernel.manifest.json declares ` +
+      `${declared ?? "<missing>"}, the bundle hashes ${actual} — ` +
+      `run bun run native:kernel and commit both artifacts`,
+  );
+  process.exit(1);
+}
+
+// Resolve through the app's own react-native so the hermesc version matches the
+// Hermes runtime the app links — the entire reason bytecode is compiled here.
+// The app's react-native root is passed explicitly by the build system — a
+// package has no reliable way to resolve it from its own tree (the package may
+// be built from its source dir via :path or a file: install).
+const rnPkg = resolve(reactNativeDir, "package.json");
+const requireFromRn = createRequire(rnPkg);
+const hermesPkg = requireFromRn.resolve("hermes-compiler/package.json");
+const platformDir =
+  process.platform === "darwin"
+    ? "osx-bin"
+    : process.platform === "linux"
+      ? "linux64-bin"
+      : "win64-bin";
+const hermesc = resolve(
+  dirname(hermesPkg),
+  "hermesc",
+  platformDir,
+  process.platform === "win32" ? "hermesc.exe" : "hermesc",
+);
+
+mkdirSync(outDir, { recursive: true });
+const tmpHbc = resolve(outDir, ".kernel.hbc");
+try {
+  execFileSync(hermesc, ["-O", "-emit-async-break-check", "-emit-binary", "-out", tmpHbc, entry], {
+    stdio: ["ignore", "pipe", "inherit"],
+  });
+} catch (error) {
+  console.error(
+    `hermesc failed on ${entry}: ${error instanceof Error ? error.message : String(error)}`,
+  );
+  process.exit(1);
+}
+const bytes = readFileSync(tmpHbc);
+rmSync(tmpHbc);
+
+const body = [
+  "// Generated by scripts/compile-kernel.mjs — do not edit.",
+  "#pragma once",
+  "",
+  "#include <cstdint>",
+  "#include <cstddef>",
+  "",
+  "namespace qntx {",
+  "inline constexpr uint8_t KERNEL_BYTECODE[] = {",
+];
+for (let i = 0; i < bytes.length; i += 16) {
+  const chunk = [...bytes.subarray(i, i + 16)]
+    .map((b) => `0x${b.toString(16).padStart(2, "0")}`)
+    .join(",");
+  body.push(`  ${chunk}${i + 16 < bytes.length ? "," : ""}`);
+}
+body.push("};", `inline constexpr size_t KERNEL_BYTECODE_SIZE = ${bytes.length};`, "}");
+
+const header = `${body.join("\n")}\n`;
+const headerPath = resolve(outDir, "kernel.hpp");
+if (!existsSync(headerPath) || readFileSync(headerPath, "utf8") !== header) {
+  writeFileSync(headerPath, header);
+}
+console.log(`kernel.hpp: ${bytes.length} bytes compiled`);