@chainberry/trust-wallet-core 1.0.0

package/README.md

@@ -0,0 +1,65 @@
+# @chainberry/trust-wallet-core
+
+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`).
+
+## Installation
+
+```sh
+npx expo install @chainberry/trust-wallet-core
+```
+
+This is an Expo config plugin module with native Android/iOS code, so it requires a development build (`expo prebuild` / EAS Build) — it will not work in Expo Go.
+
+### Android: GitHub Packages authentication required
+
+Trust Wallet Core's Android artifact is published to GitHub Packages, which requires authentication even though the package itself is public. Without credentials, `./gradlew` will fail to resolve `com.trustwallet:wallet-core`.
+
+Set up **one** of:
+
+```sh
+# Env vars (CI / one-off terminal)
+export GITHUB_ACTOR=your-github-username
+export GITHUB_TOKEN=ghp_xxxxxxxxxxxx   # classic PAT, read:packages scope only
+```
+
+or add to `~/.gradle/gradle.properties` (permanent local dev setup):
+
+```properties
+gpr.user=your-github-username
+gpr.key=ghp_xxxxxxxxxxxx
+```
+
+Generate a token at github.com/settings/tokens → "classic" → check `read:packages`.
+
+### iOS
+
+`WalletCore` is pulled in via CocoaPods (`s.dependency 'TrustWalletCore'`) — no extra auth needed, `pod install` handles it.
+
+## Usage
+
+```ts
+import { generateWallet, restoreWallet, getAddressForCoin } from "@chainberry/trust-wallet-core";
+
+const { mnemonic, wallets } = await generateWallet(); // 128-bit / 12-word by default
+// wallets: { ethereum: "0x...", solana: "...", bnb: "0x..." }
+
+const restored = await restoreWallet(mnemonic);
+
+const { address, privateKey } = await getAddressForCoin(mnemonic, "ethereum");
+```
+
+## 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"`).
+
+## Security note
+
+`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.
+
+## License
+
+MIT. Trust Wallet Core itself is Apache-2.0 — see [trustwallet/wallet-core](https://github.com/trustwallet/wallet-core) for its license.

package/TrustWalletCoreModule.podspec

@@ -0,0 +1,22 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name           = 'TrustWalletCoreModule'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = s.summary
+  # TODO: point at the real public repo URL before publishing to npm.
+  s.homepage       = 'https://github.com/chainberry/trust-wallet-core'
+  s.license        = package['license']
+  s.author         = 'Chainberry'
+  s.platform       = :ios, '16.0'
+  s.source         = { git: 'https://github.com/chainberry/trust-wallet-core.git', tag: "v#{package['version']}" }
+  s.static_framework = true
+
+  s.source_files = 'ios/**/*.{h,m,mm,swift}'
+
+  s.dependency 'ExpoModulesCore'
+  s.dependency 'TrustWalletCore'
+end

package/android/build.gradle

@@ -0,0 +1,67 @@
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+apply from: new File(
+  providers.exec {
+    workingDir(rootDir)
+    commandLine("node", "--print", "require.resolve('expo-modules-core/package.json')")
+  }.standardOutput.asText.get().trim(),
+  "../android/ExpoModulesCorePlugin.gradle"
+)
+
+applyKotlinExpoModulesCorePlugin()
+
+android {
+  namespace 'expo.modules.trustwalletcore'
+  compileSdkVersion 35
+
+  defaultConfig {
+    minSdkVersion 24
+    targetSdkVersion 35
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  kotlinOptions {
+    jvmTarget = '17'
+  }
+}
+
+// ─── wallet-core credentials ──────────────────────────────────────────────────
+// GitHub Packages requires auth even for public packages.
+// Priority order (first non-empty wins):
+//   1. Env vars     GITHUB_ACTOR / GITHUB_TOKEN       (CI / one-off terminal)
+//   2. Gradle props gpr.user / gpr.key in             (permanent dev setup)
+//        ~/.gradle/gradle.properties
+//
+// One-time dev setup — paste into ~/.gradle/gradle.properties:
+//   gpr.user=your-github-username
+//   gpr.key=ghp_xxxxxxxxxxxx   (classic PAT, read:packages scope only)
+//
+// Generate a token at: github.com/settings/tokens → "classic" → check read:packages
+
+def githubUser  = System.getenv("GITHUB_ACTOR")
+    ?: (project.hasProperty("gpr.user")  ? project.property("gpr.user")  : "")
+def githubToken = System.getenv("GITHUB_TOKEN")
+    ?: (project.hasProperty("gpr.key")   ? project.property("gpr.key")   : "")
+
+repositories {
+  maven {
+    url = uri("https://maven.pkg.github.com/trustwallet/wallet-core")
+    credentials {
+      username = githubUser
+      password = githubToken
+    }
+  }
+}
+
+useCoreDependencies()
+
+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'
+}

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

@@ -0,0 +1,143 @@
+package expo.modules.trustwalletcore
+
+import com.google.protobuf.ByteString
+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
+
+class TrustWalletCoreModule : Module() {
+  companion object {
+    init {
+      // Must be loaded once before any JNI calls
+      System.loadLibrary("TrustWalletCore")
+    }
+  }
+
+  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)
+    }
+
+    // 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(),
+      )
+    }
+
+    // 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}")
+      }
+      "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
+
+      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()
+
+      val output = AnySigner.sign(input, CoinType.SOLANA, Solana.SigningOutput.parser())
+      if (output.error != Common.SigningError.OK) {
+        throw Exception("Signing failed: ${output.errorMessage}")
+      }
+      output.encoded
+    }
+  }
+}
+
+// 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 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/expo-module.config.json

@@ -0,0 +1,9 @@
+{
+  "platforms": ["ios", "android"],
+  "ios": {
+    "modules": ["TrustWalletCoreModule"]
+  },
+  "android": {
+    "modules": ["expo.modules.trustwalletcore.TrustWalletCoreModule"]
+  }
+}

package/ios/TrustWalletCoreModule.swift

@@ -0,0 +1,145 @@
+import ExpoModulesCore
+import WalletCore
+
+// All numeric transaction fields are bare hex strings (no 0x prefix) to avoid JS number precision loss.
+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
+      guard let wallet = HDWallet(strength: UInt32(strength), passphrase: passphrase) else {
+        throw Exception(name: "WalletError", description: "Failed to generate wallet")
+      }
+      return ["mnemonic": wallet.mnemonic]
+    }
+
+    // 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
+      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,
+      ]
+    }
+
+    // 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()
+      }
+
+      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
+    }
+
+    // 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)")
+      }
+
+      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
+    }
+  }
+
+  // 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)")
+    }
+  }
+
+  // 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)
+  }
+
+  // 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
+    }
+    return Data(bytes)
+  }
+}

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@chainberry/trust-wallet-core",
+  "version": "1.0.0",
+  "description": "Expo native module wrapping Trust Wallet Core for HD wallet generation, address derivation, and transaction signing (Ethereum, Solana, BNB)",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "license": "MIT",
+  "files": [
+    "src",
+    "ios/TrustWalletCoreModule.swift",
+    "android/src",
+    "android/build.gradle",
+    "expo-module.config.json",
+    "TrustWalletCoreModule.podspec",
+    "README.md"
+  ],
+  "peerDependencies": {
+    "expo": "*",
+    "expo-modules-core": "*"
+  }
+}

package/src/index.ts

@@ -0,0 +1,75 @@
+import { requireNativeModule } from "expo-modules-core";
+
+export type SupportedCoin = "ethereum" | "solana" | "bnb";
+
+export type CoinAccount = {
+  address: string;
+  privateKey: string;
+};
+
+export type WalletResult = {
+  mnemonic: string;
+  wallets: Record<SupportedCoin, string>;
+};
+
+const TrustWalletCore = requireNativeModule("TrustWalletCore");
+
+// ─── Native calls ────────────────────────────────────────────────────────────
+
+/** 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>,
+  };
+}
+
+/** 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>,
+  };
+}
+
+/** 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);
+}