monero-native 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,36 @@
+# monero-native
+
+## Unreleased
+
+## 0.5.0 (2026-08-14)
+
+- changed: (Breaking) `broadcastTransaction` returns a `BroadcastResult` with the transaction secret key (`txKey`) instead of the string `"success"`. The key is the sender's only proof of payment and the broadcast is the send path's only chance to hand it to the caller, since it cannot be derived from the seed. A key the wallet cannot report never fails an already-broadcast payment: the result simply carries no `txKey`.
+
+## 0.4.2 (2026-07-17)
+
+- changed: Bump vtnerd/lwsf to da8e2617958312f10fe4406808c2a951c5cf0a09
+
+## 0.4.1 (2026-07-14)
+
+- fixed: iOS no longer crashes with EXC_BAD_INSTRUCTION (SIGILL) in `CRYPTO_atomic_load` on A11 and older devices (iPhone X, 8, 7, 6s) the moment a wallet opens. OpenSSL's `ios64-xcrun` build target stopped passing a deployment-target flag, so clang targeted the SDK version and raised the CPU baseline to apple-a12, emitting ARMv8.3 `ldapr` (and ARMv8.1 LSE) instructions those chips lack; the first SSL client construction (`getWalletManager` → `boost::asio::ssl::context` → `ERR_clear_error`) executed one and crash-looped the app on login. The OpenSSL build now pins `-miphoneos-version-min`/`-mios-simulator-version-min` to the platform minimum, restoring the ARMv8.0 baseline (`ldar`).
+
+## 0.4.0 (2026-07-06)
+
+- added: `getWalletStatus` reports a `refreshed` flag, true once the wallet has completed its first server refresh (and so knows its real balance and spendable outputs). LWS wallets report seed heights that look synced before then, so treat a wallet as synced only when `refreshed` is true.
+- fixed: LWS wallets can spend and receive over the Nym mixnet. The lwsf RPC timeout of 5 seconds was too short for a mixnet round-trip, so single-shot spend and receive calls failed; the Nym path now uses a 120-second budget.
+
+## 0.3.0 (2026-07-03)
+
+- added: `getPendingTransactions`, a paged view of the not-yet-mined transactions. `getAllTransactions` sorts pending entries behind all confirmed ones, so a cursor-based scan of confirmed history never reaches them; this exposes the pending set directly.
+- fixed: LWS wallets sync again. The 0.2.0 https change passed `use_ssl=true` to `wallet->init` for https daemons; wallet2 (monerod) ignores that flag, but lwsf honors it and switches from tolerant `ssl_support_autodetect` to `ssl_support_enabled`, whose certificate verification always fails on iOS/Android (no OpenSSL system CA store in the app sandbox). Every LWS connection was silently dropped at the TLS handshake, so LWS wallets polled forever at height 0 with no transactions or balance. Revert to `use_ssl=false` (TLS still autodetected from the `https://` scheme); the Nym scheme fix is unaffected since it derives https from the port inside NymHttpClient.
+- fixed: Monero Full Node (monerod) sends no longer fail with "Failed to load transaction from file". `createTransaction` now retains the signed transaction natively and `broadcastTransaction` commits it directly, instead of saving it to a file and reloading it: on the full-node (wallet2) backend `save_tx` writes an unsigned tx set while `submitTransaction`'s `load_tx` requires a signed one, so the file round-trip always failed. Retained transactions are capped at 50 per wallet (oldest disposed first) and cleared when the wallet closes. Method signatures are unchanged, but the semantics narrow: `signedTxHex` is now an opaque token (the txid) identifying the retained transaction rather than serialized bytes, a signed transaction can no longer be broadcast after its wallet closes or the app restarts (`broadcastTransaction` reports that it must be recreated), and payments the wallet would split into multiple on-chain transactions are rejected at creation so a broadcast is atomic.
+
+## 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/LICENSE

@@ -0,0 +1,38 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Airbitz, Inc.
+Copyright (c) 2014-2024, The Monero Project
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+---
+
+This package wraps the Monero Project, which is BSD-3-Clause, and ships
+binaries compiled from it. The wrapper carries the same license so the package
+and what it distributes agree. Boost, OpenSSL, libsodium, libunbound, libexpat
+and libzmq are also compiled in and remain under their own licenses.

package/README.md

