react-native-monero 0.0.1 → 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# react-native-monero
+
+## Unreleased
+
+## 0.2.0 (2026-06-29)
+
+- changed: Switch the package manager from yarn to npm (package-lock.json + `.npmrc` legacy-peer-deps), matching the other Edge currency repos.
+- fixed: Monero Full Node (monerod) wallets now sync, calculate max, and send when the Nym mixnet is enabled. The Nym HTTP client rebuilt request URLs from an unreliable SSL flag and emitted `http://` on port 443, so every monerod RPC failed under Nym while the same wallet worked with Nym off. Derive the scheme from the daemon address (and treat port 443 as https).
+- fixed: `getWalletStatus` now reads the live wallet balance on every call instead of only recomputing it when the synced block height changes, so a pending incoming transaction (or pending change after a send) is reflected immediately rather than after the next block.
+
+## 0.1.0 (2026-06-15)
+
+- Initial release

package/README.md

@@ -1,4 +1,4 @@
-# react-native-monero-lwsf
+# react-native-monero
 
 This library packages Monero C++ client for use on React Native.
 
@@ -14,7 +14,7 @@ First, add this library to your React Native app using NPM or Yarn, and run `pod
 Here is a simple usage example:
 
 ```js
-import { what } from 'react-native-monero-lwsf'
+import { what } from 'react-native-monero'
 
 // ???
 ```
@@ -33,7 +33,7 @@ This script does the following tasks:
 - Compile shared libraries for Android.
 - Compile an iOS universal static library and put it into an XCFramework.
 
-The `build-native` script is also the place to make edits when upgrading any of the third-party dependencies. The react-native-monero-lwsf repo doesn't include these third-party C++ sources, since they are enormous.
+The `build-native` script is also the place to make edits when upgrading any of the third-party dependencies. The react-native-monero repo doesn't include these third-party C++ sources, since they are enormous.
 
 For this to work, you need:
 

package/android/src/main/java/app/edge/rnmonero/RnMoneroModule.java

@@ -1,24 +1,36 @@
 package app.edge.rnmonero;
 
+import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 
 public class RnMoneroModule extends ReactContextBaseJavaModule {
   private native String callMoneroJNI(String method, String[] arguments);
 
   private native String[] getMethodNames();
 
+  // Sets the C++ callback so WalletListener events route through onWalletEvent
+  private native void initEventCallback();
+
+  private final ExecutorService moneroExecutor = Executors.newSingleThreadExecutor();
+  private final ExecutorService nymCompletionExecutor = Executors.newSingleThreadExecutor();
+
   static {
     System.loadLibrary("rnmonero");
   }
 
   public RnMoneroModule(ReactApplicationContext reactContext) {
     super(reactContext);
+    initEventCallback();
   }
 
   @Override
@@ -42,10 +54,40 @@ public class RnMoneroModule extends ReactContextBaseJavaModule {
       strings[i] = arguments.getString(i);
     }
 
-    try {
-      promise.resolve(callMoneroJNI(method, strings));
-    } catch (Exception e) {
-      promise.reject("MoneroError", e);
-    }
+    ExecutorService executor =
+      isNymCompletionMethod(method) ? nymCompletionExecutor : moneroExecutor;
+    executor.execute(() -> {
+      try {
+        promise.resolve(callMoneroJNI(method, strings));
+      } catch (Exception e) {
+        promise.reject("MoneroError", e);
+      }
+    });
+  }
+
+  private static boolean isNymCompletionMethod(String method) {
+    return "resolveFetch".equals(method) || "rejectFetch".equals(method);
+  }
+
+  // Required by React Native NativeEventEmitter on Android
+  @ReactMethod
+  public void addListener(String eventName) {}
+
+  @ReactMethod
+  public void removeListeners(int count) {}
+
+  // Called from C++ WalletListener via JNI on the SDK refresh thread.
+  // Forwards the event to JS through RCTDeviceEventEmitter.
+  public void onWalletEvent(String walletId, String eventName, String jsonPayload) {
+    ReactApplicationContext ctx = getReactApplicationContext();
+    if (ctx == null || !ctx.hasActiveReactInstance()) return;
+
+    WritableMap params = Arguments.createMap();
+    params.putString("walletId", walletId);
+    params.putString("eventName", eventName);
+    params.putString("data", jsonPayload);
+
+    ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+       .emit("MoneroWalletEvent", params);
   }
 }

package/ios/MoneroModule.h

@@ -1,4 +1,5 @@
 #import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
 
-@interface MoneroModule : NSObject <RCTBridgeModule>
+@interface MoneroModule : RCTEventEmitter <RCTBridgeModule>
 @end

package/ios/MoneroModule.mm

@@ -1,12 +1,64 @@
 #import "MoneroModule.h"
 #include "monero-methods.hpp"
 
+@interface MoneroModule () {
+  dispatch_queue_t _moneroQueue;
+  dispatch_queue_t _nymCompletionQueue;
+}
+@end
+
+static bool isNymCompletionMethod(const std::string& method) {
+  return method == "resolveFetch" || method == "rejectFetch";
+}
+
+// Global pointer so the C++ callback can reach the ObjC module instance
+static __weak MoneroModule* g_module = nil;
+
 @implementation MoneroModule
 
-RCT_EXPORT_MODULE();
+RCT_EXPORT_MODULE(MoneroLwsfModule);
 
 + (BOOL)requiresMainQueueSetup { return NO; }
 
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    g_module = self;
+    _moneroQueue = dispatch_queue_create(
+      "app.edge.rnmonero.monero", DISPATCH_QUEUE_SERIAL);
+    _nymCompletionQueue = dispatch_queue_create(
+      "app.edge.rnmonero.nymCompletion", DISPATCH_QUEUE_SERIAL);
+
+    // Wire the C++ wallet-event callback to this module's event emitter
+    moneroSetEventCallback([](const std::string& walletId,
+                              const std::string& eventName,
+                              const std::string& jsonPayload) {
+      MoneroModule* module = g_module;
+      if (module == nil) return;
+
+      NSString *nsWalletId  = [NSString stringWithUTF8String:walletId.c_str()];
+      NSString *nsEventName = [NSString stringWithUTF8String:eventName.c_str()];
+      NSString *nsPayload   = [NSString stringWithUTF8String:jsonPayload.c_str()];
+
+      dispatch_async(dispatch_get_main_queue(), ^{
+        [module sendEventWithName:@"MoneroWalletEvent" body:@{
+          @"walletId":  nsWalletId,
+          @"eventName": nsEventName,
+          @"data":      nsPayload
+        }];
+      });
+    });
+  }
+  return self;
+}
+
+- (NSArray<NSString *> *)supportedEvents {
+  return @[@"MoneroWalletEvent"];
+}
+
+- (void)startObserving {}
+- (void)stopObserving {}
+
 RCT_REMAP_METHOD(
   callMonero,
   callMoneroMethod:(NSString *)method
@@ -18,7 +70,7 @@ RCT_REMAP_METHOD(
 
   // Re-package the arguments:
   NSUInteger length = [arguments count];
-  std::vector<const std::string> strings;
+  std::vector<std::string> strings;
   strings.reserve(length);
   for (NSUInteger i = 0; i < length; ++i) {
     NSString *string = [arguments objectAtIndex:i];
@@ -35,21 +87,26 @@ RCT_REMAP_METHOD(
       return;
     }
 
-    // Call the method, with error handling:
-    try {
-      const std::string out = moneroMethods[i].method(strings);
-      resolve(
-        [NSString stringWithCString:out.c_str() encoding:NSUTF8StringEncoding]
-      );
-    } catch (std::exception &e) {
-      reject(
-        @"Error",
-        [NSString stringWithCString:e.what() encoding:NSUTF8StringEncoding],
-        nil
-      );
-    } catch (...) {
-      reject(@"Error", @"monero threw a C++ exception", nil);
-    }
+    const MoneroMethod methodInfo = moneroMethods[i];
+    dispatch_queue_t queue =
+      isNymCompletionMethod(methodString) ? _nymCompletionQueue : _moneroQueue;
+    dispatch_async(queue, ^{
+      // Call the method, with error handling:
+      try {
+        const std::string out = methodInfo.method(strings);
+        resolve(
+          [NSString stringWithCString:out.c_str() encoding:NSUTF8StringEncoding]
+        );
+      } catch (std::exception &e) {
+        reject(
+          @"Error",
+          [NSString stringWithCString:e.what() encoding:NSUTF8StringEncoding],
+          nil
+        );
+      } catch (...) {
+        reject(@"Error", @"monero threw a C++ exception", nil);
+      }
+    });
     return;
   }
 

package/ios/MoneroModule.xcframework/Info.plist

@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>AvailableLibraries</key>
+	<array>
+		<dict>
+			<key>BinaryPath</key>
+			<string>libmonero-module.a</string>
+			<key>LibraryIdentifier</key>
+			<string>ios-arm64</string>
+			<key>LibraryPath</key>
+			<string>libmonero-module.a</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</string>
+			</array>
+			<key>SupportedPlatform</key>
+			<string>ios</string>
+		</dict>
+		<dict>
+			<key>BinaryPath</key>
+			<string>libmonero-module.a</string>
+			<key>LibraryIdentifier</key>
+			<string>ios-arm64_x86_64-simulator</string>
+			<key>LibraryPath</key>
+			<string>libmonero-module.a</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</string>
+				<string>x86_64</string>
+			</array>
+			<key>SupportedPlatform</key>
+			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
+		</dict>
+	</array>
+	<key>CFBundlePackageType</key>
+	<string>XFWK</string>
+	<key>XCFrameworkFormatVersion</key>
+	<string>1.0</string>
+</dict>
+</plist>

package/lib/src/CppBridge.d.ts

@@ -0,0 +1,158 @@
+import type { DerivedKeys, EncodeUriParams, GeneratedWallet, NetworkType, ParsedUri, Recipient, SignedTransaction, TransactionPriority, TransactionsPage, WalletBackend, WalletStatus } from './types';
+/**
+ * The shape of the native C++ module exposed to React Native.
+ *
+ * You do not normally need this, but it is accessible as
+ * `require('react-native').NativeModules.MoneroLwsfModule`.
+ *
+ * Pass this object to the `CppBridge` constructor to re-assemble the API.
+ */
+export interface NativeMoneroLwsfModule {
+    readonly callMonero: (name: string, jsonArguments: string[]) => Promise<string>;
+    readonly methodNames: string[];
+    readonly documentDirectory: string;
+}
+export declare class CppBridge {
+    private readonly module;
+    constructor(moneroLwsfModule: NativeMoneroLwsfModule);
+    /**
+     * Generate a new wallet's keys in memory (no disk I/O).
+     * @param nettype - Network type (0=mainnet, 1=testnet, 2=stagenet)
+     * @param language - Mnemonic language (e.g., "English")
+     * @returns Generated wallet with mnemonic and spend keys
+     */
+    generateWallet(nettype: NetworkType, language?: string): Promise<GeneratedWallet>;
+    /**
+     * Derive all keys from a mnemonic (no disk I/O).
+     * @param mnemonic - The 25-word mnemonic seed
+     * @param nettype - Network type (0=mainnet, 1=testnet, 2=stagenet)
+     * @returns All four keys (view and spend, public and secret)
+     */
+    seedAndKeysFromMnemonic(mnemonic: string, nettype: NetworkType): Promise<DerivedKeys>;
+    /**
+     * Get the current network blockchain height from a daemon.
+     * @param backend - Backend type ('lws' or 'monerod')
+     * @param nettype - Network type (0=mainnet, 1=testnet, 2=stagenet)
+     * @param daemonAddress - Daemon address to query
+     * @returns Current blockchain height
+     */
+    getNetworkBlockHeight(backend: WalletBackend, nettype: NetworkType, daemonAddress: string): Promise<number>;
+    /**
+     * Validate a Monero address.
+     * @param address - The address to validate
+     * @param nettype - Network type (0=mainnet, 1=testnet, 2=stagenet)
+     * @returns true if valid, false otherwise
+     */
+    isValidAddress(address: string, nettype: NetworkType): Promise<boolean>;
+    /**
+     * Open or create a wallet. If already open, returns current status.
+     * If wallet exists on disk, opens it. Otherwise creates from mnemonic.
+     * @param walletId - Unique identifier for the wallet
+     * @param backend - Backend type ("lws" or "monerod")
+     * @param mnemonic - The 25-word mnemonic seed
+     * @param nettype - Network type (0=mainnet, 1=testnet, 2=stagenet)
+     * @param restoreHeight - Block height to restore from
+     * @param daemonAddress - Daemon address to connect to
+     * @returns Current wallet status (heights and balances)
+     */
+    openWallet(walletId: string, backend: WalletBackend, mnemonic: string, password: string, nettype: NetworkType, restoreHeight: number, daemonAddress: string): Promise<WalletStatus>;
+    /**
+     * Get the current status of an open wallet.
+     * @param walletId - Unique identifier for the wallet
+     * @returns Current wallet status (heights and balances)
+     */
+    getWalletStatus(walletId: string): Promise<WalletStatus>;
+    /**
+     * Close an open wallet.
+     * @param walletId - Unique identifier for the wallet to close
+     */
+    closeWallet(walletId: string): Promise<void>;
+    /**
+     * Delete a wallet's files from disk. Closes the wallet first if it's open.
+     * @param walletId - Unique identifier for the wallet
+     * @param backend - Backend type ('lws' or 'monerod')
+     */
+    deleteWallet(walletId: string, backend: WalletBackend): Promise<void>;
+    /**
+     * Get all transactions with pagination.
+     * @param walletId - Unique identifier for the wallet
+     * @param page - Page number (0-indexed)
+     * @param pageSize - Number of transactions per page
+     * @param sort - Sort order: 'asc' (oldest first) or 'desc' (newest first), pending always at end
+     * @returns Paginated transactions with metadata
+     */
+    getAllTransactions(walletId: string, page: number, pageSize: number, sort?: 'asc' | 'desc'): Promise<TransactionsPage>;
+    /**
+     * Create a transaction (supports multiple recipients).
+     * The transaction is created and signed but not broadcast yet.
+     * @param walletId - Unique identifier for the wallet
+     * @param recipients - Array of recipients with addresses and amounts (atomic units)
+     * @param priority - Transaction priority (0=Default, 1=Low, 2=Medium, 3=High)
+     * @returns SignedTransaction with txid, signedTxHex, and fee (atomic units)
+     */
+    createTransaction(walletId: string, recipients: Recipient[], priority: TransactionPriority): Promise<SignedTransaction>;
+    /**
+     * Broadcast a previously created transaction.
+     * @param walletId - Unique identifier for the wallet
+     * @param signedTx - The signed transaction string from createTransaction
+     * @returns The transaction hash
+     * @throws Error if broadcast fails
+     */
+    broadcastTransaction(walletId: string, signedTx: string): Promise<string>;
+    /**
+     * Parse a monero: URI into its components.
+     * @param uri - The monero: URI to parse
+     * @param nettype - Network type (0=mainnet, 1=testnet, 2=stagenet)
+     * @returns Parsed URI components
+     * @throws Error if URI is invalid
+     */
+    parseUri(uri: string, nettype: NetworkType): Promise<ParsedUri>;
+    /**
+     * Encode a monero: URI from components.
+     * @param params - URI components (address, amount, etc.)
+     * @param nettype - Network type (0=mainnet, 1=testnet, 2=stagenet)
+     * @returns The encoded monero: URI
+     * @throws Error if parameters are invalid
+     */
+    encodeUri(params: EncodeUriParams, nettype: NetworkType): Promise<string>;
+    /**
+     * Set the API key for LWS (Light Wallet Server) requests.
+     * Once set, the key will be included in all subsequent LWS HTTP POST requests
+     * as an "api_key" field in the JSON body.
+     * @param apiKey - The API key to include in LWS requests
+     */
+    setLwsApiKey(apiKey: string): Promise<void>;
+    /**
+     * Enable or disable the Nym fetch interceptor.
+     *
+     * When enabled, all LWSF HTTP POST requests that the C++ wallet code
+     * would have issued are redirected through the native event bridge. The
+     * consumer must register a handler via `NativeEventEmitter` on the
+     * "MoneroWalletEvent" event with `eventName === 'nymFetchRequest'` and
+     * call `resolveFetch` / `rejectFetch` to complete the request.
+     *
+     * @param enabled - Whether to route HTTP through the JS fetch bridge
+     * @param baseUrl - scheme://host[:port] of the LWSF server (must match
+     *                  the daemon address used at openWallet time). Empty
+     *                  when disabling.
+     */
+    setNymEnabled(enabled: boolean, baseUrl: string): Promise<void>;
+    /**
+     * Resolve a pending nym fetch request that was emitted as a
+     * `nymFetchRequest` wallet event. Must be called with the same
+     * `requestId` carried on the incoming event.
+     *
+     * @param requestId  - id forwarded via the native event
+     * @param status     - HTTP status code returned from fetch
+     * @param bodyBase64 - response body encoded as base64
+     */
+    resolveFetch(requestId: string, status: number, bodyBase64: string): Promise<void>;
+    /**
+     * Reject a pending nym fetch request. The blocked C++ caller will
+     * receive a runtime_error bubbled as an RPC failure.
+     *
+     * @param requestId    - id forwarded via the native event
+     * @param errorMessage - human-readable error description
+     */
+    rejectFetch(requestId: string, errorMessage: string): Promise<void>;
+}

package/lib/src/CppBridge.js

@@ -0,0 +1,266 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CppBridge = void 0;
+const types_1 = require("./types");
+class CppBridge {
+    constructor(moneroLwsfModule) {
+        this.module = moneroLwsfModule;
+    }
+    /**
+     * Generate a new wallet's keys in memory (no disk I/O).
+     * @param nettype - Network type (0=mainnet, 1=testnet, 2=stagenet)
+     * @param language - Mnemonic language (e.g., "English")
+     * @returns Generated wallet with mnemonic and spend keys
+     */
+    async generateWallet(nettype, language = 'English') {
+        const response = await this.module.callMonero('generateWallet', [
+            (0, types_1.networkTypeToIntString)(nettype),
+            language
+        ]);
+        return JSON.parse(response);
+    }
+    /**
+     * Derive all keys from a mnemonic (no disk I/O).
+     * @param mnemonic - The 25-word mnemonic seed
+     * @param nettype - Network type (0=mainnet, 1=testnet, 2=stagenet)
+     * @returns All four keys (view and spend, public and secret)
+     */
+    async seedAndKeysFromMnemonic(mnemonic, nettype) {
+        const response = await this.module.callMonero('seedAndKeysFromMnemonic', [
+            mnemonic,
+            (0, types_1.networkTypeToIntString)(nettype)
+        ]);
+        return JSON.parse(response);
+    }
+    /**
+     * Get the current network blockchain height from a daemon.
+     * @param backend - Backend type ('lws' or 'monerod')
+     * @param nettype - Network type (0=mainnet, 1=testnet, 2=stagenet)
+     * @param daemonAddress - Daemon address to query
+     * @returns Current blockchain height
+     */
+    async getNetworkBlockHeight(backend, nettype, daemonAddress) {
+        const response = await this.module.callMonero('getNetworkBlockHeight', [
+            backend,
+            (0, types_1.networkTypeToIntString)(nettype),
+            daemonAddress
+        ]);
+        return parseInt(response, 10);
+    }
+    /**
+     * Validate a Monero address.
+     * @param address - The address to validate
+     * @param nettype - Network type (0=mainnet, 1=testnet, 2=stagenet)
+     * @returns true if valid, false otherwise
+     */
+    async isValidAddress(address, nettype) {
+        const response = await this.module.callMonero('isValidAddress', [
+            address,
+            (0, types_1.networkTypeToIntString)(nettype)
+        ]);
+        return response === 'true';
+    }
+    /**
+     * Open or create a wallet. If already open, returns current status.
+     * If wallet exists on disk, opens it. Otherwise creates from mnemonic.
+     * @param walletId - Unique identifier for the wallet
+     * @param backend - Backend type ("lws" or "monerod")
+     * @param mnemonic - The 25-word mnemonic seed
+     * @param nettype - Network type (0=mainnet, 1=testnet, 2=stagenet)
+     * @param restoreHeight - Block height to restore from
+     * @param daemonAddress - Daemon address to connect to
+     * @returns Current wallet status (heights and balances)
+     */
+    async openWallet(walletId, backend, mnemonic, password, nettype, restoreHeight, daemonAddress) {
+        const response = await this.module.callMonero('openWallet', [
+            this.module.documentDirectory,
+            walletId,
+            backend,
+            mnemonic,
+            password,
+            (0, types_1.networkTypeToIntString)(nettype),
+            restoreHeight.toString(),
+            daemonAddress
+        ]);
+        return JSON.parse(response);
+    }
+    /**
+     * Get the current status of an open wallet.
+     * @param walletId - Unique identifier for the wallet
+     * @returns Current wallet status (heights and balances)
+     */
+    async getWalletStatus(walletId) {
+        const response = await this.module.callMonero('getWalletStatus', [walletId]);
+        return JSON.parse(response);
+    }
+    /**
+     * Close an open wallet.
+     * @param walletId - Unique identifier for the wallet to close
+     */
+    async closeWallet(walletId) {
+        await this.module.callMonero('closeWallet', [walletId]);
+    }
+    /**
+     * Delete a wallet's files from disk. Closes the wallet first if it's open.
+     * @param walletId - Unique identifier for the wallet
+     * @param backend - Backend type ('lws' or 'monerod')
+     */
+    async deleteWallet(walletId, backend) {
+        await this.module.callMonero('deleteWallet', [
+            this.module.documentDirectory,
+            walletId,
+            backend
+        ]);
+    }
+    /**
+     * Get all transactions with pagination.
+     * @param walletId - Unique identifier for the wallet
+     * @param page - Page number (0-indexed)
+     * @param pageSize - Number of transactions per page
+     * @param sort - Sort order: 'asc' (oldest first) or 'desc' (newest first), pending always at end
+     * @returns Paginated transactions with metadata
+     */
+    async getAllTransactions(walletId, page, pageSize, sort = 'asc') {
+        const response = await this.module.callMonero('getAllTransactions', [
+            walletId,
+            page.toString(),
+            pageSize.toString(),
+            sort
+        ]);
+        return JSON.parse(response);
+    }
+    /**
+     * Create a transaction (supports multiple recipients).
+     * The transaction is created and signed but not broadcast yet.
+     * @param walletId - Unique identifier for the wallet
+     * @param recipients - Array of recipients with addresses and amounts (atomic units)
+     * @param priority - Transaction priority (0=Default, 1=Low, 2=Medium, 3=High)
+     * @returns SignedTransaction with txid, signedTxHex, and fee (atomic units)
+     */
+    async createTransaction(walletId, recipients, priority) {
+        const addresses = recipients.map(r => r.address).join(',');
+        const amounts = recipients.map(r => r.amount).join(',');
+        const response = await this.module.callMonero('createTransaction', [
+            walletId,
+            addresses,
+            amounts,
+            priority.toString(),
+            this.module.documentDirectory
+        ]);
+        return JSON.parse(response);
+    }
+    /**
+     * Broadcast a previously created transaction.
+     * @param walletId - Unique identifier for the wallet
+     * @param signedTx - The signed transaction string from createTransaction
+     * @returns The transaction hash
+     * @throws Error if broadcast fails
+     */
+    async broadcastTransaction(walletId, signedTx) {
+        const response = await this.module.callMonero('broadcastTransaction', [
+            walletId,
+            signedTx,
+            this.module.documentDirectory
+        ]);
+        return response;
+    }
+    /**
+     * Parse a monero: URI into its components.
+     * @param uri - The monero: URI to parse
+     * @param nettype - Network type (0=mainnet, 1=testnet, 2=stagenet)
+     * @returns Parsed URI components
+     * @throws Error if URI is invalid
+     */
+    async parseUri(uri, nettype) {
+        const response = await this.module.callMonero('parseUri', [
+            uri,
+            (0, types_1.networkTypeToIntString)(nettype)
+        ]);
+        const parsed = JSON.parse(response);
+        if (typeof parsed === 'object' && 'error' in parsed) {
+            throw new Error(parsed.error);
+        }
+        return parsed;
+    }
+    /**
+     * Encode a monero: URI from components.
+     * @param params - URI components (address, amount, etc.)
+     * @param nettype - Network type (0=mainnet, 1=testnet, 2=stagenet)
+     * @returns The encoded monero: URI
+     * @throws Error if parameters are invalid
+     */
+    async encodeUri(params, nettype) {
+        const response = await this.module.callMonero('encodeUri', [
+            params.address,
+            params.paymentId ?? '',
+            params.amount,
+            params.txDescription ?? '',
+            params.recipientName ?? '',
+            (0, types_1.networkTypeToIntString)(nettype)
+        ]);
+        // Check for error response (JSON object with error field)
+        if (response.startsWith('{')) {
+            const parsed = JSON.parse(response);
+            if (typeof parsed === 'object' && 'error' in parsed) {
+                throw new Error(parsed.error);
+            }
+        }
+        return response;
+    }
+    /**
+     * Set the API key for LWS (Light Wallet Server) requests.
+     * Once set, the key will be included in all subsequent LWS HTTP POST requests
+     * as an "api_key" field in the JSON body.
+     * @param apiKey - The API key to include in LWS requests
+     */
+    async setLwsApiKey(apiKey) {
+        await this.module.callMonero('setLwsApiKey', [apiKey]);
+    }
+    /**
+     * Enable or disable the Nym fetch interceptor.
+     *
+     * When enabled, all LWSF HTTP POST requests that the C++ wallet code
+     * would have issued are redirected through the native event bridge. The
+     * consumer must register a handler via `NativeEventEmitter` on the
+     * "MoneroWalletEvent" event with `eventName === 'nymFetchRequest'` and
+     * call `resolveFetch` / `rejectFetch` to complete the request.
+     *
+     * @param enabled - Whether to route HTTP through the JS fetch bridge
+     * @param baseUrl - scheme://host[:port] of the LWSF server (must match
+     *                  the daemon address used at openWallet time). Empty
+     *                  when disabling.
+     */
+    async setNymEnabled(enabled, baseUrl) {
+        await this.module.callMonero('setNymEnabled', [
+            enabled ? 'true' : 'false',
+            baseUrl
+        ]);
+    }
+    /**
+     * Resolve a pending nym fetch request that was emitted as a
+     * `nymFetchRequest` wallet event. Must be called with the same
+     * `requestId` carried on the incoming event.
+     *
+     * @param requestId  - id forwarded via the native event
+     * @param status     - HTTP status code returned from fetch
+     * @param bodyBase64 - response body encoded as base64
+     */
+    async resolveFetch(requestId, status, bodyBase64) {
+        await this.module.callMonero('resolveFetch', [
+            requestId,
+            status.toString(),
+            bodyBase64
+        ]);
+    }
+    /**
+     * Reject a pending nym fetch request. The blocked C++ caller will
+     * receive a runtime_error bubbled as an RPC failure.
+     *
+     * @param requestId    - id forwarded via the native event
+     * @param errorMessage - human-readable error description
+     */
+    async rejectFetch(requestId, errorMessage) {
+        await this.module.callMonero('rejectFetch', [requestId, errorMessage]);
+    }
+}
+exports.CppBridge = CppBridge;

package/lib/src/index.d.ts

@@ -0,0 +1,4 @@
+import { CppBridge, type NativeMoneroLwsfModule } from './CppBridge';
+export declare function makeMonero(): CppBridge;
+export type { CppBridge, NativeMoneroLwsfModule };
+export * from './types';

package/lib/src/index.js

@@ -1 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMonero = makeMonero;
+const react_native_1 = require("react-native");
+const CppBridge_1 = require("./CppBridge");
+function makeMonero() {
+    const { MoneroLwsfModule } = react_native_1.NativeModules;
+    if (MoneroLwsfModule == null) {
+        throw new Error('react-native-monero native module not linked');
+    }
+    return new CppBridge_1.CppBridge(MoneroLwsfModule);
+}
+__exportStar(require("./types"), exports);

package/lib/src/types.d.ts

@@ -0,0 +1,103 @@
+export type NetworkType = 'MAINNET' | 'TESTNET' | 'STAGENET';
+export declare function networkTypeToIntString(type: NetworkType): string;
+export type WalletBackend = 'lws' | 'monerod';
+export interface GeneratedWallet {
+    mnemonic: string;
+    secretSpendKey: string;
+    publicSpendKey: string;
+}
+/** Return type for seedAndKeysFromMnemonic. */
+export interface DerivedKeys {
+    address: string;
+    secretViewKey: string;
+    publicViewKey: string;
+    secretSpendKey: string;
+    publicSpendKey: string;
+}
+/** Return type for openWallet and getWalletStatus. */
+export interface WalletStatus {
+    syncedHeight: number;
+    networkHeight: number;
+    balance: string;
+    unlockedBalance: string;
+}
+/** Transaction direction. */
+export type TransactionDirection = 0 | 1;
+/** Single transaction info. */
+export interface TransactionInfo {
+    hash: string;
+    direction: TransactionDirection;
+    isPending: boolean;
+    isFailed: boolean;
+    isCoinbase: boolean;
+    amount: string;
+    fee: string;
+    blockHeight: number;
+    confirmations: number;
+    timestamp: number;
+    paymentId: string;
+    description: string;
+    label: string;
+    unlockTime: number;
+    subaddrAccount: number;
+    txKey?: string;
+}
+/** Return type for getAllTransactions. */
+export interface TransactionsPage {
+    transactions: TransactionInfo[];
+    totalCount: number;
+    page: number;
+    pageSize: number;
+}
+/** Transaction priority levels. */
+export type TransactionPriority = 0 | 1 | 2 | 3;
+/** Recipient for createTransaction. */
+export interface Recipient {
+    address: string;
+    amount: string;
+}
+/** Return type for createTransaction. */
+export interface SignedTransaction {
+    txid: string;
+    signedTxHex: string;
+    fee: string;
+}
+/** Parsed Monero URI (parseUri result). */
+export interface ParsedUri {
+    address: string;
+    paymentId: string;
+    amount: string;
+    txDescription: string;
+    recipientName: string;
+    unknownParameters: string[];
+}
+/** Params for encodeUri (make monero: URI). */
+export interface EncodeUriParams {
+    address: string;
+    paymentId?: string;
+    amount: string;
+    txDescription?: string;
+    recipientName?: string;
+}
+/** Wallet event names emitted by the native WalletListener. */
+export type WalletEventName = 'pendingTransactionReceived' | 'nymFetchRequest';
+/** Payload delivered by "MoneroWalletEvent" NativeEventEmitter events. */
+export interface WalletEventData {
+    walletId: string;
+    eventName: WalletEventName;
+    /**
+     * JSON string whose shape depends on `eventName`:
+     *   - pendingTransactionReceived: { txId: string, amount: number }
+     *   - nymFetchRequest: { url, method, headers, bodyBase64 } — in this
+     *     case `walletId` holds the nym requestId that must be passed to
+     *     `resolveFetch` / `rejectFetch`.
+     */
+    data: string;
+}
+/** Parsed payload for the `nymFetchRequest` wallet event. */
+export interface NymFetchRequestPayload {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    bodyBase64: string;
+}

package/lib/src/types.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.networkTypeToIntString = networkTypeToIntString;
+const networkTypeMap = {
+    MAINNET: 0,
+    TESTNET: 1,
+    STAGENET: 2
+};
+function networkTypeToIntString(type) {
+    return networkTypeMap[type]?.toString() ?? '0';
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "react-native-monero",
-  "version": "0.0.1",
-  "description": "React Native bindings for the Monero blockchain",
+  "version": "0.2.0",
+  "description": "React Native bindings for the monero-lwsf library",
   "homepage": "https://github.com/EdgeApp/react-native-monero",
   "repository": {
     "type": "git",
@@ -18,7 +18,9 @@
     "/ios/",
     "/lib/src/",
     "/package.json",
-    "/README.md"
+    "/react-native-monero.podspec",
+    "/README.md",
+    "/src/monero-wrapper/monero-methods.hpp"
   ],
   "lint-staged": {
     "*.{js,ts}": "eslint"
@@ -26,7 +28,7 @@
   "scripts": {
     "fix": "npm run lint -- --fix",
     "lint": "eslint .",
-    "-prepack": "npm run build-native",
+    "prepack": "npm run build-native",
     "prepare": "husky && lint-staged && rimraf lib && tsc",
     "precommit": "npm run lint",
     "build-native": "ZERO_AR_DATE=1 node -r sucrase/register ./scripts/build-native.ts"
@@ -44,5 +46,8 @@
   },
   "dependencies": {
     "cleaners": "^0.3.17"
+  },
+  "peerDependencies": {
+    "react-native": ">=0.47.0 <1.0.0"
   }
 }

package/react-native-monero.podspec

@@ -0,0 +1,28 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = package['name']
+  s.version      = package['version']
+  s.summary      = package['description']
+  s.homepage     = package['homepage']
+  s.license      = package['license']
+  s.authors      = package['author']
+
+  s.platform     = :ios, "13.0"
+  s.requires_arc = true
+  s.source = {
+    :git => "https://github.com/EdgeApp/react-native-monero.git",
+    :tag => "v#{s.version}"
+  }
+  s.source_files =
+    "ios/MoneroModule.h",
+    "ios/MoneroModule.mm",
+    "src/monero-wrapper/monero-methods.hpp"
+  s.vendored_frameworks = "ios/MoneroModule.xcframework"
+  s.libraries = "c++"
+
+  s.dependency "React-Core"
+  s.frameworks = 'Security'
+end

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