@vultisig/walletcore-native 0.1.1

package/android/build.gradle

@@ -0,0 +1,68 @@
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+apply plugin: 'maven-publish'
+
+group = 'expo.modules.walletcore'
+version = '0.1.0'
+
+android {
+    namespace "expo.modules.walletcore"
+
+    compileSdkVersion safeExtGet("compileSdkVersion", 34)
+
+    defaultConfig {
+        minSdkVersion safeExtGet("minSdkVersion", 23)
+        targetSdkVersion safeExtGet("targetSdkVersion", 34)
+    }
+
+    publishing {
+        singleVariant("release") {
+            withSourcesJar()
+        }
+    }
+
+    lint {
+        abortOnError false
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = JavaVersion.VERSION_17.majorVersion
+    }
+
+    sourceSets {
+        main.java.srcDirs += 'src/main/java'
+    }
+}
+
+repositories {
+    mavenCentral()
+    maven {
+        url = uri("https://maven.pkg.github.com/trustwallet/wallet-core")
+        credentials {
+            username = System.getenv("GITHUB_USER")
+                ?: System.getenv("GITHUB_ACTOR")
+                ?: "token"
+            password = System.getenv("GITHUB_TOKEN")
+                ?: System.getenv("GH_TOKEN")
+                ?: ""
+        }
+        content {
+            includeGroup("com.trustwallet")
+        }
+    }
+}
+
+dependencies {
+    implementation project(':expo-modules-core')
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${safeExtGet('kotlinVersion', '1.8.10')}"
+    implementation 'com.trustwallet:wallet-core:4.3.22'
+}
+
+def safeExtGet(prop, fallback) {
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}

package/android/src/main/java/expo/modules/walletcore/ExpoWalletCoreModule.kt

