@bubolabs/wallet-rn-sdk 0.1.2

package/BuboWalletRnSdk.podspec

@@ -0,0 +1,29 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "BuboWalletRnSdk"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = "https://github.com/bubo/wallet-rn-sdk"
+  s.license      = "MIT"
+  s.author       = { "Bubo" => "dev@bubo.example" }
+  s.source       = { :path => "." }
+  s.platforms    = { :ios => "13.4" }
+  s.static_framework = true
+
+  s.source_files = "ios/**/*.{swift,m,h}"
+  s.public_header_files = "ios/bubo_wallet_ffiFFI.h"
+  s.preserve_paths = "ios/bubo_wallet_ffiFFI.modulemap", "ios/lib/BuboWalletFFI.xcframework/**/*"
+  s.vendored_frameworks = "ios/lib/BuboWalletFFI.xcframework"
+
+  s.dependency "React-Core"
+
+  s.pod_target_xcconfig = {
+    "DEFINES_MODULE" => "YES",
+    "SWIFT_VERSION" => "5.0",
+    "HEADER_SEARCH_PATHS" => "$(inherited) \"${PODS_TARGET_SRCROOT}/ios\"",
+    "OTHER_SWIFT_FLAGS" => "$(inherited) -Xcc -fmodule-map-file=${PODS_TARGET_SRCROOT}/ios/bubo_wallet_ffiFFI.modulemap"
+  }
+end

package/README.md

@@ -0,0 +1,71 @@
+# @bubolabs/wallet-rn-sdk
+
+Minimal React Native smoke SDK for the UniFFI wallet library.
+
+This package is a standard React Native native module layout:
+
+- `android/` React Native Android library module (autolinked)
+- `ios/` Pod sources + vendored `BuboWalletFFI.xcframework` (autolinked)
+- `react-native.config.js` for Android package registration
+
+## API
+
+- `runSmoke()`
+- `runBtcSmoke()`
+
+Both methods call native module `BuboWalletSmoke` and return:
+
+```ts
+type WalletSmokeResult = {
+  supportedChains: Array<{ chainId: string; capabilities: string[] }>;
+  deriveChainId: string;
+  derivedAddress: string;
+  signChainId: string | null;
+  signedTxHex: string | null;
+};
+```
+
+## Example
+
+```ts
+import { runSmoke } from "@bubolabs/wallet-rn-sdk";
+
+const result = await runSmoke();
+console.log(result.deriveChainId, result.derivedAddress);
+```
+
+## Install
+
+```bash
+npm install @bubolabs/wallet-rn-sdk
+```
+
+iOS:
+
+```bash
+cd ios && pod install
+```
+
+## Distribution Scripts
+
+```bash
+cd ../..
+./scripts/package-rn-sdk.sh
+```
+
+Builds a publishable tarball and verifies runtime assets are present/synced.
+
+```bash
+./scripts/verify-rn-sdk-distribution.sh
+```
+
+Installs the tarball into `example/` and verifies iOS/Android native builds.
+
+```bash
+./scripts/publish-rn-sdk.sh --dry-run
+./scripts/publish-rn-sdk.sh --publish --tag latest
+```
+
+Publish wrapper:
+- default is dry-run
+- real publish requires `--publish`

package/android/build.gradle

@@ -0,0 +1,46 @@
+buildscript {
+  ext.safeExtGet = { prop, fallback ->
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+  }
+}
+
+apply plugin: "com.android.library"
+apply plugin: "org.jetbrains.kotlin.android"
+
+android {
+  namespace "com.bubo.wallet"
+  compileSdkVersion safeExtGet("compileSdkVersion", 35)
+
+  defaultConfig {
+    minSdkVersion safeExtGet("minSdkVersion", 24)
+    targetSdkVersion safeExtGet("targetSdkVersion", 34)
+    consumerProguardFiles "consumer-rules.pro"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  kotlinOptions {
+    jvmTarget = "17"
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs = ["src/main/java"]
+      jniLibs.srcDirs = ["src/main/jniLibs"]
+      manifest.srcFile "src/main/AndroidManifest.xml"
+    }
+  }
+}
+
+repositories {
+  google()
+  mavenCentral()
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "net.java.dev.jna:jna:5.14.0@aar"
+}

package/android/consumer-rules.pro

@@ -0,0 +1 @@
+# Consumer ProGuard rules can be added here when needed.

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" />

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