@@ -0,0 +1,26 @@
+# monero-native
+
+Native Monero wallet library (LWSF) for React Native and Node.js.
+
+The compiled C++ lives in this package. React Native and Node are hosts.
+
+- GitHub: [EdgeApp/monero-native](https://github.com/EdgeApp/monero-native)
+- npm: `monero-native`
+
+## React Native
+
+Add the package and run `pod install` as needed.
+
+```js
+import { makeMonero } from 'monero-native'
+```
+
+Mobile binaries: `npm run build-native` (Android + iOS). That script fetches third-party C++ and is not run on `npm install`.
+
+## Node (CLI)
+
+```js
+import { makeNodeMoneroModule } from 'monero-native/node'
+```
+
+Host addon: `npm run build-native-host` (explicit; `prepare` / `prepack` compile JavaScript only).

package/android/build.gradle

@@ -0,0 +1,40 @@
+buildscript {
+  repositories {
+    mavenCentral()
+    google()
+  }
+
+  dependencies {
+    classpath 'com.android.tools.build:gradle:7.3.1'
+  }
+}
+
+apply plugin: 'com.android.library'
+
+def safeExtGet(prop, fallback) {
+  rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+android {
+  compileSdkVersion safeExtGet('compileSdkVersion', 32)
+  defaultConfig {
+    minSdkVersion safeExtGet('minSdkVersion', 23)
+    targetSdkVersion safeExtGet('targetSdkVersion', 32)
+  }
+  lintOptions {
+    abortOnError false
+  }
+  namespace 'app.edge.rnmonero'
+}
+
+repositories {
+  maven {
+    url('../node_modules/react-native/android')
+  }
+  google()
+  mavenCentral()
+}
+
+dependencies {
+  implementation 'com.facebook.react:react-native:+'
+}

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

@@ -0,0 +1,93 @@
+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
+  public Map<String, Object> getConstants() {
+    final Map<String, Object> constants = new HashMap<>();
+    constants.put("methodNames", getMethodNames());
+    constants.put("documentDirectory", getReactApplicationContext().getFilesDir().getAbsolutePath());
+    return constants;
+  }
+
+  @Override
+  public String getName() {
+    return "MoneroLwsfModule";
+  }
+
+  @ReactMethod
+  public void callMonero(String method, ReadableArray arguments, Promise promise) {
+    // Re-package the arguments:
+    String[] strings = new String[arguments.size()];
+    for (int i = 0; i < arguments.size(); ++i) {
+      strings[i] = arguments.getString(i);
+    }
+
+    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/android/src/main/java/app/edge/rnmonero/RnMoneroPackage.java

@@ -0,0 +1,21 @@
+package app.edge.rnmonero;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class RnMoneroPackage implements ReactPackage {
+  @Override
+  public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+    return Arrays.<NativeModule>asList(new RnMoneroModule(reactContext));
+  }
+
+  @Override
+  public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+    return Collections.emptyList();
+  }
+}

package/ios/MoneroModule.h

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

package/ios/MoneroModule.mm

@@ -0,0 +1,143 @@
+#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(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
+  arguments:(NSArray *)arguments
+  resolver:(RCTPromiseResolveBlock)resolve
+  rejecter:(RCTPromiseRejectBlock)reject
+) {
+  const std::string methodString = [method UTF8String];
+
+  // Re-package the arguments:
+  NSUInteger length = [arguments count];
+  std::vector<std::string> strings;
+  strings.reserve(length);
+  for (NSUInteger i = 0; i < length; ++i) {
+    NSString *string = [arguments objectAtIndex:i];
+    strings.push_back([string UTF8String]);
+  }
+
+  // Find the named method:
+  for (int i = 0; i < moneroMethodCount; ++i) {
+    if (moneroMethods[i].name != methodString) continue;
+
+    // Validate the argument count:
+    if (moneroMethods[i].argc != strings.size()) {
+      reject(@"Error", @"monero incorrect C++ argument count", nil);
+      return;
+    }
+
+    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;
+  }
+
+  reject(
+    @"TypeError",
+    [NSString stringWithFormat:@"No monero C++ method %@", method],
+    nil
+  );
+}
+
+- (NSDictionary *)constantsToExport
+{
+  NSMutableArray *out = [NSMutableArray arrayWithCapacity:moneroMethodCount];
+  for (int i = 0; i < moneroMethodCount; ++i) {
+    NSString *name = [NSString stringWithCString:moneroMethods[i].name
+      encoding:NSUTF8StringEncoding];
+    out[i] = name;
+  }
+
+  NSFileManager *fileManager = [NSFileManager defaultManager];
+  NSURL *docsDir = [fileManager URLForDirectory:NSDocumentDirectory
+    inDomain:NSUserDomainMask
+    appropriateForURL:nil
+    create:YES
+    error:nil];
+  NSString *docsPath = [docsDir path];
+
+  return @{
+    @"methodNames": out,
+    @"documentDirectory": docsPath
+  };
+}
+
+@end

package/ios/MoneroModule.xcframework/Info.plist

@@ -0,0 +1,43 @@
+<?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-simulator</string>
+			<key>LibraryPath</key>
+			<string>libmonero-module.a</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</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,181 @@
+import type { BroadcastResult, 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>;
+    /**
+     * Get not-yet-mined transactions with pagination. Same shape as
+     * getAllTransactions, filtered to pending entries. Pending transactions sort
+     * behind all confirmed ones in getAllTransactions, so a cursor-based scan of
+     * confirmed history never reaches them; use this to read the pending set
+     * directly. The set can include entries the backend reports as permanently
+     * failed (isFailed: true); callers decide how to label those.
+     * @param walletId - Unique identifier for the wallet
+     * @param page - Page number (0-indexed)
+     * @param pageSize - Number of transactions per page
+     * @returns Paginated pending transactions with metadata
+     */
+    getPendingTransactions(walletId: string, page: number, pageSize: number): Promise<TransactionsPage>;
+    /**
+     * Create a transaction (supports multiple recipients).
+     * The transaction is created and signed but not broadcast yet: it is retained
+     * natively for a later broadcastTransaction call. At most 50 transactions are
+     * retained per wallet (oldest disposed first; broadcasting an evicted one
+     * reports that it must be recreated), and all are released when the wallet
+     * closes. Payments the wallet would split into multiple on-chain
+     * transactions are rejected, so a later broadcast is atomic.
+     * @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. `signedTx` identifies the
+     * natively retained transaction to broadcast.
+     * @param walletId - Unique identifier for the wallet
+     * @param signedTx - The signedTxHex returned by createTransaction
+     * @returns BroadcastResult with the transaction secret key, when the wallet
+     *   can report it. This is the only chance to read the key on the send path:
+     *   it is not derivable from the seed, so a caller that drops it here can
+     *   only recover it from this wallet's local cache later.
+     * @throws Error if the transaction is no longer retained (evicted, or the
+     *   wallet was closed since creation) or the broadcast fails
+     */
+    broadcastTransaction(walletId: string, signedTx: string): Promise<BroadcastResult>;
+    /**
+     * 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>;
+}