@bubolabs/wallet-rn-sdk 0.1.2

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { runBtcSmoke, runSmoke } from "./smoke";
+export type { SupportedChainInfo, WalletSmokeErrorCode, WalletSmokeResult, } from "./types";
+export { WalletSmokeError } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +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"}

package/dist/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletSmokeError = exports.runSmoke = exports.runBtcSmoke = void 0;
+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, "WalletSmokeError", { enumerable: true, get: function () { return types_1.WalletSmokeError; } });

package/dist/native.d.ts

@@ -0,0 +1,18 @@
+export type NativeSupportedChainInfo = {
+    chainId: string;
+    capabilities: string[];
+};
+export type NativeWalletSmokeResult = {
+    supportedChains: NativeSupportedChainInfo[];
+    deriveChainId: string;
+    derivedAddress: string;
+    signChainId: string | null;
+    signedTxHex: string | null;
+};
+type BuboWalletSmokeModule = {
+    runSmoke(): Promise<NativeWalletSmokeResult>;
+    runBtcSmoke(): Promise<NativeWalletSmokeResult>;
+};
+export declare function getBuboWalletSmokeModule(): BuboWalletSmokeModule;
+export {};
+//# sourceMappingURL=native.d.ts.map

package/dist/native.d.ts.map

@@ -0,0 +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"}

package/dist/native.js

@@ -0,0 +1,37 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBuboWalletSmokeModule = getBuboWalletSmokeModule;
+const types_1 = require("./types");
+const ReactNativeRuntime = require("react-native");
+const NativeModules = (_a = ReactNativeRuntime.NativeModules) !== null && _a !== void 0 ? _a : {};
+const TurboModuleRegistry = (_b = ReactNativeRuntime.TurboModuleRegistry) !== null && _b !== void 0 ? _b : null;
+const MODULE_NAME = "BuboWalletSmoke";
+function resolveNativeModule() {
+    const turboGet = typeof (TurboModuleRegistry === null || TurboModuleRegistry === void 0 ? void 0 : TurboModuleRegistry.get) === "function"
+        ? TurboModuleRegistry.get
+        : null;
+    const turboModule = turboGet
+        ? turboGet(MODULE_NAME)
+        : null;
+    if (turboModule) {
+        return turboModule;
+    }
+    const legacyModule = NativeModules[MODULE_NAME];
+    return legacyModule !== null && legacyModule !== void 0 ? legacyModule : null;
+}
+function missingModuleHint() {
+    return [
+        `Native module "${MODULE_NAME}" is not linked.`,
+        "Expected iOS podspec: node_modules/@bubolabs/wallet-rn-sdk/BuboWalletRnSdk.podspec",
+        "Expected Android package: com.bubo.wallet.BuboWalletSmokePackage",
+        "If you are on iOS, run pod install and rebuild the app.",
+    ].join(" ");
+}
+function getBuboWalletSmokeModule() {
+    const mod = resolveNativeModule();
+    if (!mod) {
+        throw new types_1.WalletSmokeError("MODULE_NOT_LINKED", missingModuleHint());
+    }
+    return mod;
+}

package/dist/smoke.d.ts

@@ -0,0 +1,4 @@
+import { WalletSmokeResult } from "./types";
+export declare function runSmoke(): Promise<WalletSmokeResult>;
+export declare function runBtcSmoke(): Promise<WalletSmokeResult>;
+//# sourceMappingURL=smoke.d.ts.map

package/dist/smoke.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smoke.d.ts","sourceRoot":"","sources":["../src/smoke.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,iBAAiB,EAClB,MAAM,SAAS,CAAC;AAqGjB,wBAAsB,QAAQ,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAO3D;AAED,wBAAsB,WAAW,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAO9D"}

