monero-native 0.0.1

package/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "monero-native",
+  "version": "0.0.1",
+  "description": "Native Monero wallet library for React Native and Node.js",
+  "homepage": "https://github.com/EdgeApp/monero-native",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:EdgeApp/monero-native.git"
+  },
+  "license": "BSD-3-Clause",
+  "author": "Airbitz Inc dba Edge",
+  "main": "lib/src/index.js",
+  "types": "lib/src/index.d.ts",
+  "files": [
+    "/android/build.gradle",
+    "/android/src/",
+    "/CHANGELOG.md",
+    "/ios/",
+    "/lib/src/",
+    "/LICENSE",
+    "/monero-native.podspec",
+    "/node.d.ts",
+    "/node.js",
+    "/package.json",
+    "/prebuilds/",
+    "/README.md",
+    "/src/monero-wrapper/monero-methods.hpp",
+    "/src/node/",
+    "!/android/src/main/jniLibs/armeabi-v7a"
+  ],
+  "lint-staged": {
+    "*.{js,ts}": "eslint"
+  },
+  "scripts": {
+    "build-native": "ZERO_AR_DATE=1 node -r sucrase/register ./scripts/build-native.ts",
+    "build-native-arm64": "ZERO_AR_DATE=1 node -r sucrase/register ./scripts/build-native.ts default-arm64",
+    "build-native-host": "ZERO_AR_DATE=1 node -r sucrase/register ./scripts/build-native-host.ts host",
+    "clean": "npm run clean:js && rm -rf tmp android/src/main/jniLibs ios/MoneroModule.xcframework",
+    "clean:js": "rm -rf node_modules lib",
+    "fix": "npm run lint -- --fix",
+    "lint": "eslint .",
+    "precommit": "npm run lint",
+    "prepare": "husky && rimraf lib && tsc",
+    "prepublishOnly": "npm run build-native-arm64 && npm run build-native-host",
+    "smoke-node": "node -r sucrase/register ./scripts/smoke-node.ts"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.0",
+    "eslint": "^9.39.1",
+    "eslint-config-standard-kit": "^1.0.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.6",
+    "prettier": "^3.6.2",
+    "rimraf": "^6.1.0",
+    "sucrase": "^3.35.0",
+    "typescript": "^5.9.3",
+    "node-gyp": "^11.4.2"
+  },
+  "dependencies": {
+    "cleaners": "^0.3.17",
+    "node-addon-api": "^8.5.0"
+  },
+  "peerDependencies": {
+    "react-native": ">=0.47.0 <1.0.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./lib/src/index.d.ts",
+      "react-native": "./lib/src/index.js",
+      "default": "./lib/src/index.js"
+    },
+    "./node": {
+      "types": "./lib/src/node.d.ts",
+      "default": "./lib/src/node.js"
+    },
+    "./package.json": "./package.json",
+    "./lib/src/CppBridge": {
+      "types": "./lib/src/CppBridge.d.ts",
+      "default": "./lib/src/CppBridge.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "node": [
+        "lib/src/node.d.ts"
+      ]
+    }
+  },
+  "peerDependenciesMeta": {
+    "react-native": {
+      "optional": true
+    }
+  }
+}

package/src/monero-wrapper/monero-methods.hpp

@@ -0,0 +1,25 @@
+#ifndef MONERO_METHODS_HPP_INCLUDED
+#define MONERO_METHODS_HPP_INCLUDED
+
+#include <string>
+#include <vector>
+#include <functional>
+#include <mutex>
+
+struct MoneroMethod {
+  const char *name;
+  int argc;
+  std::string (*method)(const std::vector<std::string> &args);
+};
+extern const MoneroMethod moneroMethods[];
+extern const unsigned moneroMethodCount;
+
+// Callback type for wallet events (walletId, eventName, jsonPayload)
+using WalletEventCallback = std::function<void(
+  const std::string&, const std::string&, const std::string&)>;
+
+// Set the global callback invoked by WalletListener on the SDK refresh thread.
+// Thread-safe: the callback is guarded by a mutex.
+void moneroSetEventCallback(WalletEventCallback cb);
+
+#endif

