@chainberry/trust-wallet-core 1.0.2 → 2.0.0

package/README.md

@@ -2,7 +2,7 @@
 
 Expo native module wrapping [Trust Wallet Core](https://github.com/trustwallet/wallet-core) for HD wallet generation, address derivation, and transaction signing. Runs the real native library (Kotlin/JNI on Android, Swift on iOS) — not the WASM build, so it works fine under Hermes.
 
-Supported coins: Ethereum, Solana, BNB Smart Chain (see `SupportedCoin`).
+Supported chains: Ethereum, BNB Smart Chain, Polygon, Solana, Tron, TON, Bitcoin, Bitcoin Cash (address derivation only — see Security model), Litecoin, XRP (see `Chain`).
 
 ## Installation
 
@@ -35,30 +35,45 @@ Generate a token at github.com/settings/tokens → "classic" → check `read:pac
 
 ### iOS
 
-`WalletCore` is pulled in via CocoaPods (`s.dependency 'TrustWalletCore'`) — no extra auth needed, `pod install` handles it.
+`WalletCore` is pulled in via CocoaPods (`s.dependency 'TrustWalletCore'`) — no extra auth needed, `pod install` handles it. Biometric/passcode gating uses `LocalAuthentication` (system framework, no extra dependency).
+
+Android biometric gating additionally pulls in `androidx.biometric:biometric:1.1.0`.
 
 ## Usage
 
 ```ts
-import { generateWallet, restoreWallet, getAddressForCoin } from "@chainberry/trust-wallet-core";
+import { createWallet, importWallet, signTransaction, exportMnemonic } from "@chainberry/trust-wallet-core";
+
+const { walletId, addresses } = await createWallet(); // 128-bit / 12-word by default
+// addresses: { ethereum: "0x...", solana: "...", bnb: "0x...", bitcoin: "...", ... }
 
-const { mnemonic, wallets } = await generateWallet(); // 128-bit / 12-word by default
-// wallets: { ethereum: "0x...", solana: "...", bnb: "0x..." }
+const restored = await importWallet(mnemonic);
 
-const restored = await restoreWallet(mnemonic);
+// Triggers a native biometry/passcode prompt; only signed tx bytes/hex cross back to JS.
+const { signedTx } = await signTransaction(walletId, "ethereum", unsignedTx);
 
-const { address, privateKey } = await getAddressForCoin(mnemonic, "ethereum");
+// Explicit backup flow only — biometry/passcode gated.
+const mnemonic = await exportMnemonic(walletId);
 ```
 
 ## API
 
-- `generateWallet(strength = 128, passphrase = "")` — creates a new BIP-39 mnemonic (128 = 12 words, 256 = 24 words) and returns it along with the derived address for every supported coin.
-- `restoreWallet(mnemonic, passphrase = "")` — validates an existing mnemonic and returns the same shape as `generateWallet`. Throws if the mnemonic is invalid.
-- `getAddressForCoin(mnemonic, coin, passphrase = "")` — derives `{ address, privateKey }` for a single coin (`"ethereum" | "solana" | "bnb"`).
+- `createWallet(strength = 128, passphrase = "")` — generates a new BIP-39 mnemonic and persists it natively (Keychain on iOS / Keystore-backed file on Android, biometry-or-passcode gated). Returns `{ walletId, addresses }` — the mnemonic itself never leaves native code.
+- `importWallet(mnemonic, passphrase = "")` — validates and persists an existing mnemonic the same way. The `mnemonic` argument is a one-time exposure from the caller (e.g. a text-entry backup-restore screen); discard your own copy immediately after this call resolves.
+- `listWallets()` — returns `{ walletId, addresses }[]` for every persisted wallet, reading only the ungated metadata store. No biometric prompt.
+- `deleteWallet(walletId)` — removes the wallet's native key material and metadata entry. Irreversible; not biometric-gated (deleting reveals nothing, so this is a UX confirmation concern, not a key-secrecy one).
+- `signTransaction(walletId, chain, unsignedTx)` — triggers a native biometry/passcode prompt, then derives the key and signs entirely inside native code. Returns `{ signedTx, meta? }`; `meta` currently only carries TON's `txHash`.
+- `exportMnemonic(walletId)` — the one sanctioned mnemonic exposure. Biometry/passcode gated. Use only for an explicit "reveal recovery phrase" backup screen; don't hold the result in app state beyond that screen's lifetime.
+
+## Security model
+
+Mnemonic and derived private keys are generated, persisted, and used for signing entirely inside this module's native code (Swift/Kotlin) — they are never serialized back across the JS bridge, with the single exception of `exportMnemonic`'s explicit backup flow. This is a deliberate change from this module's earlier version, which returned raw private keys to JS on every address derivation; that let a compromised/malicious JS dependency, an attached JS debugger, or a JS-heap memory dump read wallet secrets in full. Now the JS runtime never holds them at all.
+
+Storage: one biometry-or-passcode-gated secret per wallet (`SecAccessControl` + iOS Keychain; a hardware-backed Android Keystore AES key gating an encrypted on-disk file), plus a separate, ungated metadata entry (`walletId` → addresses) for read-only UI that shouldn't need a biometric prompt just to show an address or balance.
 
-## Security note
+Bitcoin Cash is derivation-only: sending BCH is unsupported both here and upstream (`chainberry-wallet`'s self-custody transaction preparation has no BCH case), so this module only derives its address.
 
-`getAddressForCoin` returns the raw private key as hex to JS. That's a deliberate tradeoff for this module — it does no key storage or signing orchestration itself, it only derives keys. Callers are responsible for how the mnemonic and private keys are held, encrypted at rest, and cleared from memory. Don't treat this module as a secure enclave; it isn't one.
+**Not yet verified against a real device/build**: the per-chain `SigningInput` field mappings for Bitcoin, Litecoin, Tron, XRP, and TON, and Solana's raw-transaction signing mode, were written against the general Trust Wallet Core API shape but haven't been compiled or run against this module's pinned `wallet-core` version. Confirm field names and produce byte-for-byte signed-output parity against the previous JS-based signers (or a testnet broadcast) before trusting any of these chains with real funds. Ethereum/BNB/Polygon signing is a straightforward reshape of what this module already proved out.
 
 ## License
 

package/android/build.gradle

@@ -64,4 +64,6 @@ dependencies {
   // Check github.com/trustwallet/wallet-core/releases for the latest version
   implementation 'com.trustwallet:wallet-core:4.1.19'
   implementation 'com.google.protobuf:protobuf-javalite:3.21.9'
+  // BiometricPrompt (biometry-or-device-credential gating on the Keystore-backed wallet cipher)
+  implementation 'androidx.biometric:biometric:1.1.0'
 }

package/android/src/main/java/expo/modules/trustwalletcore/ChainSigning.kt

@@ -0,0 +1,299 @@
+package expo.modules.trustwalletcore
+
+import com.google.protobuf.ByteString
+import wallet.core.java.AnySigner
+import wallet.core.jni.AnyAddress
+import wallet.core.jni.CoinType
+import wallet.core.jni.HDWallet
+import wallet.core.jni.proto.Bitcoin
+import wallet.core.jni.proto.Common
+import wallet.core.jni.proto.Ethereum
+import wallet.core.jni.proto.Ripple
+import wallet.core.jni.proto.Solana
+import wallet.core.jni.proto.TheOpenNetwork
+import wallet.core.jni.proto.Tron
+import java.math.BigInteger
+
+class ChainSigningException(message: String) : Exception(message)
+
+// All chains this module derives addresses for / signs transactions for.
+enum class ChainKey(val coinType: CoinType) {
+  ETHEREUM(CoinType.ETHEREUM),
+  BNB(CoinType.SMARTCHAIN),
+  // Polygon shares Ethereum's secp256k1 key/address (same BIP44 path) — no distinct CoinType.
+  POLYGON(CoinType.ETHEREUM),
+  SOLANA(CoinType.SOLANA),
+  TRON(CoinType.TRON),
+  TON(CoinType.TON),
+  BITCOIN(CoinType.BITCOIN),
+  BITCOINCASH(CoinType.BITCOINCASH),
+  LITECOIN(CoinType.LITECOIN),
+  XRP(CoinType.XRP);
+
+  companion object {
+    fun fromJs(raw: String): ChainKey =
+      entries.find { it.name.equals(raw, ignoreCase = true) }
+        ?: throw ChainSigningException("Unsupported chain: $raw")
+  }
+}
+
+data class ChainSignResult(val signedTx: String, val meta: Map<String, Any>?)
+
+object ChainSigner {
+  fun sign(chain: ChainKey, wallet: HDWallet, unsignedTx: Map<String, Any>): ChainSignResult = when (chain) {
+    ChainKey.ETHEREUM, ChainKey.BNB, ChainKey.POLYGON ->
+      ChainSignResult(signEvm(wallet, chain.coinType, unsignedTx), null)
+    ChainKey.SOLANA -> ChainSignResult(signSolana(wallet, unsignedTx), null)
+    ChainKey.BITCOIN, ChainKey.LITECOIN -> ChainSignResult(signUtxo(wallet, chain.coinType, unsignedTx), null)
+    ChainKey.TRON -> ChainSignResult(signTron(wallet, unsignedTx), null)
+    ChainKey.XRP -> ChainSignResult(signXrp(wallet, unsignedTx), null)
+    ChainKey.TON -> signTon(wallet, unsignedTx)
+    // Sending is intentionally unsupported: chainberry-wallet's prepareSelfCustodyUnsignedTx has
+    // no BCH case — this app only ever needs BCH address derivation, never a signed BCH tx.
+    ChainKey.BITCOINCASH -> throw ChainSigningException("BCH sending is not supported")
+  }
+
+  // MARK: - EVM (ethereum / bnb / polygon)
+  // unsignedTx: { to, chainId, nonce, gasLimitHex, valueHex?, dataHex?,
+  //               gasPriceHex? (legacy) | maxFeePerGasHex + maxPriorityFeePerGasHex (EIP-1559) }
+
+  private fun signEvm(wallet: HDWallet, coin: CoinType, unsignedTx: Map<String, Any>): String {
+    val privateKey = wallet.getKeyForCoin(coin)
+    val to = unsignedTx["to"] as? String ?: throw ChainSigningException("Missing to")
+    val nonce = (unsignedTx["nonce"] as? Number)?.toLong() ?: throw ChainSigningException("Missing nonce")
+    val gasLimHex = unsignedTx["gasLimitHex"] as? String ?: throw ChainSigningException("Missing gasLimitHex")
+    val chainId = (unsignedTx["chainId"] as? Number)?.toLong() ?: throw ChainSigningException("Missing chainId")
+    val valueHex = (unsignedTx["valueHex"] as? String)?.ifEmpty { "0" } ?: "0"
+    val dataHex = unsignedTx["dataHex"] as? String ?: ""
+
+    val input = Ethereum.SigningInput.newBuilder().apply {
+      this.chainId = BigInteger.valueOf(chainId).toMinimalByteString()
+      this.nonce = BigInteger.valueOf(nonce).toMinimalByteString()
+      this.gasLimit = BigInteger(gasLimHex, 16).toMinimalByteString()
+      this.toAddress = to
+      this.privateKey = ByteString.copyFrom(privateKey.data())
+
+      this.transaction = Ethereum.Transaction.newBuilder().apply {
+        this.transfer = Ethereum.Transaction.Transfer.newBuilder().apply {
+          this.amount = BigInteger(valueHex, 16).toMinimalByteString()
+          if (dataHex.isNotEmpty()) this.data = ByteString.copyFrom(dataHex.hexToBytes())
+        }.build()
+      }.build()
+
+      val gasPriceHex = unsignedTx["gasPriceHex"] as? String
+      if (gasPriceHex != null) {
+        this.gasPrice = BigInteger(gasPriceHex, 16).toMinimalByteString()
+      } else {
+        val mfHex = unsignedTx["maxFeePerGasHex"] as? String
+        val pfHex = unsignedTx["maxPriorityFeePerGasHex"] as? String
+        if (mfHex != null && pfHex != null) {
+          this.maxFeePerGas = BigInteger(mfHex, 16).toMinimalByteString()
+          this.maxInclusionFeePerGas = BigInteger(pfHex, 16).toMinimalByteString()
+        }
+      }
+    }.build()
+
+    val output = AnySigner.sign(input, coin, Ethereum.SigningOutput.parser())
+    if (output.error != Common.SigningError.OK) throw ChainSigningException("Signing failed: ${output.errorMessage}")
+    return "0x" + output.encoded.toByteArray().toHex()
+  }
+
+  // MARK: - Solana
+  // NOTE(verify-on-device): prepareSelfCustodyUnsignedTx's SOL branch returns a fully-built,
+  // base64-serialized unsigned @solana/web3.js Transaction (native transfer or SPL-token
+  // transfer) — not a simple {to,lamports,recentBlockhash} triple. wallet-core's
+  // Solana.SigningInput has a raw-message signing mode intended for exactly this case; confirm
+  // the exact field/message name against the installed wallet-core version.
+  // unsignedTx: { unsignedTxBase64: string }
+  private fun signSolana(wallet: HDWallet, unsignedTx: Map<String, Any>): String {
+    val privateKey = wallet.getKeyForCoin(CoinType.SOLANA)
+    val unsignedTxBase64 = unsignedTx["unsignedTxBase64"] as? String
+      ?: throw ChainSigningException("Missing unsignedTxBase64")
+    val txBytes = android.util.Base64.decode(unsignedTxBase64, android.util.Base64.DEFAULT)
+
+    val input = Solana.SigningInput.newBuilder().apply {
+      this.privateKey = ByteString.copyFrom(privateKey.data())
+      this.rawMessage = Solana.RawMessage.newBuilder().apply {
+        this.type = Solana.MessageType.legacy
+        this.encoded = ByteString.copyFrom(txBytes)
+      }.build()
+    }.build()
+
+    val output = AnySigner.sign(input, CoinType.SOLANA, Solana.SigningOutput.parser())
+    if (output.error != Common.SigningError.OK) throw ChainSigningException("Signing failed: ${output.errorMessage}")
+    return output.encoded
+  }
+
+  // MARK: - BTC / LTC (UTXO-based)
+  // unsignedTx (from wallet-broadcast's additive prepareBtcUtxoSet/prepareLtcUtxoSet):
+  // { toAddress, changeAddress, sendAmountSats, changeAmountSats, satsPerByte,
+  //   inputs: [{ txIdHex, vout, amountSats, scriptPubKeyHex }] }
+  @Suppress("UNCHECKED_CAST")
+  private fun signUtxo(wallet: HDWallet, coin: CoinType, unsignedTx: Map<String, Any>): String {
+    val privateKey = wallet.getKeyForCoin(coin)
+    val toAddress = unsignedTx["toAddress"] as? String ?: throw ChainSigningException("Missing toAddress")
+    val changeAddress = unsignedTx["changeAddress"] as? String ?: throw ChainSigningException("Missing changeAddress")
+    val sendAmountSats = (unsignedTx["sendAmountSats"] as? String)?.toLong() ?: throw ChainSigningException("Missing sendAmountSats")
+    val satsPerByte = (unsignedTx["satsPerByte"] as? Number)?.toLong() ?: throw ChainSigningException("Missing satsPerByte")
+    val inputs = unsignedTx["inputs"] as? List<Map<String, Any>> ?: throw ChainSigningException("Missing inputs")
+
+    val utxos = inputs.map { entry ->
+      val txIdHex = entry["txIdHex"] as? String ?: throw ChainSigningException("Invalid UTXO entry")
+      val vout = (entry["vout"] as? Number)?.toInt() ?: throw ChainSigningException("Invalid UTXO entry")
+      val amount = (entry["amountSats"] as? String)?.toLong() ?: throw ChainSigningException("Invalid UTXO entry")
+      val scriptHex = entry["scriptPubKeyHex"] as? String ?: throw ChainSigningException("Invalid UTXO entry")
+
+      // On-chain/explorer txid hex is displayed big-endian; wallet-core's OutPoint.hash wants
+      // the reversed (little-endian, internal wire-format) byte order.
+      val txIdBytes = txIdHex.hexToBytes().reversedArray()
+
+      Bitcoin.UnspentTransaction.newBuilder().apply {
+        this.outPoint = Bitcoin.OutPoint.newBuilder().apply {
+          this.hash = ByteString.copyFrom(txIdBytes)
+          this.index = vout
+        }.build()
+        this.amount = amount
+        this.script = ByteString.copyFrom(scriptHex.hexToBytes())
+      }.build()
+    }
+
+    val input = Bitcoin.SigningInput.newBuilder().apply {
+      this.hashType = 1 // SIGHASH_ALL — stable Bitcoin protocol constant, not a wallet-core-specific value
+      this.amount = sendAmountSats
+      this.byteFee = satsPerByte
+      this.toAddress = toAddress
+      this.changeAddress = changeAddress
+      this.useMaxAmount = false
+      this.coinType = coin.value()
+      this.addPrivateKey(ByteString.copyFrom(privateKey.data()))
+      this.addAllUtxo(utxos)
+    }.build()
+
+    val output = AnySigner.sign(input, coin, Bitcoin.SigningOutput.parser())
+    if (output.error != Common.SigningError.OK) throw ChainSigningException("Signing failed: ${output.errorMessage}")
+    return output.encoded.toByteArray().toHex()
+  }
+
+  // MARK: - TRX
+  // unsignedTx: the raw TronGrid-shaped unsigned tx object from prepareSelfCustodyUnsignedTx's
+  // TRX branch (raw_data.contract[], ref_block_bytes/hash, expiration, timestamp).
+  // NOTE(verify-on-device): covers the plain TRX-transfer contract only (matches
+  // prepareTrxTransaction's non-token branch); the TRC20 branch needs its own mapping.
+  @Suppress("UNCHECKED_CAST")
+  private fun signTron(wallet: HDWallet, unsignedTx: Map<String, Any>): String {
+    val privateKey = wallet.getKeyForCoin(CoinType.TRON)
+    val rawData = unsignedTx["raw_data"] as? Map<String, Any> ?: throw ChainSigningException("Missing raw_data")
+    val contracts = rawData["contract"] as? List<Map<String, Any>> ?: throw ChainSigningException("Missing contract")
+    val parameter = contracts.firstOrNull()?.get("parameter") as? Map<String, Any> ?: throw ChainSigningException("Missing contract parameter")
+    val value = parameter["value"] as? Map<String, Any> ?: throw ChainSigningException("Missing contract value")
+    val toAddressHex = value["to_address"] as? String ?: throw ChainSigningException("Missing to_address")
+    val amount = (value["amount"] as? Number)?.toLong() ?: throw ChainSigningException("Missing amount")
+    val refBlockBytes = rawData["ref_block_bytes"] as? String ?: throw ChainSigningException("Missing ref_block_bytes")
+    val refBlockHash = rawData["ref_block_hash"] as? String ?: throw ChainSigningException("Missing ref_block_hash")
+    val expiration = (rawData["expiration"] as? Number)?.toLong() ?: throw ChainSigningException("Missing expiration")
+    val timestamp = (rawData["timestamp"] as? Number)?.toLong() ?: throw ChainSigningException("Missing timestamp")
+
+    // TronGrid's raw hex address (0x41-prefixed 21 bytes) -> base58check "T..." string that
+    // wallet-core's TransferContract.to_address expects.
+    val toAddress = AnyAddress(toAddressHex.hexToBytes(), CoinType.TRON).description()
+
+    val input = Tron.SigningInput.newBuilder().apply {
+      this.privateKey = ByteString.copyFrom(privateKey.data())
+      this.transaction = Tron.Transaction.newBuilder().apply {
+        this.transfer = Tron.TransferContract.newBuilder().apply {
+          this.toAddress = toAddress
+          this.amount = amount
+        }.build()
+      }.build()
+      this.refBlockBytes = ByteString.copyFrom(refBlockBytes.hexToBytes())
+      this.refBlockHash = ByteString.copyFrom(refBlockHash.hexToBytes())
+      this.expiration = expiration
+      this.timestamp = timestamp
+    }.build()
+
+    val output = AnySigner.sign(input, CoinType.TRON, Tron.SigningOutput.parser())
+    if (output.error != Common.SigningError.OK) throw ChainSigningException("Signing failed: ${output.errorMessage}")
+    return output.json
+  }
+
+  // MARK: - XRP
+  // unsignedTx: xrpl.js `Payment` object (Account, Destination, Amount (drops, string),
+  // Fee (drops, string), Sequence, LastLedgerSequence, DestinationTag?).
+  private fun signXrp(wallet: HDWallet, unsignedTx: Map<String, Any>): String {
+    val privateKey = wallet.getKeyForCoin(CoinType.XRP)
+    val account = unsignedTx["Account"] as? String ?: throw ChainSigningException("Missing Account")
+    val destination = unsignedTx["Destination"] as? String ?: throw ChainSigningException("Missing Destination")
+    val amountDrops = unsignedTx["Amount"] as? String ?: throw ChainSigningException("Missing Amount")
+    val feeDrops = unsignedTx["Fee"] as? String ?: throw ChainSigningException("Missing Fee")
+    val sequence = (unsignedTx["Sequence"] as? Number)?.toInt() ?: throw ChainSigningException("Missing Sequence")
+    val lastLedgerSequence = (unsignedTx["LastLedgerSequence"] as? Number)?.toInt()
+    val destinationTag = (unsignedTx["DestinationTag"] as? Number)?.toInt()
+
+    val input = Ripple.SigningInput.newBuilder().apply {
+      this.privateKey = ByteString.copyFrom(privateKey.data())
+      this.account = account
+      this.fee = feeDrops.toLong()
+      this.sequence = sequence
+      lastLedgerSequence?.let { this.lastLedgerSequence = it }
+      this.opPayment = Ripple.OperationPayment.newBuilder().apply {
+        this.amount = amountDrops.toLong()
+        this.destination = destination
+        destinationTag?.let { this.destinationTag = it }
+      }.build()
+    }.build()
+
+    val output = AnySigner.sign(input, CoinType.XRP, Ripple.SigningOutput.parser())
+    if (output.error != Common.SigningError.OK) throw ChainSigningException("Signing failed: ${output.errorMessage}")
+    return output.encoded.toByteArray().toHex()
+  }
+
+  // MARK: - TON
+  // unsignedTx: { toAddress, amount, seqno, memoId? }.
+  // NOTE(verify-on-device): confirm `amount` units (nanoton vs TON) and that wallet_version
+  // V4R2 matches the address format the current @ton/* implementation derives.
+  private fun signTon(wallet: HDWallet, unsignedTx: Map<String, Any>): ChainSignResult {
+    val privateKey = wallet.getKeyForCoin(CoinType.TON)
+    val toAddress = unsignedTx["toAddress"] as? String ?: throw ChainSigningException("Missing toAddress")
+    val amount = (unsignedTx["amount"] as? String)?.toULongOrNull() ?: throw ChainSigningException("Missing amount")
+    val seqno = (unsignedTx["seqno"] as? Number)?.toInt() ?: throw ChainSigningException("Missing seqno")
+    val memoId = unsignedTx["memoId"] as? String
+
+    val transfer = TheOpenNetwork.Transfer.newBuilder().apply {
+      this.dest = toAddress
+      this.amount = amount.toLong()
+      this.mode = TheOpenNetwork.SendMode.PAY_GAS_SEPARATELY_VALUE or TheOpenNetwork.SendMode.IGNORE_ACTION_PHASE_ERRORS_VALUE
+      this.bounceable = true
+      memoId?.let { this.comment = it }
+    }.build()
+
+    val input = TheOpenNetwork.SigningInput.newBuilder().apply {
+      this.privateKey = ByteString.copyFrom(privateKey.data())
+      this.walletVersion = TheOpenNetwork.WalletVersion.WALLET_V4_R2
+      this.sequenceNumber = seqno
+      this.transfer = transfer
+    }.build()
+
+    val output = AnySigner.sign(input, CoinType.TON, TheOpenNetwork.SigningOutput.parser())
+    if (output.error != Common.SigningError.OK) throw ChainSigningException("Signing failed: ${output.errorMessage}")
+    return ChainSignResult(output.encoded, mapOf("txHash" to output.hash.toByteArray().toHex()))
+  }
+}
+
+// Helpers
+
+private fun ByteArray.toHex(): String = joinToString("") { "%02x".format(it) }
+
+private fun String.hexToBytes(): ByteArray {
+  val s = removePrefix("0x").let { if (it.length % 2 == 0) it else "0$it" }
+  return ByteArray(s.length / 2) { s.substring(it * 2, it * 2 + 2).toInt(16).toByte() }
+}
+
+// BigInteger -> minimal big-endian ByteString (strips Java's leading sign byte)
+private fun BigInteger.toMinimalByteString(): ByteString {
+  val raw = toByteArray()
+  return if (raw.size > 1 && raw[0] == 0.toByte()) {
+    ByteString.copyFrom(raw, 1, raw.size - 1)
+  } else {
+    ByteString.copyFrom(raw)
+  }
+}

package/android/src/main/java/expo/modules/trustwalletcore/NativeWalletStore.kt

@@ -0,0 +1,182 @@
+package expo.modules.trustwalletcore
+
+import android.content.Context
+import android.os.Build
+import android.security.keystore.KeyGenParameterSpec
+import android.security.keystore.KeyProperties
+import androidx.biometric.BiometricManager
+import androidx.biometric.BiometricPrompt
+import androidx.fragment.app.FragmentActivity
+import org.json.JSONObject
+import java.io.File
+import java.security.KeyStore
+import javax.crypto.Cipher
+import javax.crypto.KeyGenerator
+import javax.crypto.SecretKey
+import javax.crypto.spec.GCMParameterSpec
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+import kotlin.coroutines.suspendCoroutine
+
+/**
+ * Persists mnemonics as files encrypted with a hardware-backed, biometry-or-device-credential
+ * gated Android Keystore AES key (one key per wallet), plus a parallel ungated metadata store
+ * (walletId -> per-chain addresses) for read-only UI. Deliberately not `EncryptedSharedPreferences`
+ * or wallet-core's `StoredKey` keystore-JSON — confidentiality comes entirely from the Keystore
+ * key never leaving the TEE/StrongBox, not from the on-disk file encoding.
+ */
+class NativeWalletStoreError(message: String) : Exception(message)
+
+object NativeWalletStore {
+  private const val KEY_ALIAS_PREFIX = "vault_wallet_"
+  private const val ANDROID_KEYSTORE = "AndroidKeyStore"
+  private const val TRANSFORMATION = "AES/GCM/NoPadding"
+  private const val GCM_IV_LENGTH = 12
+  private const val GCM_TAG_LENGTH_BITS = 128
+  private const val WALLETS_DIR = "vault_wallets"
+  private const val METADATA_FILE = "metadata.json"
+
+  private fun walletsDir(context: Context): File =
+    File(context.filesDir, WALLETS_DIR).apply { mkdirs() }
+
+  private fun mnemonicFile(context: Context, walletId: String): File =
+    File(walletsDir(context), "$walletId.enc")
+
+  private fun metadataFile(context: Context): File =
+    File(walletsDir(context), METADATA_FILE)
+
+  // MARK: - Keystore key management
+
+  private fun keyStore(): KeyStore = KeyStore.getInstance(ANDROID_KEYSTORE).apply { load(null) }
+
+  private fun getOrCreateKey(walletId: String): SecretKey {
+    val alias = KEY_ALIAS_PREFIX + walletId
+    val ks = keyStore()
+    (ks.getKey(alias, null) as? SecretKey)?.let { return it }
+
+    val keyGenerator = KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES, ANDROID_KEYSTORE)
+    val builder = KeyGenParameterSpec.Builder(alias, KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT)
+      .setBlockModes(KeyProperties.BLOCK_MODE_GCM)
+      .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
+      .setUserAuthenticationRequired(true)
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+      builder.setUserAuthenticationParameters(
+        0,
+        KeyProperties.AUTH_BIOMETRIC_STRONG or KeyProperties.AUTH_DEVICE_CREDENTIAL
+      )
+    } else {
+      @Suppress("DEPRECATION")
+      builder.setUserAuthenticationValidityDurationSeconds(-1)
+    }
+
+    keyGenerator.init(builder.build())
+    return keyGenerator.generateKey()
+  }
+
+  // MARK: - Mnemonic (biometry/device-credential gated)
+
+  /** Encrypts and writes the mnemonic. Also requires user authentication (the key itself is
+   * auth-gated for every use, encrypt included) — callers should invoke this right after a
+   * successful [authenticate] prompt, same as [loadMnemonic]. */
+  fun saveMnemonic(context: Context, walletId: String, mnemonic: String, authenticatedCipher: Cipher) {
+    val iv = authenticatedCipher.iv
+    val ciphertext = authenticatedCipher.doFinal(mnemonic.toByteArray(Charsets.UTF_8))
+    mnemonicFile(context, walletId).writeBytes(iv + ciphertext)
+  }
+
+  fun loadMnemonic(context: Context, walletId: String, authenticatedCipher: Cipher): String {
+    val file = mnemonicFile(context, walletId)
+    if (!file.exists()) throw NativeWalletStoreError("Wallet not found: $walletId")
+    val bytes = file.readBytes()
+    val ciphertext = bytes.copyOfRange(GCM_IV_LENGTH, bytes.size)
+    return String(authenticatedCipher.doFinal(ciphertext), Charsets.UTF_8)
+  }
+
+  fun deleteMnemonic(context: Context, walletId: String) {
+    mnemonicFile(context, walletId).delete()
+    runCatching { keyStore().deleteEntry(KEY_ALIAS_PREFIX + walletId) }
+  }
+
+  /** A `Cipher` initialized for encryption, to be unlocked via [authenticate] before use. */
+  fun encryptCipher(walletId: String): Cipher {
+    val cipher = Cipher.getInstance(TRANSFORMATION)
+    cipher.init(Cipher.ENCRYPT_MODE, getOrCreateKey(walletId))
+    return cipher
+  }
+
+  /** A `Cipher` initialized for decryption using the IV already on disk, to be unlocked via
+   * [authenticate] before use. */
+  fun decryptCipher(context: Context, walletId: String): Cipher {
+    val file = mnemonicFile(context, walletId)
+    if (!file.exists()) throw NativeWalletStoreError("Wallet not found: $walletId")
+    val iv = file.readBytes().copyOfRange(0, GCM_IV_LENGTH)
+    val cipher = Cipher.getInstance(TRANSFORMATION)
+    cipher.init(Cipher.DECRYPT_MODE, getOrCreateKey(walletId), GCMParameterSpec(GCM_TAG_LENGTH_BITS, iv))
+    return cipher
+  }
+
+  // MARK: - Metadata (ungated: walletId -> { chain: address })
+
+  fun saveMetadata(context: Context, wallets: Map<String, Map<String, String>>) {
+    val root = JSONObject()
+    for ((walletId, addresses) in wallets) {
+      root.put(walletId, JSONObject(addresses as Map<*, *>))
+    }
+    metadataFile(context).writeText(root.toString())
+  }
+
+  fun loadMetadata(context: Context): Map<String, Map<String, String>> {
+    val file = metadataFile(context)
+    if (!file.exists()) return emptyMap()
+    val root = JSONObject(file.readText())
+    val result = mutableMapOf<String, Map<String, String>>()
+    for (walletId in root.keys()) {
+      val addressesJson = root.getJSONObject(walletId)
+      val addresses = mutableMapOf<String, String>()
+      for (chain in addressesJson.keys()) {
+        addresses[chain] = addressesJson.getString(chain)
+      }
+      result[walletId] = addresses
+    }
+    return result
+  }
+
+  // MARK: - Biometric/device-credential prompt
+
+  /** Authenticates the given [Cipher] via BiometricPrompt (biometry-or-device-credential),
+   * returning the same cipher ready for [Cipher.doFinal]. */
+  suspend fun authenticate(activity: FragmentActivity, cipher: Cipher, title: String): Cipher =
+    suspendCoroutine { continuation ->
+      val allowedAuthenticators = BiometricManager.Authenticators.BIOMETRIC_STRONG or
+        BiometricManager.Authenticators.DEVICE_CREDENTIAL
+
+      val promptInfo = BiometricPrompt.PromptInfo.Builder()
+        .setTitle(title)
+        .setAllowedAuthenticators(allowedAuthenticators)
+        .build()
+
+      val executor = androidx.core.content.ContextCompat.getMainExecutor(activity)
+      val prompt = BiometricPrompt(
+        activity,
+        executor,
+        object : BiometricPrompt.AuthenticationCallback() {
+          override fun onAuthenticationSucceeded(result: BiometricPrompt.AuthenticationResult) {
+            val authenticatedCipher = result.cryptoObject?.cipher
+              ?: return continuation.resumeWithException(NativeWalletStoreError("No authenticated cipher returned"))
+            continuation.resume(authenticatedCipher)
+          }
+
+          override fun onAuthenticationError(errorCode: Int, errString: CharSequence) {
+            continuation.resumeWithException(NativeWalletStoreError("Authentication error: $errString"))
+          }
+
+          override fun onAuthenticationFailed() {
+            // Not terminal — BiometricPrompt keeps the sheet open for retry; only
+            // onAuthenticationError/onAuthenticationSucceeded resolve the continuation.
+          }
+        }
+      )
+      prompt.authenticate(promptInfo, BiometricPrompt.CryptoObject(cipher))
+    }
+}

package/android/src/main/java/expo/modules/trustwalletcore/TrustWalletCoreModule.kt

@@ -1,17 +1,15 @@
 package expo.modules.trustwalletcore
 
-import com.google.protobuf.ByteString
+import androidx.fragment.app.FragmentActivity
+import expo.modules.kotlin.exception.CodedException
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
-import wallet.core.java.AnySigner
-import wallet.core.jni.CoinType
 import wallet.core.jni.HDWallet
-import wallet.core.jni.PrivateKey
-import wallet.core.jni.proto.Common
-import wallet.core.jni.proto.Ethereum
-import wallet.core.jni.proto.Solana
-import java.math.BigInteger
+import java.util.UUID
 
+// Mnemonic/private-key material never crosses back to JS except `exportMnemonic` — an
+// explicit, biometric/device-credential-gated backup flow. Every other method returns only
+// walletIds, addresses, or signed transaction bytes/hex.
 class TrustWalletCoreModule : Module() {
   companion object {
     init {
@@ -20,124 +18,74 @@ class TrustWalletCoreModule : Module() {
     }
   }
 
+  private val context get() = appContext.reactContext
+    ?: throw CodedException("NoContext", "React context unavailable", null)
+
+  private val activity: FragmentActivity
+    get() = appContext.currentActivity as? FragmentActivity
+      ?: throw CodedException("NoActivity", "No foreground FragmentActivity to host the biometric prompt", null)
+
   override fun definition() = ModuleDefinition {
     Name("TrustWalletCore")
 
-    // Returns { mnemonic } — strength 128 = 12 words, 256 = 24 words
-    AsyncFunction("generateWallet") { strength: Int, passphrase: String ->
-      mapOf("mnemonic" to HDWallet(strength, passphrase).mnemonic())
-    }
-
-    // Validates mnemonic and returns { mnemonic }
-    AsyncFunction("restoreWallet") { mnemonic: String, passphrase: String ->
-      HDWallet(mnemonic, passphrase) // throws on invalid mnemonic
-      mapOf("mnemonic" to mnemonic)
+    // strength 128 = 12 words, 256 = 24 words. Returns { walletId, addresses }.
+    AsyncFunction("createWallet") { strength: Int, passphrase: String ->
+      val wallet = HDWallet(strength, passphrase)
+      persistNewWallet(wallet)
     }
 
-    // Derives address and private key for a named coin
-    // coin: "ethereum" | "solana"
-    AsyncFunction("getAddressForCoin") { mnemonic: String, coin: String, passphrase: String ->
-      val wallet = HDWallet(mnemonic, passphrase)
-      val coinType = resolveCoinType(coin)
-      mapOf(
-        "address"    to wallet.getAddressForCoin(coinType),
-        "privateKey" to wallet.getKeyForCoin(coinType).data().toHex(),
-      )
+    // One-time mnemonic exposure from JS, at import only — never retained after this call.
+    // Returns { walletId, addresses }.
+    AsyncFunction("importWallet") { mnemonic: String, passphrase: String ->
+      val wallet = HDWallet(mnemonic, passphrase) // throws on invalid mnemonic
+      persistNewWallet(wallet)
     }
 
-    // Signs an Ethereum transaction; returns 0x-prefixed RLP-encoded signed tx hex
-    // txParams: { to, valueHex, nonce, gasLimitHex, chainId, dataHex?,
-    //             gasPriceHex? (legacy) | maxFeePerGasHex + maxPriorityFeePerGasHex (EIP-1559) }
-    AsyncFunction("signEthereumTransaction") { privateKeyHex: String, txParams: Map<String, Any> ->
-      val privateKey = PrivateKey(privateKeyHex.hexToBytes())
-      val to        = txParams["to"] as String
-      val valueHex  = (txParams["valueHex"] as? String)?.ifEmpty { "0" } ?: "0"
-      val nonce     = (txParams["nonce"] as Number).toInt()
-      val gasLimHex = txParams["gasLimitHex"] as String
-      val chainId   = (txParams["chainId"] as Number).toInt()
-      val dataHex   = (txParams["dataHex"] as? String) ?: ""
-
-      val input = Ethereum.SigningInput.newBuilder().apply {
-        this.chainId    = BigInteger.valueOf(chainId.toLong()).toMinimalByteString()
-        this.nonce      = BigInteger.valueOf(nonce.toLong()).toMinimalByteString()
-        this.gasLimit   = BigInteger(gasLimHex, 16).toMinimalByteString()
-        this.toAddress  = to
-        this.privateKey = ByteString.copyFrom(privateKey.data())
-
-        this.transaction = Ethereum.Transaction.newBuilder().apply {
-          this.transfer = Ethereum.Transaction.Transfer.newBuilder().apply {
-            this.amount = BigInteger(valueHex, 16).toMinimalByteString()
-            if (dataHex.isNotEmpty()) this.data = ByteString.copyFrom(dataHex.hexToBytes())
-          }.build()
-        }.build()
-
-        val gasPriceHex = txParams["gasPriceHex"] as? String
-        if (gasPriceHex != null) {
-          this.gasPrice = BigInteger(gasPriceHex, 16).toMinimalByteString()
-        } else {
-          val mfHex = txParams["maxFeePerGasHex"] as? String
-          val pfHex = txParams["maxPriorityFeePerGasHex"] as? String
-          if (mfHex != null && pfHex != null) {
-            this.maxFeePerGas          = BigInteger(mfHex, 16).toMinimalByteString()
-            this.maxInclusionFeePerGas = BigInteger(pfHex, 16).toMinimalByteString()
-          }
-        }
-      }.build()
-
-      val output = AnySigner.sign(input, CoinType.ETHEREUM, Ethereum.SigningOutput.parser())
-      if (output.error != Common.SigningError.OK) {
-        throw Exception("Signing failed: ${output.errorMessage}")
+    // Reads only the ungated metadata store — no biometric prompt.
+    AsyncFunction("listWallets") {
+      NativeWalletStore.loadMetadata(context).map { (walletId, addresses) ->
+        mapOf("walletId" to walletId, "addresses" to addresses)
       }
-      "0x" + output.encoded.toByteArray().toHex()
     }
 
-    // Signs a Solana transfer; returns base64-encoded signed transaction
-    // txParams: { to, lamports (string, lamports amount), recentBlockhash }
-    AsyncFunction("signSolanaTransaction") { privateKeyHex: String, txParams: Map<String, Any> ->
-      val privateKey      = PrivateKey(privateKeyHex.hexToBytes())
-      val to              = txParams["to"] as String
-      val lamports        = (txParams["lamports"] as String).toLong()
-      val recentBlockhash = txParams["recentBlockhash"] as String
+    AsyncFunction("deleteWallet") { walletId: String ->
+      NativeWalletStore.deleteMnemonic(context, walletId)
+      val metadata = NativeWalletStore.loadMetadata(context).toMutableMap()
+      metadata.remove(walletId)
+      NativeWalletStore.saveMetadata(context, metadata)
+    }
 
-      val input = Solana.SigningInput.newBuilder().apply {
-        this.recentBlockhash = recentBlockhash
-        this.privateKey      = ByteString.copyFrom(privateKey.data())
-        this.transferTransaction = Solana.Transfer.newBuilder().apply {
-          this.recipient = to
-          this.value     = lamports
-        }.build()
-      }.build()
+    // Triggers the native biometry/device-credential prompt, then signs entirely in-process.
+    // Returns { signedTx, meta? }.
+    AsyncFunction("signTransaction") { walletId: String, chain: String, unsignedTx: Map<String, Any> ->
+      val chainKey = ChainKey.fromJs(chain)
+      val cipher = NativeWalletStore.authenticate(activity, NativeWalletStore.decryptCipher(context, walletId), "Sign transaction")
+      val mnemonic = NativeWalletStore.loadMnemonic(context, walletId, cipher)
+      val wallet = HDWallet(mnemonic, "")
+      val result = ChainSigner.sign(chainKey, wallet, unsignedTx)
+      val response = mutableMapOf<String, Any>("signedTx" to result.signedTx)
+      result.meta?.let { response["meta"] = it }
+      response
+    }
 
-      val output = AnySigner.sign(input, CoinType.SOLANA, Solana.SigningOutput.parser())
-      if (output.error != Common.SigningError.OK) {
-        throw Exception("Signing failed: ${output.errorMessage}")
-      }
-      output.encoded
+    // The one sanctioned mnemonic exposure — explicit backup flow only.
+    AsyncFunction("exportMnemonic") { walletId: String ->
+      val cipher = NativeWalletStore.authenticate(activity, NativeWalletStore.decryptCipher(context, walletId), "Reveal recovery phrase")
+      NativeWalletStore.loadMnemonic(context, walletId, cipher)
     }
   }
-}
 
-// Helpers
-private fun resolveCoinType(coin: String): CoinType = when (coin.lowercase()) {
-  "ethereum" -> CoinType.ETHEREUM
-  "solana"   -> CoinType.SOLANA
-  "bnb"      -> CoinType.SMARTCHAIN
-  else       -> throw IllegalArgumentException("Unsupported coin: $coin")
-}
+  private suspend fun persistNewWallet(wallet: HDWallet): Map<String, Any> {
+    val walletId = UUID.randomUUID().toString()
+    val addresses = ChainKey.entries.associate { chain -> chain.name.lowercase() to wallet.getAddressForCoin(chain.coinType) }
 
-private fun ByteArray.toHex(): String = joinToString("") { "%02x".format(it) }
+    val cipher = NativeWalletStore.authenticate(activity, NativeWalletStore.encryptCipher(walletId), "Secure your new wallet")
+    NativeWalletStore.saveMnemonic(context, walletId, wallet.mnemonic(), cipher)
 
-private fun String.hexToBytes(): ByteArray {
-  val s = removePrefix("0x").let { if (it.length % 2 == 0) it else "0$it" }
-  return ByteArray(s.length / 2) { s.substring(it * 2, it * 2 + 2).toInt(16).toByte() }
-}
+    val metadata = NativeWalletStore.loadMetadata(context).toMutableMap()
+    metadata[walletId] = addresses
+    NativeWalletStore.saveMetadata(context, metadata)
 
-// BigInteger → minimal big-endian ByteString (strips Java's leading sign byte)
-private fun BigInteger.toMinimalByteString(): ByteString {
-  val raw = toByteArray()
-  return if (raw.size > 1 && raw[0] == 0.toByte()) {
-    ByteString.copyFrom(raw, 1, raw.size - 1)
-  } else {
-    ByteString.copyFrom(raw)
+    return mapOf("walletId" to walletId, "addresses" to addresses)
   }
 }

package/ios/TrustWalletCoreModule.swift

@@ -1,145 +1,107 @@
 import ExpoModulesCore
 import WalletCore
+import LocalAuthentication
 
-// All numeric transaction fields are bare hex strings (no 0x prefix) to avoid JS number precision loss.
+// Mnemonic/private-key material never crosses back to JS except `exportMnemonic` — an
+// explicit, biometric/passcode-gated backup flow. Every other method returns only
+// walletIds, addresses, or signed transaction bytes/hex.
 public class TrustWalletCoreModule: Module {
   public func definition() -> ModuleDefinition {
     Name("TrustWalletCore")
 
-    // Returns { mnemonic } — strength 128 = 12 words, 256 = 24 words
-    AsyncFunction("generateWallet") { (strength: Int, passphrase: String) throws -> [String: String] in
+    // strength 128 = 12 words, 256 = 24 words. Returns { walletId, addresses }.
+    AsyncFunction("createWallet") { (strength: Int, passphrase: String) throws -> [String: Any] in
       guard let wallet = HDWallet(strength: UInt32(strength), passphrase: passphrase) else {
         throw Exception(name: "WalletError", description: "Failed to generate wallet")
       }
-      return ["mnemonic": wallet.mnemonic]
+      return try Self.persistNewWallet(wallet: wallet)
     }
 
-    // Validates mnemonic and returns { mnemonic }
-    AsyncFunction("restoreWallet") { (mnemonic: String, passphrase: String) throws -> [String: String] in
-      guard HDWallet(mnemonic: mnemonic, passphrase: passphrase) != nil else {
-        throw Exception(name: "InvalidMnemonic", description: "Invalid mnemonic phrase")
-      }
-      return ["mnemonic": mnemonic]
-    }
-
-    // Derives address and private key for a named coin
-    // coin: "ethereum" | "solana"
-    AsyncFunction("getAddressForCoin") { (mnemonic: String, coin: String, passphrase: String) throws -> [String: String] in
+    // One-time mnemonic exposure from JS, at import only — never retained after this call.
+    // Returns { walletId, addresses }.
+    AsyncFunction("importWallet") { (mnemonic: String, passphrase: String) throws -> [String: Any] in
       guard let wallet = HDWallet(mnemonic: mnemonic, passphrase: passphrase) else {
         throw Exception(name: "InvalidMnemonic", description: "Invalid mnemonic phrase")
       }
-      let coinType = try Self.resolveCoinType(coin)
-      return [
-        "address":    wallet.getAddressForCoin(coin: coinType),
-        "privateKey": wallet.getKeyForCoin(coin: coinType).data.hexString,
-      ]
+      return try Self.persistNewWallet(wallet: wallet)
     }
 
-    // Signs an Ethereum transaction; returns 0x-prefixed RLP-encoded signed tx hex
-    // txParams: { to, valueHex, nonce, gasLimitHex, chainId, dataHex?,
-    //             gasPriceHex? (legacy) | maxFeePerGasHex + maxPriorityFeePerGasHex (EIP-1559) }
-    AsyncFunction("signEthereumTransaction") { (privateKeyHex: String, txParams: [String: Any]) throws -> String in
-      guard let pkData = Data(hexString: privateKeyHex),
-            let privateKey = PrivateKey(data: pkData) else {
-        throw Exception(name: "InvalidKey", description: "Invalid private key hex")
-      }
-      guard let to       = txParams["to"] as? String,
-            let nonce    = txParams["nonce"] as? Int,
-            let gasLimHex = txParams["gasLimitHex"] as? String,
-            let chainId  = txParams["chainId"] as? Int else {
-        throw Exception(name: "InvalidParams", description: "Missing required tx params")
-      }
-      let valueHex = (txParams["valueHex"] as? String) ?? "0"
-      let dataHex  = (txParams["dataHex"]  as? String) ?? ""
-
-      var input = EthereumSigningInput()
-      input.chainID    = Self.intToData(chainId)
-      input.nonce      = Self.intToData(nonce)
-      input.gasLimit   = Self.hexData(gasLimHex) ?? Data()
-      input.toAddress  = to
-      input.privateKey = privateKey.data
-      if !dataHex.isEmpty { input.txData = Self.hexData(dataHex) ?? Data() }
-
-      var transfer = EthereumTransaction.Transfer()
-      transfer.amount = Self.hexData(valueHex) ?? Data([0])
-      var tx = EthereumTransaction()
-      tx.transfer = transfer
-      input.transaction = tx
-
-      if let gasPriceHex = txParams["gasPriceHex"] as? String {
-        input.gasPrice = Self.hexData(gasPriceHex) ?? Data()
-      } else if let mfHex = txParams["maxFeePerGasHex"] as? String,
-                let pfHex = txParams["maxPriorityFeePerGasHex"] as? String {
-        input.maxFeePerGas          = Self.hexData(mfHex) ?? Data()
-        input.maxInclusionFeePerGas = Self.hexData(pfHex) ?? Data()
+    // Reads only the ungated metadata store — no biometric prompt.
+    AsyncFunction("listWallets") { () -> [[String: Any]] in
+      NativeWalletStore.loadMetadata().map { walletId, addresses in
+        ["walletId": walletId, "addresses": addresses]
       }
+    }
 
-      let output: EthereumSigningOutput = AnySigner.sign(input: input, coin: .ethereum)
-      guard output.error == .ok else {
-        throw Exception(name: "SigningFailed", description: output.errorMessage)
-      }
-      return "0x" + output.encoded.hexString
+    AsyncFunction("deleteWallet") { (walletId: String) throws -> Void in
+      NativeWalletStore.deleteMnemonic(walletId: walletId)
+      var metadata = NativeWalletStore.loadMetadata()
+      metadata.removeValue(forKey: walletId)
+      try NativeWalletStore.saveMetadata(metadata)
     }
 
-    // Signs a Solana transfer; returns base64-encoded signed transaction
-    // txParams: { to, lamports (string), recentBlockhash }
-    AsyncFunction("signSolanaTransaction") { (privateKeyHex: String, txParams: [String: Any]) throws -> String in
-      guard let pkData = Data(hexString: privateKeyHex),
-            let privateKey = PrivateKey(data: pkData) else {
-        throw Exception(name: "InvalidKey", description: "Invalid private key hex")
-      }
-      guard let to             = txParams["to"] as? String,
-            let lamportsStr    = txParams["lamports"] as? String,
-            let lamports       = UInt64(lamportsStr),
-            let recentBlockhash = txParams["recentBlockhash"] as? String else {
-        throw Exception(name: "InvalidParams", description: "Missing required Solana tx params (to, lamports, recentBlockhash)")
+    // Triggers the native biometry/passcode prompt, then signs entirely in-process.
+    // Returns { signedTx, meta? }.
+    AsyncFunction("signTransaction") { (walletId: String, chain: String, unsignedTx: [String: Any]) throws -> [String: Any] in
+      let chainKey = try ChainKey(fromJs: chain)
+      let context = try await Self.authenticatedContext(reason: "Sign transaction")
+      let mnemonic = try NativeWalletStore.loadMnemonic(walletId: walletId, context: context)
+      guard let wallet = HDWallet(mnemonic: mnemonic, passphrase: "") else {
+        throw Exception(name: "InvalidMnemonic", description: "Stored mnemonic failed validation")
       }
+      let result = try ChainSigner.sign(chain: chainKey, wallet: wallet, unsignedTx: unsignedTx)
+      var response: [String: Any] = ["signedTx": result.signedTx]
+      if let meta = result.meta { response["meta"] = meta }
+      return response
+    }
 
-      var transfer = SolanaTransfer()
-      transfer.recipient = to
-      transfer.value = lamports
-
-      var input = SolanaSigningInput()
-      input.recentBlockhash      = recentBlockhash
-      input.privateKey           = privateKey.data
-      input.transferTransaction  = transfer
-
-      let output: SolanaSigningOutput = AnySigner.sign(input: input, coin: .solana)
-      guard output.error == .ok else {
-        throw Exception(name: "SigningFailed", description: output.errorMessage)
-      }
-      return output.encoded
+    // The one sanctioned mnemonic exposure — explicit backup flow only.
+    AsyncFunction("exportMnemonic") { (walletId: String) throws -> String in
+      let context = try await Self.authenticatedContext(reason: "Reveal recovery phrase")
+      return try NativeWalletStore.loadMnemonic(walletId: walletId, context: context)
     }
   }
 
   // MARK: - Helpers
 
-  private static func resolveCoinType(_ coin: String) throws -> CoinType {
-    switch coin.lowercased() {
-    case "ethereum": return .ethereum
-    case "solana":   return .solana
-    case "bnb":      return .smartChain
-    default:
-      throw Exception(name: "UnsupportedCoin", description: "Unsupported coin: \(coin)")
+  private static func persistNewWallet(wallet: HDWallet) throws -> [String: Any] {
+    let walletId = UUID().uuidString
+    var addresses: [String: String] = [:]
+    for chain in ChainKey.allCases {
+      addresses[chain.rawValue] = wallet.getAddressForCoin(coin: chain.coinType)
     }
-  }
 
-  // Parses a hex string (with or without 0x, odd or even length) into Data
-  private static func hexData(_ hex: String) -> Data? {
-    let s = hex.hasPrefix("0x") ? String(hex.dropFirst(2)) : hex
-    let padded = s.count % 2 == 0 ? s : "0" + s
-    return padded.isEmpty ? Data([0]) : Data(hexString: padded)
+    try NativeWalletStore.saveMnemonic(wallet.mnemonic, walletId: walletId)
+    var metadata = NativeWalletStore.loadMetadata()
+    metadata[walletId] = addresses
+    try NativeWalletStore.saveMetadata(metadata)
+
+    return ["walletId": walletId, "addresses": addresses]
   }
 
-  // Encodes a non-negative integer as minimal big-endian Data
-  private static func intToData(_ value: Int) -> Data {
-    guard value > 0 else { return Data([0]) }
-    var v = value
-    var bytes: [UInt8] = []
-    while v > 0 {
-      bytes.insert(UInt8(v & 0xFF), at: 0)
-      v >>= 8
+  /// Prompts biometry-or-device-passcode via `.deviceOwnerAuthentication` (Apple's
+  /// combined policy — no separate fallback branch needed), then hands back the
+  /// now-authenticated context for a single Keychain read via `kSecUseAuthenticationContext`.
+  private static func authenticatedContext(reason: String) async throws -> LAContext {
+    let context = LAContext()
+    var evalError: NSError?
+    guard context.canEvaluatePolicy(.deviceOwnerAuthentication, error: &evalError) else {
+      throw Exception(
+        name: "BiometryUnavailable",
+        description: evalError?.localizedDescription ?? "No biometry or device passcode is set up"
+      )
+    }
+    return try await withCheckedThrowingContinuation { continuation in
+      context.evaluatePolicy(.deviceOwnerAuthentication, localizedReason: reason) { success, authError in
+        if success {
+          continuation.resume(returning: context)
+        } else {
+          continuation.resume(throwing: Exception(
+            name: "AuthenticationFailed",
+            description: authError?.localizedDescription ?? "Authentication failed"
+          ))
+        }
+      }
     }
-    return Data(bytes)
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@chainberry/trust-wallet-core",
-  "version": "1.0.2",
-  "description": "Expo native module wrapping Trust Wallet Core for HD wallet generation, address derivation, and transaction signing (Ethereum, Solana, BNB)",
+  "version": "2.0.0",
+  "description": "Expo native module wrapping Trust Wallet Core for native-only HD wallet custody, address derivation, and transaction signing (Ethereum, BNB, Polygon, Solana, Tron, TON, Bitcoin, Bitcoin Cash, Litecoin, XRP) — mnemonic/private keys never cross the JS bridge",
   "main": "src/index.ts",
   "types": "src/index.ts",
   "license": "MIT",

package/src/index.ts

@@ -1,75 +1,70 @@
 import { requireNativeModule } from "expo-modules-core";
 
-export type SupportedCoin = "ethereum" | "solana" | "bnb";
+/**
+ * Mnemonic/private-key material never crosses this boundary except `exportMnemonic` —
+ * an explicit, biometric/passcode-gated backup flow. Every other function returns only
+ * walletIds, addresses, or signed transaction bytes/hex; wallet storage and all signing
+ * happen entirely inside the native module (see ios/TrustWalletCoreModule.swift,
+ * android/.../TrustWalletCoreModule.kt).
+ */
+export type Chain =
+  | "ethereum"
+  | "bnb"
+  | "polygon" // shares Ethereum's secp256k1 key/address — same BIP44 path, no distinct derivation
+  | "solana"
+  | "tron"
+  | "ton"
+  | "bitcoin"
+  | "bitcoincash" // address derivation only — sending is unsupported, see ChainSigner
+  | "litecoin"
+  | "xrp";
 
-export type CoinAccount = {
-  address: string;
-  privateKey: string;
+export type WalletSummary = {
+  walletId: string;
+  addresses: Record<Chain, string>;
 };
 
-export type WalletResult = {
-  mnemonic: string;
-  wallets: Record<SupportedCoin, string>;
+export type SignResult = {
+  signedTx: string;
+  meta?: Record<string, unknown>;
 };
 
 const TrustWalletCore = requireNativeModule("TrustWalletCore");
 
-// ─── Native calls ────────────────────────────────────────────────────────────
+/** Generates a new mnemonic and persists it natively (biometry/passcode-gated).
+ * strength 128 = 12 words, 256 = 24 words. */
+export async function createWallet(strength: 128 | 256 = 128, passphrase = ""): Promise<WalletSummary> {
+  return TrustWalletCore.createWallet(strength, passphrase);
+}
+
+/** One-time mnemonic exposure from the caller — persisted natively immediately, never
+ * retained in JS after this call returns. */
+export async function importWallet(mnemonic: string, passphrase = ""): Promise<WalletSummary> {
+  return TrustWalletCore.importWallet(mnemonic, passphrase);
+}
+
+/** Reads only public metadata (walletId + addresses) — no biometric prompt. */
+export async function listWallets(): Promise<WalletSummary[]> {
+  return TrustWalletCore.listWallets();
+}
 
-/** Create a new HD wallet and store encrypted keys for all supported coins */
-export async function generateWallet(
-  strength = 128,
-  passphrase = "",
-): Promise<WalletResult> {
-  const { mnemonic } = (await TrustWalletCore.generateWallet(
-    strength,
-    passphrase,
-  )) as { mnemonic: string };
-  const coins: SupportedCoin[] = ["ethereum", "solana", "bnb"];
-  const entries = await Promise.all(
-    coins.map(async (coin) => {
-      const { address } = await getAddressForCoin(
-        mnemonic,
-        coin,
-        passphrase,
-      );
-      return [coin, address] as const;
-    }),
-  );
-  return {
-    mnemonic,
-    wallets: Object.fromEntries(entries) as Record<SupportedCoin, string>,
-  };
+export async function deleteWallet(walletId: string): Promise<void> {
+  return TrustWalletCore.deleteWallet(walletId);
 }
 
-/** Validate and restore an existing wallet from a BIP-39 mnemonic */
-export async function restoreWallet(
-  mnemonic: string,
-  passphrase = "",
-): Promise<WalletResult> {
-  await TrustWalletCore.restoreWallet(mnemonic, passphrase);
-  const coins: SupportedCoin[] = ["ethereum", "solana", "bnb"];
-  const entries = await Promise.all(
-    coins.map(async (coin) => {
-      const { address } = await getAddressForCoin(
-        mnemonic,
-        coin,
-        passphrase,
-      );
-      return [coin, address] as const;
-    }),
-  );
-  return {
-    mnemonic,
-    wallets: Object.fromEntries(entries) as Record<SupportedCoin, string>,
-  };
+/** Triggers the native biometry/passcode prompt, then signs entirely in-process —
+ * only signed transaction bytes/hex cross back. */
+export async function signTransaction(
+  walletId: string,
+  chain: Chain,
+  unsignedTx: Record<string, unknown>,
+): Promise<SignResult> {
+  return TrustWalletCore.signTransaction(walletId, chain, unsignedTx);
 }
 
-/** Derive the address and private key for a specific coin from a mnemonic */
-export function getAddressForCoin(
-  mnemonic: string,
-  coin: SupportedCoin,
-  passphrase = "",
-): Promise<CoinAccount> {
-  return TrustWalletCore.getAddressForCoin(mnemonic, coin, passphrase);
+/** The one sanctioned mnemonic exposure — explicit backup/reveal flow only, gated behind
+ * a native biometry/passcode prompt. Callers must not hold onto the result beyond the
+ * immediate display/dismiss of the backup screen. */
+export async function exportMnemonic(walletId: string): Promise<string> {
+  return TrustWalletCore.exportMnemonic(walletId);
 }