package/dist/smoke.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSmoke = runSmoke;
+exports.runBtcSmoke = runBtcSmoke;
+const native_1 = require("./native");
+const types_1 = require("./types");
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}
+function toSupportedChainInfo(value, index) {
+    if (!isObject(value)) {
+        throw new types_1.WalletSmokeError("INVALID_RESULT", `supportedChains[${index}] is not an object`, value);
+    }
+    const chainId = value.chainId;
+    const capabilities = value.capabilities;
+    if (typeof chainId !== "string") {
+        throw new types_1.WalletSmokeError("INVALID_RESULT", `supportedChains[${index}].chainId must be a string`, value);
+    }
+    if (!Array.isArray(capabilities) || !capabilities.every((c) => typeof c === "string")) {
+        throw new types_1.WalletSmokeError("INVALID_RESULT", `supportedChains[${index}].capabilities must be string[]`, value);
+    }
+    return {
+        chainId,
+        capabilities,
+    };
+}
+function normalizeSmokeResult(raw) {
+    if (!isObject(raw)) {
+        throw new types_1.WalletSmokeError("INVALID_RESULT", "native result is not an object", raw);
+    }
+    if (!Array.isArray(raw.supportedChains)) {
+        throw new types_1.WalletSmokeError("INVALID_RESULT", "native result.supportedChains must be an array", raw);
+    }
+    const supportedChains = raw.supportedChains.map(toSupportedChainInfo);
+    if (typeof raw.deriveChainId !== "string" || raw.deriveChainId.length === 0) {
+        throw new types_1.WalletSmokeError("INVALID_RESULT", "native result.deriveChainId must be a non-empty string", raw);
+    }
+    if (typeof raw.derivedAddress !== "string" || raw.derivedAddress.length === 0) {
+        throw new types_1.WalletSmokeError("INVALID_RESULT", "native result.derivedAddress must be a non-empty string", raw);
+    }
+    if (raw.signChainId !== null && typeof raw.signChainId !== "string") {
+        throw new types_1.WalletSmokeError("INVALID_RESULT", "native result.signChainId must be string | null", raw);
+    }
+    if (raw.signedTxHex !== null && typeof raw.signedTxHex !== "string") {
+        throw new types_1.WalletSmokeError("INVALID_RESULT", "native result.signedTxHex must be string | null", raw);
+    }
+    return {
+        supportedChains,
+        deriveChainId: raw.deriveChainId,
+        derivedAddress: raw.derivedAddress,
+        signChainId: raw.signChainId,
+        signedTxHex: raw.signedTxHex,
+    };
+}
+function mapNativeError(error) {
+    if (error instanceof types_1.WalletSmokeError) {
+        return error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("btc buildAndSign not available")) {
+        return new types_1.WalletSmokeError("BTC_SIGN_UNAVAILABLE", message, error);
+    }
+    return new types_1.WalletSmokeError("NATIVE_ERROR", message, error);
+}
+async function runSmoke() {
+    try {
+        const result = await (0, native_1.getBuboWalletSmokeModule)().runSmoke();
+        return normalizeSmokeResult(result);
+    }
+    catch (error) {
+        throw mapNativeError(error);
+    }
+}
+async function runBtcSmoke() {
+    try {
+        const result = await (0, native_1.getBuboWalletSmokeModule)().runBtcSmoke();
+        return normalizeSmokeResult(result);
+    }
+    catch (error) {
+        throw mapNativeError(error);
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,18 @@
+export type SupportedChainInfo = {
+    chainId: string;
+    capabilities: string[];
+};
+export type WalletSmokeResult = {
+    supportedChains: SupportedChainInfo[];
+    deriveChainId: string;
+    derivedAddress: string;
+    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;
+    readonly causeValue?: unknown;
+    constructor(code: WalletSmokeErrorCode, message: string, causeValue?: unknown);
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +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"}

package/dist/types.js

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

package/ios/BuboWalletSmoke.swift

@@ -0,0 +1,110 @@
+import Foundation
+
+public struct WalletSmokeResult {
+    public let supportedChains: [SupportedChainInfo]
+    public let deriveChainId: String
+    public let derivedAddress: String
+    public let signChainId: String?
+    public let signedTxHex: String?
+
+    public init(
+        supportedChains: [SupportedChainInfo],
+        deriveChainId: String,
+        derivedAddress: String,
+        signChainId: String?,
+        signedTxHex: String?
+    ) {
+        self.supportedChains = supportedChains
+        self.deriveChainId = deriveChainId
+        self.derivedAddress = derivedAddress
+        self.signChainId = signChainId
+        self.signedTxHex = signedTxHex
+    }
+}
+
+public enum WalletSmokeError: Error {
+    case noSupportedChains
+    case noDeriveCapability
+    case btcSignUnavailable
+}
+
+public enum WalletLibSmoke {
+    private static let sampleMnemonic =
+        "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about"
+
+    private static let btcSmokePayload = """
+    {
+      "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
+    }
+    """.data(using: .utf8)!
+
+    public static func runSmoke() throws -> WalletSmokeResult {
+        let lib = WalletLib()
+        try lib.`init`()
+
+        let chains = try lib.listSupportedChains()
+        guard !chains.isEmpty else {
+            throw WalletSmokeError.noSupportedChains
+        }
+        guard let deriveChain = chains.first(where: { $0.capabilities.contains("deriveAddress") }) else {
+            throw WalletSmokeError.noDeriveCapability
+        }
+
+        let address = try lib.deriveAddress(
+            chainId: deriveChain.chainId,
+            mnemonic: sampleMnemonic,
+            account: 0,
+            index: 0,
+            passphrase: nil
+        )
+
+        guard chains.contains(where: { $0.chainId == "btc" && $0.capabilities.contains("buildAndSign") }) else {
+            return WalletSmokeResult(
+                supportedChains: chains,
+                deriveChainId: deriveChain.chainId,
+                derivedAddress: address,
+                signChainId: nil,
+                signedTxHex: nil
+            )
+        }
+
+        let signed = try lib.buildAndSign(
+            chainId: "btc",
+            mnemonic: sampleMnemonic,
+            txPayload: btcSmokePayload
+        )
+        return WalletSmokeResult(
+            supportedChains: chains,
+            deriveChainId: deriveChain.chainId,
+            derivedAddress: address,
+            signChainId: "btc",
+            signedTxHex: signed.hexEncodedString()
+        )
+    }
+
+    public static func runBtcSmoke() throws -> WalletSmokeResult {
+        let result = try runSmoke()
+        guard result.signChainId == "btc", result.signedTxHex != nil else {
+            throw WalletSmokeError.btcSignUnavailable
+        }
+        return result
+    }
+}
+
+private extension Data {
+    func hexEncodedString() -> String {
+        map { String(format: "%02x", $0) }.joined()
+    }
+}

package/ios/BuboWalletSmokeModule.m

@@ -0,0 +1,11 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(BuboWalletSmoke, NSObject)
+
+RCT_EXTERN_METHOD(runSmoke:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(runBtcSmoke:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+@end

package/ios/BuboWalletSmokeModule.swift

@@ -0,0 +1,51 @@
+import Foundation
+import React
+
+@objc(BuboWalletSmoke)
+public final class BuboWalletSmoke: NSObject {
+    @objc
+    public static func requiresMainQueueSetup() -> Bool {
+        false
+    }
+
+    @objc(runSmoke:rejecter:)
+    public func runSmoke(
+        _ resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        do {
+            let result = try WalletLibSmoke.runSmoke()
+            resolve(Self.serialize(result))
+        } catch {
+            reject("BUBO_WALLET_SMOKE", String(describing: error), error)
+        }
+    }
+
+    @objc(runBtcSmoke:rejecter:)
+    public func runBtcSmoke(
+        _ resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        do {
+            let result = try WalletLibSmoke.runBtcSmoke()
+            resolve(Self.serialize(result))
+        } catch {
+            reject("BUBO_WALLET_SMOKE", String(describing: error), error)
+        }
+    }
+
+    private static func serialize(_ result: WalletSmokeResult) -> [String: Any] {
+        return [
+            "supportedChains": result.supportedChains.map {
+                [
+                    "chainId": $0.chainId,
+                    "capabilities": $0.capabilities,
+                ]
+            },
+            "deriveChainId": result.deriveChainId,
+            "derivedAddress": result.derivedAddress,
+            "signChainId": result.signChainId as Any,
+            "signedTxHex": result.signedTxHex as Any,
+        ]
+    }
+}