@bubolabs/wallet-rn-sdk 0.1.2 → 0.1.5

package/README.md

@@ -1,49 +1,174 @@
 # @bubolabs/wallet-rn-sdk
 
-Minimal React Native smoke SDK for the UniFFI wallet library.
+React Native SDK for the Bubo wallet UniFFI bridge.
 
-This package is a standard React Native native module layout:
+This package uses standard RN native-module layout and supports autolinking:
 
-- `android/` React Native Android library module (autolinked)
-- `ios/` Pod sources + vendored `BuboWalletFFI.xcframework` (autolinked)
+- `android/` React Native Android library module
+- `ios/` Pod sources + vendored `BuboWalletFFI.xcframework`
 - `react-native.config.js` for Android package registration
 
-## API
+## Install
 
-- `runSmoke()`
-- `runBtcSmoke()`
+```bash
+npm install @bubolabs/wallet-rn-sdk
+```
+
+iOS:
 
-Both methods call native module `BuboWalletSmoke` and return:
+```bash
+cd ios && pod install
+```
+
+## Core API
 
 ```ts
-type WalletSmokeResult = {
-  supportedChains: Array<{ chainId: string; capabilities: string[] }>;
-  deriveChainId: string;
-  derivedAddress: string;
-  signChainId: string | null;
-  signedTxHex: string | null;
+import {
+  init,
+  listSupportedChains,
+  deriveAddress,
+  buildAndSign,
+} from "@bubolabs/wallet-rn-sdk";
+```
+
+- `init(): Promise<void>`
+- `listSupportedChains(): Promise<SupportedChainInfo[]>`
+- `deriveAddress(request: DeriveAddressRequest): Promise<string>`
+- `buildAndSign(request: BuildAndSignRequest): Promise<BuildAndSignResult>`
+
+### Types
+
+```ts
+type SupportedChainInfo = {
+  chainId: string;
+  capabilities: string[];
+};
+
+type DeriveAddressRequest = {
+  chainId: string;
+  mnemonic: string;
+  account: number; // uint32
+  index: number; // uint32
+  passphrase?: string | null;
+};
+
+type BuildAndSignRequest = {
+  chainId: string;
+  mnemonic: string;
+  txPayload: string;
+  txEncoding?: "utf8" | "hex" | "base64"; // default: utf8
+};
+
+type BuildAndSignResult = {
+  chainId: string;
+  signedTxHex: string;
 };
 ```
 
-## Example
+### Example
 
 ```ts
-import { runSmoke } from "@bubolabs/wallet-rn-sdk";
+import {
+  init,
+  listSupportedChains,
+  deriveAddress,
+  buildAndSign,
+} from "@bubolabs/wallet-rn-sdk";
+
+await init();
+const chains = await listSupportedChains();
+const address = await deriveAddress({
+  chainId: "btc",
+  mnemonic: "<mnemonic>",
+  account: 0,
+  index: 0,
+  passphrase: null,
+});
+
+const signed = await buildAndSign({
+  chainId: "btc",
+  mnemonic: "<mnemonic>",
+  txPayload: "<tx payload>",
+  txEncoding: "utf8",
+});
+```
 
-const result = await runSmoke();
-console.log(result.deriveChainId, result.derivedAddress);
+### `txPayload` JSON Examples
+
+`txEncoding` uses `"utf8"` by default, so pass JSON text directly.
+
+BTC:
+
+```json
+{
+  "account": 0,
+  "address_index": 0,
+  "change_index": 0,
+  "network": "mainnet",
+  "prev_txid": "0000000000000000000000000000000000000000000000000000000000000001",
+  "prev_vout": 0,
+  "prev_script_pubkey_hex": "76a914d986ed01b7a22225a70edbf2ba7cfb63a15cb3aa88ac",
+  "prev_value_sat": 100000,
+  "to_address": "1BoatSLRHtKNngkdXEeobR76b53LETtpyT",
+  "amount_sat": 10000,
+  "fee_sat": 1000,
+  "lock_time": 0,
+  "sequence": 4294967295
+}
 ```
 