@@ -0,0 +1,65 @@
+package com.bubo.wallet
+
+import com.facebook.react.bridge.Arguments
+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.WritableArray
+import com.facebook.react.bridge.WritableMap
+import uniffi.bubo_wallet_ffi.SupportedChainInfo
+import uniffi.bubo_wallet_ffi.WalletLibSmoke
+import uniffi.bubo_wallet_ffi.WalletSmokeResult
+
+class BuboWalletSmokeModule(
+    reactContext: ReactApplicationContext
+) : ReactContextBaseJavaModule(reactContext) {
+
+    override fun getName(): String = "BuboWalletSmoke"
+
+    @ReactMethod
+    fun runSmoke(promise: Promise) {
+        try {
+            val result = WalletLibSmoke.runSmoke()
+            promise.resolve(toWritableMap(result))
+        } catch (t: Throwable) {
+            promise.reject("BUBO_WALLET_SMOKE", t.message, t)
+        }
+    }
+
+    @ReactMethod
+    fun runBtcSmoke(promise: Promise) {
+        try {
+            val result = WalletLibSmoke.runBtcSmoke()
+            promise.resolve(toWritableMap(result))
+        } catch (t: Throwable) {
+            promise.reject("BUBO_WALLET_SMOKE", t.message, t)
+        }
+    }
+
+    private fun toWritableMap(result: WalletSmokeResult): WritableMap {
+        val map = Arguments.createMap()
+        map.putArray("supportedChains", toWritableChains(result.supportedChains))
+        map.putString("deriveChainId", result.deriveChainId)
+        map.putString("derivedAddress", result.derivedAddress)
+        map.putString("signChainId", result.signChainId)
+        map.putString("signedTxHex", result.signedTxHex)
+        return map
+    }
+
+    private fun toWritableChains(chains: List<SupportedChainInfo>): WritableArray {
+        val out = Arguments.createArray()
+        for (chain in chains) {
+            val item = Arguments.createMap()
+            item.putString("chainId", chain.chainId)
+
+            val caps = Arguments.createArray()
+            for (cap in chain.capabilities) {
+                caps.pushString(cap)
+            }
+            item.putArray("capabilities", caps)
+            out.pushMap(item)
+        }
+        return out
+    }
+}

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

@@ -0,0 +1,18 @@
+package com.bubo.wallet
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class BuboWalletSmokePackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(BuboWalletSmokeModule(reactContext))
+    }
+
+    override fun createViewManagers(
+        reactContext: ReactApplicationContext
+    ): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}

package/android/src/main/java/uniffi/bubo_wallet_ffi/WalletLibSmoke.kt

@@ -0,0 +1,92 @@
+package uniffi.bubo_wallet_ffi
+
+data class WalletSmokeResult(
+    val supportedChains: List<SupportedChainInfo>,
+    val deriveChainId: String,
+    val derivedAddress: String,
+    val signChainId: String?,
+    val signedTxHex: String?,
+)
+
+object WalletLibSmoke {
+    private const val SAMPLE_MNEMONIC =
+        "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about"
+
+    private val BTC_SMOKE_PAYLOAD = """
+        {
+          "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
+        }
+    """.trimIndent().toByteArray(Charsets.UTF_8)
+
+    fun runSmoke(): WalletSmokeResult {
+        val wallet = WalletLib()
+        try {
+            wallet.init()
+            val chains = wallet.listSupportedChains()
+            require(chains.isNotEmpty()) { "no supported chains after init()" }
+
+            val deriveChain = chains.firstOrNull { it.capabilities.contains("deriveAddress") }
+                ?: error("no chain exposes deriveAddress capability")
+            val address = wallet.deriveAddress(
+                deriveChain.chainId,
+                SAMPLE_MNEMONIC,
+                0u,
+                0u,
+                null,
+            )
+
+            val btcSignCap = chains.firstOrNull { chain ->
+                chain.chainId == "btc" && chain.capabilities.contains("buildAndSign")
+            }
+            if (btcSignCap == null) {
+                return WalletSmokeResult(
+                    supportedChains = chains,
+                    deriveChainId = deriveChain.chainId,
+                    derivedAddress = address,
+                    signChainId = null,
+                    signedTxHex = null,
+                )
+            }
+
+            val signed = wallet.buildAndSign("btc", SAMPLE_MNEMONIC, BTC_SMOKE_PAYLOAD)
+            return WalletSmokeResult(
+                supportedChains = chains,
+                deriveChainId = deriveChain.chainId,
+                derivedAddress = address,
+                signChainId = "btc",
+                signedTxHex = signed.toHex(),
+            )
+        } finally {
+            wallet.close()
+        }
+    }
+
+    fun runBtcSmoke(): WalletSmokeResult {
+        val result = runSmoke()
+        require(result.signChainId == "btc" && result.signedTxHex != null) {
+            "btc buildAndSign not available in current feature set"
+        }
+        return result
+    }
+}
+
+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()
+}