package/src/node/monero-napi.cpp

@@ -0,0 +1,248 @@
+#include <napi.h>
+
+#include "monero-methods.hpp"
+
+#include <condition_variable>
+#include <functional>
+#include <mutex>
+#include <queue>
+#include <stdexcept>
+#include <string>
+#include <thread>
+#include <utility>
+#include <vector>
+
+namespace {
+
+struct Job {
+  std::string method;
+  std::vector<std::string> args;
+  std::function<void(std::string result, std::string error)> complete;
+};
+
+class SerialExecutor {
+ public:
+  SerialExecutor() { thread_ = std::thread([this] { run(); }); }
+
+  ~SerialExecutor() {
+    {
+      std::lock_guard<std::mutex> lock(mu_);
+      stop_ = true;
+    }
+    cv_.notify_all();
+    if (thread_.joinable()) thread_.join();
+  }
+
+  void enqueue(Job job) {
+    {
+      std::lock_guard<std::mutex> lock(mu_);
+      jobs_.push(std::move(job));
+    }
+    cv_.notify_one();
+  }
+
+ private:
+  static std::string dispatch(
+    const std::string &method,
+    const std::vector<std::string> &args
+  ) {
+    for (unsigned i = 0; i < moneroMethodCount; ++i) {
+      if (moneroMethods[i].name != method) continue;
+      if (
+        moneroMethods[i].argc != -1 &&
+        static_cast<int>(args.size()) != moneroMethods[i].argc
+      ) {
+        throw std::runtime_error("monero incorrect C++ argument count");
+      }
+      return moneroMethods[i].method(args);
+    }
+    throw std::runtime_error("No monero C++ method " + method);
+  }
+
+  void run() {
+    while (true) {
+      Job job;
+      {
+        std::unique_lock<std::mutex> lock(mu_);
+        cv_.wait(lock, [&] { return stop_ || !jobs_.empty(); });
+        if (stop_ && jobs_.empty()) return;
+        job = std::move(jobs_.front());
+        jobs_.pop();
+      }
+      try {
+        job.complete(dispatch(job.method, job.args), "");
+      } catch (const std::exception &e) {
+        job.complete("", e.what());
+      } catch (...) {
+        job.complete("", "monero threw a C++ exception");
+      }
+    }
+  }
+
+  std::mutex mu_;
+  std::condition_variable cv_;
+  std::queue<Job> jobs_;
+  std::thread thread_;
+  bool stop_ = false;
+};
+
+SerialExecutor *g_mainQueue = nullptr;
+SerialExecutor *g_nymQueue = nullptr;
+Napi::ThreadSafeFunction *g_eventTsfn = nullptr;
+std::mutex g_eventTsfnMutex;
+
+bool isNymCompletionMethod(const std::string &method) {
+  return method == "resolveFetch" || method == "rejectFetch";
+}
+
+struct CallResult {
+  Napi::Promise::Deferred deferred;
+  std::string value;
+  std::string error;
+  Napi::ThreadSafeFunction tsfn;
+
+  CallResult(Napi::Promise::Deferred deferred_, Napi::ThreadSafeFunction tsfn_)
+    : deferred(deferred_), tsfn(tsfn_) {}
+};
+
+struct EventPayload {
+  std::string walletId;
+  std::string eventName;
+  std::string data;
+};
+
+} // namespace
+
+static Napi::Value CallMonero(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 2 || !info[0].IsString() || !info[1].IsArray()) {
+    Napi::TypeError::New(env, "callMonero(method, string[]) expected")
+      .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  const std::string method = info[0].As<Napi::String>().Utf8Value();
+  const Napi::Array arr = info[1].As<Napi::Array>();
+  std::vector<std::string> args;
+  args.reserve(arr.Length());
+  for (uint32_t i = 0; i < arr.Length(); ++i) {
+    Napi::Value value = arr.Get(i);
+    if (!value.IsString()) {
+      Napi::TypeError::New(env, "callMonero arguments must be strings")
+        .ThrowAsJavaScriptException();
+      return env.Undefined();
+    }
+    args.push_back(value.As<Napi::String>().Utf8Value());
+  }
+
+  auto deferred = Napi::Promise::Deferred::New(env);
+  Napi::ThreadSafeFunction tsfn = Napi::ThreadSafeFunction::New(
+    env,
+    Napi::Function::New(env, [](const Napi::CallbackInfo &) {}),
+    "monero-call-complete",
+    0,
+    1
+  );
+
+  auto *result = new CallResult(deferred, tsfn);
+  SerialExecutor *queue =
+    isNymCompletionMethod(method) ? g_nymQueue : g_mainQueue;
+
+  queue->enqueue(
+    Job{
+      method,
+      std::move(args),
+      [result](std::string value, std::string error) {
+        result->value = std::move(value);
+        result->error = std::move(error);
+        result->tsfn.BlockingCall(result, [](Napi::Env env, Napi::Function, CallResult *r) {
+          if (r->error.empty()) {
+            r->deferred.Resolve(Napi::String::New(env, r->value));
+          } else {
+            r->deferred.Reject(Napi::Error::New(env, r->error).Value());
+          }
+          r->tsfn.Release();
+          delete r;
+        });
+      }
+    }
+  );
+
+  return deferred.Promise();
+}
+
+static Napi::Value GetMethodNames(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+  Napi::Array out = Napi::Array::New(env, moneroMethodCount);
+  for (unsigned i = 0; i < moneroMethodCount; ++i) {
+    out.Set(i, Napi::String::New(env, moneroMethods[i].name));
+  }
+  return out;
+}
+
+static Napi::Value SetEventListener(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 1 || !info[0].IsFunction()) {
+    Napi::TypeError::New(env, "setEventListener(fn) expected")
+      .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  std::lock_guard<std::mutex> lock(g_eventTsfnMutex);
+  if (g_eventTsfn != nullptr) {
+    g_eventTsfn->Abort();
+    g_eventTsfn->Release();
+    delete g_eventTsfn;
+    g_eventTsfn = nullptr;
+  }
+  g_eventTsfn = new Napi::ThreadSafeFunction(
+    Napi::ThreadSafeFunction::New(
+      env,
+      info[0].As<Napi::Function>(),
+      "monero-wallet-event",
+      0,
+      1
+    )
+  );
+  g_eventTsfn->Unref(env);
+  return env.Undefined();
+}
+
+static Napi::Object Init(Napi::Env env, Napi::Object exports) {
+  if (g_mainQueue == nullptr) g_mainQueue = new SerialExecutor();
+  if (g_nymQueue == nullptr) g_nymQueue = new SerialExecutor();
+
+  moneroSetEventCallback(
+    [](
+      const std::string &walletId,
+      const std::string &eventName,
+      const std::string &jsonPayload
+    ) {
+      auto *payload = new EventPayload{walletId, eventName, jsonPayload};
+      std::lock_guard<std::mutex> lock(g_eventTsfnMutex);
+      if (g_eventTsfn == nullptr) {
+        delete payload;
+        return;
+      }
+      napi_status status = g_eventTsfn->NonBlockingCall(
+        payload,
+        [](Napi::Env env, Napi::Function jsCallback, EventPayload *p) {
+          jsCallback.Call(
+            {Napi::String::New(env, p->walletId),
+             Napi::String::New(env, p->eventName),
+             Napi::String::New(env, p->data)}
+          );
+          delete p;
+        }
+      );
+      if (status != napi_ok) delete payload;
+    }
+  );
+
+  exports.Set("callMonero", Napi::Function::New(env, CallMonero));
+  exports.Set("methodNames", Napi::Function::New(env, GetMethodNames));
+  exports.Set("setEventListener", Napi::Function::New(env, SetEventListener));
+  return exports;
+}
+
+NODE_API_MODULE(monero, Init)