@chainberry/trust-wallet-core 1.0.2 → 2.5.0

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

@@ -1,143 +0,0 @@
-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/ios/TrustWalletCoreModule.swift

@@ -1,145 +0,0 @@
-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)
-  }
-}