@@ -0,0 +1,349 @@
+package expo.modules.walletcore
+
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import wallet.core.jni.*
+
+class ExpoWalletCoreModule : Module() {
+    // NOTE: nextHandle and the key/wallet maps are accessed from the Expo module
+    // dispatch thread. Expo modules run function handlers on a single background
+    // serial queue, so concurrent mutation is not expected. If this assumption
+    // ever changes (e.g. concurrent async functions are introduced), these maps
+    // must be protected with a lock or replaced with thread-safe collections.
+    private var nextHandle = 1
+    private val publicKeys = mutableMapOf<Int, PublicKey>()
+    private val privateKeys = mutableMapOf<Int, PrivateKey>()
+    private val hdWallets = mutableMapOf<Int, HDWallet>()
+
+    init {
+        System.loadLibrary("TrustWalletCore")
+    }
+
+    private fun storePublicKey(pk: PublicKey): Int {
+        val h = nextHandle++; publicKeys[h] = pk; return h
+    }
+    private fun storePrivateKey(pk: PrivateKey): Int {
+        val h = nextHandle++; privateKeys[h] = pk; return h
+    }
+    private fun storeHDWallet(w: HDWallet): Int {
+        val h = nextHandle++; hdWallets[h] = w; return h
+    }
+
+    override fun definition() = ModuleDefinition {
+        Name("ExpoWalletCore")
+
+        // CoinType — map camelCase names from TS to WalletCore enum values.
+        // Uses an explicit mapping (like iOS) instead of valueOf() to avoid
+        // casing mismatches (e.g. "bitcoinCash".uppercase() → "BITCOINCASH" ≠ "BITCOIN_CASH").
+        Function("coinTypeValue") { name: String ->
+            val mapping = mapOf(
+                "bitcoin" to CoinType.BITCOIN,
+                "litecoin" to CoinType.LITECOIN,
+                "dogecoin" to CoinType.DOGECOIN,
+                "dash" to CoinType.DASH,
+                "ethereum" to CoinType.ETHEREUM,
+                "cosmos" to CoinType.COSMOS,
+                "zcash" to CoinType.ZCASH,
+                "ripple" to CoinType.XRP,
+                "xrp" to CoinType.XRP,
+                "bitcoinCash" to CoinType.BITCOINCASH,
+                "tron" to CoinType.TRON,
+                "terra" to CoinType.TERRA,
+                "polkadot" to CoinType.POLKADOT,
+                "ton" to CoinType.TON,
+                "solana" to CoinType.SOLANA,
+                "thorchain" to CoinType.THORCHAIN,
+                "sui" to CoinType.SUI,
+                "cardano" to CoinType.CARDANO,
+                "smartChain" to CoinType.SMARTCHAIN,
+                "arbitrum" to CoinType.ARBITRUM,
+                "avalancheCChain" to CoinType.AVALANCHECCHAIN,
+                "base" to CoinType.BASE,
+                "polygon" to CoinType.POLYGON,
+                "optimism" to CoinType.OPTIMISM,
+                "cronosChain" to CoinType.CRONOSCHAIN,
+                "blast" to CoinType.BLAST,
+                "zksync" to CoinType.ZKSYNC,
+                "osmosis" to CoinType.OSMOSIS,
+                "terraV2" to CoinType.TERRAV2,
+                "noble" to CoinType.NOBLE,
+                "kujira" to CoinType.KUJIRA,
+                "dydx" to CoinType.DYDX,
+                "akash" to CoinType.AKASH,
+                "mantle" to CoinType.MANTLE,
+                "sei" to CoinType.SEI,
+            )
+            val ct = mapping[name] ?: throw Exception("Unknown CoinType name: $name")
+            ct.value()
+        }
+
+        // CoinTypeExt
+        Function("derivationPath") { coinType: Int ->
+            CoinType.createFromValue(coinType).derivationPath()
+        }
+
+        Function("deriveAddressFromPublicKey") { coinType: Int, publicKeyHandle: Int ->
+            val pk = publicKeys[publicKeyHandle] ?: throw Exception("Invalid PublicKey handle")
+            CoinType.createFromValue(coinType).deriveAddressFromPublicKey(pk)
+        }
+
+        Function("chainId") { coinType: Int ->
+            CoinType.createFromValue(coinType).chainId()
+        }
+
+        Function("ss58Prefix") { coinType: Int ->
+            CoinType.createFromValue(coinType).ss58Prefix()
+        }
+
+        // PublicKey
+        Function("publicKeyCreateWithData") { dataBase64: String, typeValue: Int ->
+            val data = android.util.Base64.decode(dataBase64, android.util.Base64.NO_WRAP)
+            val pkType = PublicKeyType.createFromValue(typeValue)
+            val pk = PublicKey(data, pkType)
+            storePublicKey(pk)
+        }
+
+        Function("publicKeyData") { handle: Int ->
+            val pk = publicKeys[handle] ?: throw Exception("Invalid PublicKey handle")
+            android.util.Base64.encodeToString(pk.data(), android.util.Base64.NO_WRAP)
+        }
+
+        Function("publicKeyUncompressed") { handle: Int ->
+            val pk = publicKeys[handle] ?: throw Exception("Invalid PublicKey handle")
+            storePublicKey(pk.uncompressed())
+        }
+
+        Function("publicKeyCompressed") { handle: Int ->
+            val pk = publicKeys[handle] ?: throw Exception("Invalid PublicKey handle")
+            storePublicKey(pk.compressed())
+        }
+
+        Function("publicKeyVerify") { handle: Int, signatureBase64: String, messageBase64: String ->
+            val pk = publicKeys[handle] ?: return@Function false
+            val sig = android.util.Base64.decode(signatureBase64, android.util.Base64.NO_WRAP)
+            val msg = android.util.Base64.decode(messageBase64, android.util.Base64.NO_WRAP)
+            pk.verify(sig, msg)
+        }
+
+        Function("publicKeyVerifyAsDER") { handle: Int, signatureBase64: String, messageBase64: String ->
+            val pk = publicKeys[handle] ?: return@Function false
+            val sig = android.util.Base64.decode(signatureBase64, android.util.Base64.NO_WRAP)
+            val msg = android.util.Base64.decode(messageBase64, android.util.Base64.NO_WRAP)
+            pk.verifyAsDER(sig, msg)
+        }
+
+        Function("freePublicKey") { handle: Int -> publicKeys.remove(handle); Unit }
+
+        // AnyAddress
+        Function("anyAddressIsValid") { address: String, coinType: Int ->
+            AnyAddress.isValid(address, CoinType.createFromValue(coinType))
+        }
+
+        Function("anyAddressIsValidBech32") { address: String, coinType: Int, hrp: String ->
+            AnyAddress.isValidBech32(address, CoinType.createFromValue(coinType), hrp)
+        }
+
+        // The Trust Wallet Core Android JNI binding does not expose an SS58-prefix
+        // overload on AnyAddress. Throw rather than returning a potentially incorrect
+        // result, so callers know this code path is not supported yet.
+        Function("anyAddressIsValidSS58") { _address: String, _coinType: Int, _ss58Prefix: Int ->
+            throw Exception(
+                "anyAddressIsValidSS58 is not supported on Android: the JNI binding " +
+                "does not expose an SS58-prefix overload. Use anyAddressIsValid as a " +
+                "fallback (ignores ss58Prefix) or implement a pure-Kotlin SS58 check."
+            )
+        }
+
+        Function("anyAddressCreateWithString") { address: String, coinType: Int ->
+            AnyAddress(address, CoinType.createFromValue(coinType)).description()
+        }
+
+        Function("anyAddressCreateBech32WithPublicKey") { publicKeyHandle: Int, coinType: Int, hrp: String ->
+            val pk = publicKeys[publicKeyHandle] ?: throw Exception("Invalid PublicKey handle")
+            AnyAddress(pk, CoinType.createFromValue(coinType), hrp).description()
+        }
+
+        Function("anyAddressCreateBech32") { address: String, coinType: Int, hrp: String ->
+            AnyAddress(address, CoinType.createFromValue(coinType), hrp).description()
+        }
+
+        Function("anyAddressData") { address: String, coinType: Int ->
+            val addr = AnyAddress(address, CoinType.createFromValue(coinType))
+            android.util.Base64.encodeToString(addr.data(), android.util.Base64.NO_WRAP)
+        }
+
+        // TransactionCompiler
+        Function("preImageHashes") { coinType: Int, txInputDataBase64: String ->
+            val txData = android.util.Base64.decode(txInputDataBase64, android.util.Base64.NO_WRAP)
+            val result = TransactionCompiler.preImageHashes(CoinType.createFromValue(coinType), txData)
+            android.util.Base64.encodeToString(result, android.util.Base64.NO_WRAP)
+        }
+
+        Function("compileWithSignatures") { coinType: Int, txInputDataBase64: String, signaturesBase64: List<String>, publicKeysBase64: List<String> ->
+            val txData = android.util.Base64.decode(txInputDataBase64, android.util.Base64.NO_WRAP)
+            val signatures = DataVector()
+            signaturesBase64.forEach { s ->
+                signatures.add(android.util.Base64.decode(s, android.util.Base64.NO_WRAP))
+            }
+            val pubkeys = DataVector()
+            publicKeysBase64.forEach { p ->
+                pubkeys.add(android.util.Base64.decode(p, android.util.Base64.NO_WRAP))
+            }
+            val result = TransactionCompiler.compileWithSignatures(
+                CoinType.createFromValue(coinType), txData, signatures, pubkeys
+            )
+            android.util.Base64.encodeToString(result, android.util.Base64.NO_WRAP)
+        }
+
+        // AnySigner
+        Function("anySignerPlan") { txInputDataBase64: String, coinType: Int ->
+            val txData = android.util.Base64.decode(txInputDataBase64, android.util.Base64.NO_WRAP)
+            val result = AnySigner.plan(txData, CoinType.createFromValue(coinType))
+            android.util.Base64.encodeToString(result, android.util.Base64.NO_WRAP)
+        }
+
+        // HDWallet
+        Function("hdWalletCreate") { mnemonic: String, passphrase: String ->
+            storeHDWallet(HDWallet(mnemonic, passphrase))
+        }
+
+        Function("hdWalletGetMasterKey") { handle: Int, curveValue: Int ->
+            val wallet = hdWallets[handle] ?: throw Exception("Invalid HDWallet handle")
+            storePrivateKey(wallet.getMasterKey(Curve.createFromValue(curveValue)))
+        }
+
+        Function("hdWalletGetKeyForCoin") { handle: Int, coinType: Int ->
+            val wallet = hdWallets[handle] ?: throw Exception("Invalid HDWallet handle")
+            storePrivateKey(wallet.getKeyForCoin(CoinType.createFromValue(coinType)))
+        }
+
+        Function("hdWalletGetKeyDerivation") { handle: Int, coinType: Int, derivationValue: Int ->
+            val wallet = hdWallets[handle] ?: throw Exception("Invalid HDWallet handle")
+            storePrivateKey(wallet.getKeyDerivation(CoinType.createFromValue(coinType), Derivation.createFromValue(derivationValue)))
+        }
+
+        Function("hdWalletGetAddressDerivation") { handle: Int, coinType: Int, derivationValue: Int ->
+            val wallet = hdWallets[handle] ?: throw Exception("Invalid HDWallet handle")
+            wallet.getAddressDerivation(CoinType.createFromValue(coinType), Derivation.createFromValue(derivationValue))
+        }
+
+        Function("hdWalletGetKey") { handle: Int, coinType: Int, derivationPath: String ->
+            val wallet = hdWallets[handle] ?: throw Exception("Invalid HDWallet handle")
+            storePrivateKey(wallet.getKey(CoinType.createFromValue(coinType), derivationPath))
+        }
+
+        Function("hdWalletGetAddressForCoin") { handle: Int, coinType: Int ->
+            val wallet = hdWallets[handle] ?: throw Exception("Invalid HDWallet handle")
+            wallet.getAddressForCoin(CoinType.createFromValue(coinType))
+        }
+
+        Function("hdWalletGetExtendedPrivateKey") { handle: Int, purposeValue: Int, coinType: Int, versionValue: Int ->
+            val wallet = hdWallets[handle] ?: throw Exception("Invalid HDWallet handle")
+            wallet.getExtendedPrivateKey(
+                Purpose.createFromValue(purposeValue),
+                CoinType.createFromValue(coinType),
+                HDVersion.createFromValue(versionValue)
+            )
+        }
+
+        Function("freeHDWallet") { handle: Int -> hdWallets.remove(handle); Unit }
+
+        // PrivateKey
+        Function("privateKeyCreate") { -> storePrivateKey(PrivateKey()) }
+
+        Function("privateKeyData") { handle: Int ->
+            val key = privateKeys[handle] ?: throw Exception("Invalid PrivateKey handle")
+            android.util.Base64.encodeToString(key.data(), android.util.Base64.NO_WRAP)
+        }
+
+        Function("privateKeyGetPublicKeySecp256k1") { handle: Int, compressed: Boolean ->
+            val key = privateKeys[handle] ?: throw Exception("Invalid PrivateKey handle")
+            storePublicKey(key.getPublicKeySecp256k1(compressed))
+        }
+
+        Function("privateKeyGetPublicKeyEd25519") { handle: Int ->
+            val key = privateKeys[handle] ?: throw Exception("Invalid PrivateKey handle")
+            storePublicKey(key.getPublicKeyEd25519())
+        }
+
+        Function("freePrivateKey") { handle: Int -> privateKeys.remove(handle); Unit }
+
+        // HexCoding
+        Function("hexDecode") { hex: String ->
+            require(hex.length % 2 == 0) { "Hex string must have even length, got ${hex.length}" }
+            require(hex.all { it in '0'..'9' || it in 'a'..'f' || it in 'A'..'F' }) {
+                "Hex string contains non-hex characters"
+            }
+            val bytes = hex.chunked(2).map { it.toInt(16).toByte() }.toByteArray()
+            android.util.Base64.encodeToString(bytes, android.util.Base64.NO_WRAP)
+        }
+
+        Function("hexEncode") { dataBase64: String ->
+            val data = android.util.Base64.decode(dataBase64, android.util.Base64.NO_WRAP)
+            data.joinToString("") { "%02x".format(it) }
+        }
+
+        // Bech32
+        Function("bech32Encode") { hrp: String, dataBase64: String ->
+            val data = android.util.Base64.decode(dataBase64, android.util.Base64.NO_WRAP)
+            Bech32.encode(hrp, data)
+        }
+
+        // BitcoinScript
+        Function("bitcoinScriptBuildPayToWitnessPubkeyHash") { hashBase64: String ->
+            val hash = android.util.Base64.decode(hashBase64, android.util.Base64.NO_WRAP)
+            val script = BitcoinScript.buildPayToWitnessPubkeyHash(hash)
+            android.util.Base64.encodeToString(script.data(), android.util.Base64.NO_WRAP)
+        }
+
+        Function("bitcoinScriptBuildPayToPublicKeyHash") { hashBase64: String ->
+            val hash = android.util.Base64.decode(hashBase64, android.util.Base64.NO_WRAP)
+            val script = BitcoinScript.buildPayToPublicKeyHash(hash)
+            android.util.Base64.encodeToString(script.data(), android.util.Base64.NO_WRAP)
+        }
+
+        Function("bitcoinScriptLockScriptForAddress") { address: String, coinType: Int ->
+            val script = BitcoinScript.lockScriptForAddress(address, CoinType.createFromValue(coinType))
+            android.util.Base64.encodeToString(script.data(), android.util.Base64.NO_WRAP)
+        }
+
+        Function("bitcoinScriptHashTypeForCoin") { coinType: Int ->
+            BitcoinScript.hashTypeForCoin(CoinType.createFromValue(coinType)).toInt()
+        }
+
+        // EthereumAbi
+        // WARNING: Only the 4-byte function selector is encoded. Full ABI encoding
+        // requires parsing param types/values and calling fn.addParam*(). Throws if
+        // the caller passes non-empty params to avoid silent data loss.
+        // TODO: Accept a structured param list (e.g. JSON) and call fn.addParam*().
+        Function("ethereumAbiEncode") { functionName: String, params: String ->
+            require(params.isEmpty()) {
+                "ethereumAbiEncode does not yet support params — only the 4-byte selector is encoded"
+            }
+            val fn = EthereumAbiFunction(functionName)
+            val encoded = EthereumAbi.encode(fn)
+            android.util.Base64.encodeToString(encoded, android.util.Base64.NO_WRAP)
+        }
+
+        // EthereumAbi — typed encoding
+        Function("ethereumAbiEncodeTyped") { messageJson: String ->
+            val encoded = EthereumAbi.encodeTyped(messageJson)
+            encoded.joinToString("") { "%02x".format(it) }
+        }
+
+        // Mnemonic
+        Function("mnemonicIsValid") { mnemonic: String ->
+            Mnemonic.isValid(mnemonic)
+        }
+
+        // TONAddressConverter
+        Function("tonAddressToUserFriendly") { address: String ->
+            TONAddressConverter.toUserFriendly(address)
+        }
+
+        // SolanaAddress
+        Function("solanaAddressDefaultTokenAddress") { address: String, tokenMintAddress: String ->
+            SolanaAddress(address).defaultTokenAddress(tokenMintAddress)
+        }
+    }
+}

package/expo-module.config.json

@@ -0,0 +1,5 @@
+{
+  "platforms": ["apple", "android"],
+  "apple": { "modules": ["ExpoWalletCoreModule"] },
+  "android": { "modules": ["expo.modules.walletcore.ExpoWalletCoreModule"] }
+}

package/ios/ExpoWalletCore.podspec

@@ -0,0 +1,17 @@
+Pod::Spec.new do |s|
+  s.name           = 'ExpoWalletCore'
+  s.version        = '0.1.0'
+  s.summary        = 'Native WalletCore bridge for Vultisig SDK'
+  s.description    = 'Expo native module wrapping TrustWallet WalletCore for chain operations'
+  s.homepage       = 'https://github.com/vultisig/vultisig-sdk'
+  s.license        = 'MIT'
+  s.author         = 'Vultisig'
+  s.source         = { git: 'https://github.com/vultisig/vultisig-sdk.git' }
+
+  s.platform       = :ios, '15.1'
+  s.swift_version  = '5.4'
+  s.source_files   = '*.swift'
+
+  s.dependency 'ExpoModulesCore'
+  s.dependency 'TrustWalletCore', '4.3.22'
+end