-## Install
+ETH (legacy transfer):
+
+```json
+{
+  "account": 0,
+  "index": 0,
+  "chain_id": 1,
+  "nonce": 0,
+  "gas_price_wei": "1000000000",
+  "gas_limit": 21000,
+  "to_address": "0x1111111111111111111111111111111111111111",
+  "value_wei": "1000000000000000"
+}
+```
 
-```bash
-npm install @bubolabs/wallet-rn-sdk
+Solana (system transfer):
+
+```json
+{
+  "account": 0,
+  "index": 0,
+  "to_address": "11111111111111111111111111111111",
+  "lamports": 1000,
+  "recent_blockhash": "11111111111111111111111111111111"
+}
 ```
 
-iOS:
+### Chain Feature Notes
+
+- Published package content depends on Rust feature set at build time.
+- When `BUBO_RUST_FEATURES` is not set, packaging auto-enables all `chain-*` features from `crates/ffi/Cargo.toml`.
+- You can still override for focused builds, for example:
 
 ```bash
-cd ios && pod install
+BUBO_RUST_FEATURES=chain-eth,chain-btc ./scripts/build-rn-sdk-native-artifacts.sh
+```
+
+## Compatibility Smoke API
+
+Legacy smoke APIs remain available for regression checks:
+
+- `runSmoke()`
+- `runBtcSmoke()`
+
+```ts
+type WalletSmokeResult = {
+  supportedChains: Array<{ chainId: string; capabilities: string[] }>;
+  deriveChainId: string;
+  derivedAddress: string;
+  signChainId: string | null;
+  signedTxHex: string | null;
+};
 ```
 
 ## Distribution Scripts

package/android/src/main/java/com/bubo/wallet/BuboWalletSmokeModule.kt

@@ -1,5 +1,6 @@
 package com.bubo.wallet
 
+import android.util.Base64
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
@@ -8,15 +9,77 @@ import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.WritableArray
 import com.facebook.react.bridge.WritableMap
 import uniffi.bubo_wallet_ffi.SupportedChainInfo
+import uniffi.bubo_wallet_ffi.WalletLib
 import uniffi.bubo_wallet_ffi.WalletLibSmoke
 import uniffi.bubo_wallet_ffi.WalletSmokeResult
 
 class BuboWalletSmokeModule(
     reactContext: ReactApplicationContext
 ) : ReactContextBaseJavaModule(reactContext) {
+    private val wallet: WalletLib = WalletLib()
 
     override fun getName(): String = "BuboWalletSmoke"
 
+    @ReactMethod
+    fun init(promise: Promise) {
+        try {
+            wallet.init()
+            promise.resolve(null)
+        } catch (t: Throwable) {
+            promise.reject("BUBO_WALLET", t.message, t)
+        }
+    }
+
+    @ReactMethod
+    fun listSupportedChains(promise: Promise) {
+        try {
+            val chains = wallet.listSupportedChains()
+            promise.resolve(toWritableChains(chains))
+        } catch (t: Throwable) {
+            promise.reject("BUBO_WALLET", t.message, t)
+        }
+    }
+
+    @ReactMethod
+    fun deriveAddress(
+        chainId: String,
+        mnemonic: String,
+        account: Double,
+        index: Double,
+        passphrase: String?,
+        promise: Promise
+    ) {
+        try {
+            val address = wallet.deriveAddress(
+                chainId = chainId,
+                mnemonic = mnemonic,
+                account = asUInt32(account, "account"),
+                index = asUInt32(index, "index"),
+                passphrase = passphrase,
+            )
+            promise.resolve(address)
+        } catch (t: Throwable) {
+            promise.reject("BUBO_WALLET", t.message, t)
+        }
+    }
+
+    @ReactMethod
+    fun buildAndSign(
+        chainId: String,
+        mnemonic: String,
+        txPayload: String,
+        txEncoding: String,
+        promise: Promise
+    ) {
+        try {
+            val payloadBytes = decodePayload(txPayload, txEncoding)
+            val signed = wallet.buildAndSign(chainId, mnemonic, payloadBytes)
+            promise.resolve(signed.toHex())
+        } catch (t: Throwable) {
+            promise.reject("BUBO_WALLET", t.message, t)
+        }
+    }
+
     @ReactMethod
     fun runSmoke(promise: Promise) {
         try {
@@ -62,4 +125,44 @@ class BuboWalletSmokeModule(
         }
         return out
     }
+
+    private fun asUInt32(value: Double, field: String): UInt {
+        require(value.isFinite() && value >= 0 && value <= UInt.MAX_VALUE.toDouble() && value % 1.0 == 0.0) {
+            "$field must be uint32"
+        }
+        return value.toLong().toUInt()
+    }
+
+    private fun decodePayload(payload: String, encoding: String): ByteArray {
+        return when (encoding.lowercase()) {
+            "utf8" -> payload.toByteArray(Charsets.UTF_8)
+            "base64" -> Base64.decode(payload, Base64.DEFAULT)
+            "hex" -> decodeHex(payload)
+            else -> error("txEncoding must be utf8|hex|base64")
+        }
+    }
+
+    private fun decodeHex(value: String): ByteArray {
+        val raw = value.trim()
+        require(raw.length % 2 == 0) { "hex payload length must be even" }
+        val out = ByteArray(raw.length / 2)
+        var i = 0
+        while (i < raw.length) {
+            val hi = raw[i].digitToIntOrNull(16)
+            val lo = raw[i + 1].digitToIntOrNull(16)
+            require(hi != null && lo != null) { "txPayload must be valid hex" }
+            out[i / 2] = ((hi shl 4) or lo).toByte()
+            i += 2
+        }
+        return out
+    }
+
+    private fun ByteArray.toHex(): String {
+        val out = StringBuilder(size * 2)
+        for (byte in this) {
+            out.append(((byte.toInt() ushr 4) and 0xF).toString(16))
+            out.append((byte.toInt() and 0xF).toString(16))
+        }
+        return out.toString()
+    }
 }

package/dist/index.d.ts

@@ -1,4 +1,5 @@
+export { buildAndSign, deriveAddress, init, listSupportedChains } from "./wallet";
 export { runBtcSmoke, runSmoke } from "./smoke";
-export type { SupportedChainInfo, WalletSmokeErrorCode, WalletSmokeResult, } from "./types";
-export { WalletSmokeError } from "./types";
+export type { BuildAndSignRequest, BuildAndSignResult, DeriveAddressRequest, SupportedChainInfo, TxPayloadEncoding, WalletErrorCode, WalletSmokeErrorCode, WalletSmokeResult, } from "./types";
+export { WalletError, WalletSmokeError } from "./types";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAChD,YAAY,EACV,kBAAkB,EAClB,oBAAoB,EACpB,iBAAiB,GAClB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,IAAI,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAClF,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAChD,YAAY,EACV,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,EACpB,kBAAkB,EAClB,iBAAiB,EACjB,eAAe,EACf,oBAAoB,EACpB,iBAAiB,GAClB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -1,8 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WalletSmokeError = exports.runSmoke = exports.runBtcSmoke = void 0;
+exports.WalletSmokeError = exports.WalletError = exports.runSmoke = exports.runBtcSmoke = exports.listSupportedChains = exports.init = exports.deriveAddress = exports.buildAndSign = void 0;
+var wallet_1 = require("./wallet");
+Object.defineProperty(exports, "buildAndSign", { enumerable: true, get: function () { return wallet_1.buildAndSign; } });
+Object.defineProperty(exports, "deriveAddress", { enumerable: true, get: function () { return wallet_1.deriveAddress; } });
+Object.defineProperty(exports, "init", { enumerable: true, get: function () { return wallet_1.init; } });
+Object.defineProperty(exports, "listSupportedChains", { enumerable: true, get: function () { return wallet_1.listSupportedChains; } });
 var smoke_1 = require("./smoke");
 Object.defineProperty(exports, "runBtcSmoke", { enumerable: true, get: function () { return smoke_1.runBtcSmoke; } });
 Object.defineProperty(exports, "runSmoke", { enumerable: true, get: function () { return smoke_1.runSmoke; } });
 var types_1 = require("./types");
+Object.defineProperty(exports, "WalletError", { enumerable: true, get: function () { return types_1.WalletError; } });
 Object.defineProperty(exports, "WalletSmokeError", { enumerable: true, get: function () { return types_1.WalletSmokeError; } });

package/dist/native.d.ts

@@ -10,6 +10,10 @@ export type NativeWalletSmokeResult = {
     signedTxHex: string | null;
 };
 type BuboWalletSmokeModule = {
+    init(): Promise<void>;
+    listSupportedChains(): Promise<NativeSupportedChainInfo[]>;
+    deriveAddress(chainId: string, mnemonic: string, account: number, index: number, passphrase: string | null): Promise<string>;
+    buildAndSign(chainId: string, mnemonic: string, txPayload: string, txEncoding: string): Promise<string>;
     runSmoke(): Promise<NativeWalletSmokeResult>;
     runBtcSmoke(): Promise<NativeWalletSmokeResult>;
 };

package/dist/native.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"native.d.ts","sourceRoot":"","sources":["../src/native.ts"],"names":[],"mappings":"AAcA,MAAM,MAAM,wBAAwB,GAAG;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,eAAe,EAAE,wBAAwB,EAAE,CAAC;IAC5C,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B,CAAC;AAEF,KAAK,qBAAqB,GAAG;IAC3B,QAAQ,IAAI,OAAO,CAAC,uBAAuB,CAAC,CAAC;IAC7C,WAAW,IAAI,OAAO,CAAC,uBAAuB,CAAC,CAAC;CACjD,CAAC;AA+BF,wBAAgB,wBAAwB,IAAI,qBAAqB,CAMhE"}
+{"version":3,"file":"native.d.ts","sourceRoot":"","sources":["../src/native.ts"],"names":[],"mappings":"AAcA,MAAM,MAAM,wBAAwB,GAAG;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,eAAe,EAAE,wBAAwB,EAAE,CAAC;IAC5C,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B,CAAC;AAEF,KAAK,qBAAqB,GAAG;IAC3B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,mBAAmB,IAAI,OAAO,CAAC,wBAAwB,EAAE,CAAC,CAAC;IAC3D,aAAa,CACX,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,GAAG,IAAI,GACxB,OAAO,CAAC,MAAM,CAAC,CAAC;IACnB,YAAY,CACV,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,CAAC,CAAC;IACnB,QAAQ,IAAI,OAAO,CAAC,uBAAuB,CAAC,CAAC;IAC7C,WAAW,IAAI,OAAO,CAAC,uBAAuB,CAAC,CAAC;CACjD,CAAC;AA+BF,wBAAgB,wBAAwB,IAAI,qBAAqB,CAMhE"}

package/dist/types.d.ts

@@ -2,6 +2,24 @@ export type SupportedChainInfo = {
     chainId: string;
     capabilities: string[];
 };
+export type TxPayloadEncoding = "utf8" | "hex" | "base64";
+export type DeriveAddressRequest = {
+    chainId: string;
+    mnemonic: string;
+    account: number;
+    index: number;
+    passphrase?: string | null;
+};
+export type BuildAndSignRequest = {
+    chainId: string;
+    mnemonic: string;
+    txPayload: string;
+    txEncoding?: TxPayloadEncoding;
+};
+export type BuildAndSignResult = {
+    chainId: string;
+    signedTxHex: string;
+};
 export type WalletSmokeResult = {
     supportedChains: SupportedChainInfo[];
     deriveChainId: string;
@@ -9,10 +27,14 @@ export type WalletSmokeResult = {
     signChainId: string | null;
     signedTxHex: string | null;
 };
-export type WalletSmokeErrorCode = "MODULE_NOT_LINKED" | "NATIVE_ERROR" | "INVALID_RESULT" | "BTC_SIGN_UNAVAILABLE";
-export declare class WalletSmokeError extends Error {
-    readonly code: WalletSmokeErrorCode;
+export type WalletErrorCode = "MODULE_NOT_LINKED" | "NATIVE_ERROR" | "INVALID_RESULT" | "INVALID_ARGUMENT" | "BTC_SIGN_UNAVAILABLE" | "NOT_INITIALIZED" | "UNSUPPORTED_CHAIN" | "UNSUPPORTED_CAPABILITY" | "INVALID_MNEMONIC" | "INVALID_DERIVATION_PATH" | "INVALID_ADDRESS" | "TX_BUILD_FAILED" | "TX_SIGN_FAILED" | "SERIALIZATION_FAILED" | "INTERNAL_ERROR";
+export declare class WalletError extends Error {
+    readonly code: WalletErrorCode;
     readonly causeValue?: unknown;
+    constructor(code: WalletErrorCode, message: string, causeValue?: unknown);
+}
+export type WalletSmokeErrorCode = WalletErrorCode;
+export declare class WalletSmokeError extends WalletError {
     constructor(code: WalletSmokeErrorCode, message: string, causeValue?: unknown);
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,eAAe,EAAE,kBAAkB,EAAE,CAAC;IACtC,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAC5B,mBAAmB,GACnB,cAAc,GACd,gBAAgB,GAChB,sBAAsB,CAAC;AAE3B,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,SAAgB,IAAI,EAAE,oBAAoB,CAAC;IAC3C,SAAgB,UAAU,CAAC,EAAE,OAAO,CAAC;gBAGnC,IAAI,EAAE,oBAAoB,EAC1B,OAAO,EAAE,MAAM,EACf,UAAU,CAAC,EAAE,OAAO;CAOvB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,CAAC;AAE1D,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,iBAAiB,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,eAAe,EAAE,kBAAkB,EAAE,CAAC;IACtC,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,eAAe,GACvB,mBAAmB,GACnB,cAAc,GACd,gBAAgB,GAChB,kBAAkB,GAClB,sBAAsB,GACtB,iBAAiB,GACjB,mBAAmB,GACnB,wBAAwB,GACxB,kBAAkB,GAClB,yBAAyB,GACzB,iBAAiB,GACjB,iBAAiB,GACjB,gBAAgB,GAChB,sBAAsB,GACtB,gBAAgB,CAAC;AAErB,qBAAa,WAAY,SAAQ,KAAK;IACpC,SAAgB,IAAI,EAAE,eAAe,CAAC;IACtC,SAAgB,UAAU,CAAC,EAAE,OAAO,CAAC;gBAGnC,IAAI,EAAE,eAAe,EACrB,OAAO,EAAE,MAAM,EACf,UAAU,CAAC,EAAE,OAAO;CAOvB;AAED,MAAM,MAAM,oBAAoB,GAAG,eAAe,CAAC;AAEnD,qBAAa,gBAAiB,SAAQ,WAAW;gBAE7C,IAAI,EAAE,oBAAoB,EAC1B,OAAO,EAAE,MAAM,EACf,UAAU,CAAC,EAAE,OAAO;CAKvB"}

package/dist/types.js

@@ -1,12 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WalletSmokeError = void 0;
-class WalletSmokeError extends Error {
+exports.WalletSmokeError = exports.WalletError = void 0;
+class WalletError extends Error {
     constructor(code, message, causeValue) {
         super(message);
-        this.name = "WalletSmokeError";
+        this.name = "WalletError";
         this.code = code;
         this.causeValue = causeValue;
     }
 }
+exports.WalletError = WalletError;
+class WalletSmokeError extends WalletError {
+    constructor(code, message, causeValue) {
+        super(code, message, causeValue);
+        this.name = "WalletSmokeError";
+    }
+}
 exports.WalletSmokeError = WalletSmokeError;

package/dist/wallet.d.ts

@@ -0,0 +1,6 @@
+import { BuildAndSignRequest, BuildAndSignResult, DeriveAddressRequest, SupportedChainInfo } from "./types";
+export declare function init(): Promise<void>;
+export declare function listSupportedChains(): Promise<SupportedChainInfo[]>;
+export declare function deriveAddress(request: DeriveAddressRequest): Promise<string>;
+export declare function buildAndSign(request: BuildAndSignRequest): Promise<BuildAndSignResult>;
+//# sourceMappingURL=wallet.d.ts.map

package/dist/wallet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet.d.ts","sourceRoot":"","sources":["../src/wallet.ts"],"names":[],"mappings":"AACA,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,EACpB,kBAAkB,EAInB,MAAM,SAAS,CAAC;AAgHjB,wBAAsB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAM1C;AAED,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAUzE;AAED,wBAAsB,aAAa,CACjC,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,MAAM,CAAC,CAmBjB;AAED,wBAAsB,YAAY,CAChC,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,kBAAkB,CAAC,CAoB7B"}

package/dist/wallet.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+exports.listSupportedChains = listSupportedChains;
+exports.deriveAddress = deriveAddress;
+exports.buildAndSign = buildAndSign;
+const native_1 = require("./native");
+const types_1 = require("./types");
+const HEX_REGEX = /^[0-9a-fA-F]+$/;
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}
+function parseCoreErrorCode(message) {
+    var _a;
+    const m = message.match(/^([A-Za-z]+):/);
+    const ffiCode = (_a = m === null || m === void 0 ? void 0 : m[1]) !== null && _a !== void 0 ? _a : "";
+    switch (ffiCode) {
+        case "NotInitialized":
+            return "NOT_INITIALIZED";
+        case "UnsupportedChain":
+            return "UNSUPPORTED_CHAIN";
+        case "UnsupportedCapability":
+            return "UNSUPPORTED_CAPABILITY";
+        case "InvalidMnemonic":
+            return "INVALID_MNEMONIC";
+        case "InvalidDerivationPath":
+            return "INVALID_DERIVATION_PATH";
+        case "InvalidAddress":
+            return "INVALID_ADDRESS";
+        case "TxBuildFailed":
+            return "TX_BUILD_FAILED";
+        case "TxSignFailed":
+            return "TX_SIGN_FAILED";
+        case "SerializationFailed":
+            return "SERIALIZATION_FAILED";
+        case "Internal":
+            return "INTERNAL_ERROR";
+        default:
+            return null;
+    }
+}
+function mapNativeError(error) {
+    var _a;
+    if (error instanceof types_1.WalletError) {
+        return error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return new types_1.WalletError((_a = parseCoreErrorCode(message)) !== null && _a !== void 0 ? _a : "NATIVE_ERROR", message, error);
+}
+function assertNonEmptyString(value, field) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new types_1.WalletError("INVALID_ARGUMENT", `${field} must be a non-empty string`, value);
+    }
+    return value;
+}
+function assertUint32(value, field) {
+    if (typeof value !== "number" ||
+        !Number.isFinite(value) ||
+        !Number.isInteger(value) ||
+        value < 0 ||
+        value > 0xffffffff) {
+        throw new types_1.WalletError("INVALID_ARGUMENT", `${field} must be a uint32`, value);
+    }
+    return value;
+}
+function assertEncoding(value) {
+    const encoding = value !== null && value !== void 0 ? value : "utf8";
+    if (encoding !== "utf8" && encoding !== "hex" && encoding !== "base64") {
+        throw new types_1.WalletError("INVALID_ARGUMENT", "txEncoding must be one of: utf8 | hex | base64", value);
+    }
+    return encoding;
+}
+function normalizeChainInfo(value, index) {
+    if (!isObject(value)) {
+        throw new types_1.WalletError("INVALID_RESULT", `supportedChains[${index}] is not an object`, value);
+    }
+    const chainId = value.chainId;
+    const capabilities = value.capabilities;
+    if (typeof chainId !== "string" || chainId.length === 0) {
+        throw new types_1.WalletError("INVALID_RESULT", `supportedChains[${index}].chainId must be a non-empty string`, value);
+    }
+    if (!Array.isArray(capabilities) || !capabilities.every((item) => typeof item === "string")) {
+        throw new types_1.WalletError("INVALID_RESULT", `supportedChains[${index}].capabilities must be string[]`, value);
+    }
+    return { chainId, capabilities };
+}
+function validateBuildPayload(payload, txEncoding) {
+    if (txEncoding === "hex") {
+        if (payload.length % 2 !== 0 || !HEX_REGEX.test(payload)) {
+            throw new types_1.WalletError("INVALID_ARGUMENT", "txPayload must be valid even-length hex when txEncoding=hex", payload);
+        }
+    }
+}
+async function init() {
+    try {
+        await (0, native_1.getBuboWalletSmokeModule)().init();
+    }
+    catch (error) {
+        throw mapNativeError(error);
+    }
+}
+async function listSupportedChains() {
+    try {
+        const raw = await (0, native_1.getBuboWalletSmokeModule)().listSupportedChains();
+        if (!Array.isArray(raw)) {
+            throw new types_1.WalletError("INVALID_RESULT", "native result must be array", raw);
+        }
+        return raw.map(normalizeChainInfo);
+    }
+    catch (error) {
+        throw mapNativeError(error);
+    }
+}
+async function deriveAddress(request) {
+    const chainId = assertNonEmptyString(request.chainId, "chainId");
+    const mnemonic = assertNonEmptyString(request.mnemonic, "mnemonic");
+    const account = assertUint32(request.account, "account");
+    const index = assertUint32(request.index, "index");
+    const passphrase = request.passphrase == null ? null : String(request.passphrase);
+    try {
+        const address = await (0, native_1.getBuboWalletSmokeModule)().deriveAddress(chainId, mnemonic, account, index, passphrase);
+        return assertNonEmptyString(address, "native address");
+    }
+    catch (error) {
+        throw mapNativeError(error);
+    }
+}
+async function buildAndSign(request) {
+    const chainId = assertNonEmptyString(request.chainId, "chainId");
+    const mnemonic = assertNonEmptyString(request.mnemonic, "mnemonic");
+    const txPayload = assertNonEmptyString(request.txPayload, "txPayload");
+    const txEncoding = assertEncoding(request.txEncoding);
+    validateBuildPayload(txPayload, txEncoding);
+    try {
+        const signedTxHex = await (0, native_1.getBuboWalletSmokeModule)().buildAndSign(chainId, mnemonic, txPayload, txEncoding);
+        return {
+            chainId,
+            signedTxHex: assertNonEmptyString(signedTxHex, "native signedTxHex"),
+        };
+    }
+    catch (error) {
+        throw mapNativeError(error);
+    }
+}

package/ios/BuboWalletSmokeModule.m

@@ -2,6 +2,27 @@
 
 @interface RCT_EXTERN_MODULE(BuboWalletSmoke, NSObject)
 
+RCT_EXTERN_METHOD(init:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(listSupportedChains:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(deriveAddress:(NSString *)chainId
+                  mnemonic:(NSString *)mnemonic
+                  account:(nonnull NSNumber *)account
+                  index:(nonnull NSNumber *)index
+                  passphrase:(NSString * _Nullable)passphrase
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(buildAndSign:(NSString *)chainId
+                  mnemonic:(NSString *)mnemonic
+                  txPayload:(NSString *)txPayload
+                  txEncoding:(NSString *)txEncoding
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
 RCT_EXTERN_METHOD(runSmoke:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 

package/ios/BuboWalletSmokeModule.swift

@@ -3,11 +3,87 @@ import React
 
 @objc(BuboWalletSmoke)
 public final class BuboWalletSmoke: NSObject {
+    private let wallet = WalletLib()
+
     @objc
     public static func requiresMainQueueSetup() -> Bool {
         false
     }
 
+    @objc(init:rejecter:)
+    public func `init`(
+        _ resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        do {
+            try wallet.`init`()
+            resolve(nil)
+        } catch {
+            reject("BUBO_WALLET", String(describing: error), error)
+        }
+    }
+
+    @objc(listSupportedChains:rejecter:)
+    public func listSupportedChains(
+        _ resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        do {
+            let chains = try wallet.listSupportedChains()
+            resolve(chains.map { ["chainId": $0.chainId, "capabilities": $0.capabilities] })
+        } catch {
+            reject("BUBO_WALLET", String(describing: error), error)
+        }
+    }
+
+    @objc(deriveAddress:mnemonic:account:index:passphrase:resolver:rejecter:)
+    public func deriveAddress(
+        _ chainId: String,
+        mnemonic: String,
+        account: NSNumber,
+        index: NSNumber,
+        passphrase: String?,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        do {
+            let accountU32 = try toUInt32(account, field: "account")
+            let indexU32 = try toUInt32(index, field: "index")
+            let address = try wallet.deriveAddress(
+                chainId: chainId,
+                mnemonic: mnemonic,
+                account: accountU32,
+                index: indexU32,
+                passphrase: passphrase
+            )
+            resolve(address)
+        } catch {
+            reject("BUBO_WALLET", String(describing: error), error)
+        }
+    }
+
+    @objc(buildAndSign:mnemonic:txPayload:txEncoding:resolver:rejecter:)
+    public func buildAndSign(
+        _ chainId: String,
+        mnemonic: String,
+        txPayload: String,
+        txEncoding: String,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        do {
+            let payload = try decodePayload(txPayload, encoding: txEncoding)
+            let signed = try wallet.buildAndSign(
+                chainId: chainId,
+                mnemonic: mnemonic,
+                txPayload: payload
+            )
+            resolve(hexEncodedString(signed))
+        } catch {
+            reject("BUBO_WALLET", String(describing: error), error)
+        }
+    }
+
     @objc(runSmoke:rejecter:)
     public func runSmoke(
         _ resolve: @escaping RCTPromiseResolveBlock,
@@ -48,4 +124,71 @@ public final class BuboWalletSmoke: NSObject {
             "signedTxHex": result.signedTxHex as Any,
         ]
     }
+
+    private func toUInt32(_ value: NSNumber, field: String) throws -> UInt32 {
+        let raw = value.doubleValue
+        if !raw.isFinite || raw < 0 || raw > Double(UInt32.max) || floor(raw) != raw {
+            throw NSError(
+                domain: "BuboWalletSmoke",
+                code: 1,
+                userInfo: [NSLocalizedDescriptionKey: "\(field) must be uint32"]
+            )
+        }
+        return UInt32(raw)
+    }
+
+    private func decodePayload(_ payload: String, encoding: String) throws -> Data {
+        switch encoding.lowercased() {
+        case "utf8":
+            return Data(payload.utf8)
+        case "base64":
+            guard let data = Data(base64Encoded: payload) else {
+                throw NSError(
+                    domain: "BuboWalletSmoke",
+                    code: 2,
+                    userInfo: [NSLocalizedDescriptionKey: "txPayload must be valid base64"]
+                )
+            }
+            return data
+        case "hex":
+            return try decodeHex(payload)
+        default:
+            throw NSError(
+                domain: "BuboWalletSmoke",
+                code: 3,
+                userInfo: [NSLocalizedDescriptionKey: "txEncoding must be utf8|hex|base64"]
+            )
+        }
+    }
+
+    private func decodeHex(_ value: String) throws -> Data {
+        let raw = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        if raw.count % 2 != 0 {
+            throw NSError(
+                domain: "BuboWalletSmoke",
+                code: 4,
+                userInfo: [NSLocalizedDescriptionKey: "hex payload length must be even"]
+            )
+        }
+        var data = Data(capacity: raw.count / 2)
+        var index = raw.startIndex
+        while index < raw.endIndex {
+            let next = raw.index(index, offsetBy: 2)
+            let byteStr = raw[index..<next]
+            guard let byte = UInt8(byteStr, radix: 16) else {
+                throw NSError(
+                    domain: "BuboWalletSmoke",
+                    code: 5,
+                    userInfo: [NSLocalizedDescriptionKey: "txPayload must be valid hex"]
+                )
+            }
+            data.append(byte)
+            index = next
+        }
+        return data
+    }
+
+    private func hexEncodedString(_ data: Data) -> String {
+        data.map { String(format: "%02x", $0) }.joined()
+    }
 }

package/ios/lib/BuboWalletFFI.xcframework/Info.plist

@@ -10,18 +10,15 @@
 			<key>HeadersPath</key>
 			<string>Headers</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64_x86_64-simulator</string>
+			<string>ios-arm64</string>
 			<key>LibraryPath</key>
 			<string>libbubo_wallet_ffi.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>
 		<dict>
 			<key>BinaryPath</key>
@@ -29,15 +26,18 @@
 			<key>HeadersPath</key>
 			<string>Headers</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
+			<string>ios-arm64_x86_64-simulator</string>
 			<key>LibraryPath</key>
 			<string>libbubo_wallet_ffi.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>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bubolabs/wallet-rn-sdk",
-  "version": "0.1.2",
+  "version": "0.1.5",
   "description": "React Native smoke SDK for bubo wallet UniFFI bridge",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",