@chainberry/trust-wallet-core 2.0.0 → 2.5.1

package/ios/ChainberryTrustWalletCoreModule.swift

@@ -0,0 +1,336 @@
+import ExpoModulesCore
+import UIKit
+import WalletCore
+@preconcurrency import LocalAuthentication
+
+// 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 ChainberryTrustWalletCoreModule: Module {
+  public func definition() -> ModuleDefinition {
+    Name("TrustWalletCore")
+
+    // Runs once, right after module init, before any of the AsyncFunctions below can be reached
+    // from JS — so nothing can legitimately be mid-operation yet, which is exactly what makes a
+    // one-shot pass here sufficient (no lock/grace-period needed against an in-flight call). This
+    // is the actual crash-safety mechanism for an interrupted create/delete; see CONTEXT.md and
+    // docs/adr/0001. `reconcileOrphans` is non-throwing — never allowed to block or crash startup.
+    OnCreate {
+      NativeWalletStore.reconcileOrphans()
+    }
+
+    // strength 128 = 12 words, 256 = 24 words. Returns { walletId, addresses }.
+    // No BIP-39 passphrase support: signTransaction always reconstructs the wallet with an
+    // empty passphrase, so accepting one here would derive addresses from a seed different
+    // from the one actually used to sign — always pass "" to stay consistent with that.
+    // isTestnet selects the address format for BTC/LTC/BCH (see ChainSigner.address(for:)) —
+    // every other chain's address is the same on mainnet and testnet.
+    AsyncFunction("createWallet") { (strength: Int, isTestnet: Bool) throws -> [String: Any] in
+      guard let wallet = HDWallet(strength: Int32(strength), passphrase: "") else {
+        throw Exception(name: "WalletError", description: "Failed to generate wallet")
+      }
+      do {
+        return try Self.persistNewWallet(wallet: wallet, isTestnet: isTestnet)
+      } catch let e as NativeWalletStoreError {
+        throw e.asException
+      }
+    }
+
+    // One-time mnemonic exposure from JS, at import only — never retained after this call.
+    // Returns { walletId, addresses }. No BIP-39 passphrase support (see `createWallet`).
+    AsyncFunction("importWallet") { (mnemonic: String, isTestnet: Bool) throws -> [String: Any] in
+      guard let wallet = HDWallet(mnemonic: mnemonic, passphrase: "") else {
+        throw Exception(name: "InvalidMnemonic", description: "Invalid mnemonic phrase")
+      }
+      do {
+        return try Self.persistNewWallet(wallet: wallet, isTestnet: isTestnet)
+      } catch let e as NativeWalletStoreError {
+        throw e.asException
+      }
+    }
+
+    // Reads only the ungated metadata store — no biometric prompt.
+    AsyncFunction("listWallets") { () throws -> [[String: Any]] in
+      do {
+        return try NativeWalletStore.loadMetadata().map { walletId, addresses in
+          ["walletId": walletId, "addresses": addresses]
+        }
+      } catch let e as NativeWalletStoreError {
+        throw e.asException
+      }
+    }
+
+    // Irreversible — requires a fresh biometric/passcode confirmation before anything is
+    // deleted, same gate as `signTransaction`/`exportMnemonic`. A compromised/malicious JS
+    // caller can still invoke this directly (there's no UI call site today), so the gate
+    // must live here rather than in JS.
+    //
+    // Removes the metadata entry *before* the secret (Keychain item) — the reverse of the old
+    // ordering. If this is interrupted between the two steps, the wallet is already gone from
+    // `listWallets` and only an orphaned Keychain item is left behind, which the next app
+    // launch's reconciliation pass cleans up (see docs/adr/0001) — never a metadata record still
+    // pointing at a secret that's already gone.
+    AsyncFunction("deleteWallet") { (walletId: String) async throws -> Void in
+      try await Self.withLifecycleLock(rejectIfBusy: false) {
+        do {
+          let id = try NativeWalletStore.validateWalletId(walletId)
+          _ = try await Self.authenticatedContext(reason: "Delete wallet")
+          var metadata = try NativeWalletStore.loadMetadata()
+          metadata.removeValue(forKey: id)
+          try NativeWalletStore.saveMetadata(metadata)
+          try NativeWalletStore.deleteMnemonic(walletId: id)
+        } catch let e as NativeWalletStoreError {
+          throw e.asException
+        }
+      }
+    }
+
+    // Triggers the native biometry/passcode prompt, then signs entirely in-process.
+    // Returns { signedTx, meta? }. isTestnet must match whatever `createWallet`/`importWallet`
+    // used — see ChainSigner.key(for:) (a mismatch signs with the wrong key for BTC/LTC).
+    AsyncFunction("signTransaction") { (walletId: String, chain: String, unsignedTx: [String: Any], isTestnet: Bool) async throws -> [String: Any] in
+      do {
+        let id = try NativeWalletStore.validateWalletId(walletId)
+        let chainKey = try ChainKey(fromJs: chain)
+        try await Self.confirmTransaction(chain: chainKey, unsignedTx: unsignedTx)
+        let context = try await Self.authenticatedContext(reason: "Sign transaction")
+        let mnemonic = try NativeWalletStore.loadMnemonic(walletId: id, context: context)
+        guard let wallet = HDWallet(mnemonic: mnemonic, passphrase: "") else {
+          throw Exception(name: "InvalidMnemonic", description: "Stored mnemonic failed validation")
+        }
+        // Backfill any addresses that were missing when the wallet was first stored
+        // (e.g. chains added after the wallet was created). Runs silently after the
+        // biometric gate — no extra prompt needed.
+        var metadata = try NativeWalletStore.loadMetadata()
+        if var storedAddresses = metadata[id] {
+          var changed = false
+          for chain in ChainKey.allCases {
+            if storedAddresses[chain.rawValue] == nil {
+              storedAddresses[chain.rawValue] = ChainSigner.address(for: chain, wallet: wallet, isTestnet: isTestnet)
+              changed = true
+            }
+          }
+          if changed {
+            metadata[id] = storedAddresses
+            try? NativeWalletStore.saveMetadata(metadata)
+          }
+        }
+        let result = try ChainSigner.sign(chain: chainKey, wallet: wallet, unsignedTx: unsignedTx, isTestnet: isTestnet)
+        var response: [String: Any] = ["signedTx": result.signedTx]
+        if let meta = result.meta { response["meta"] = meta }
+        return response
+      } catch let e as NativeWalletStoreError {
+        throw e.asException
+      }
+    }
+
+    // The one sanctioned mnemonic exposure — explicit backup flow only.
+    AsyncFunction("exportMnemonic") { (walletId: String) async throws -> String in
+      do {
+        let id = try NativeWalletStore.validateWalletId(walletId)
+        let context = try await Self.authenticatedContext(reason: "Reveal recovery phrase")
+        return try NativeWalletStore.loadMnemonic(walletId: id, context: context)
+      } catch let e as NativeWalletStoreError {
+        throw e.asException
+      }
+    }
+  }
+
+  // MARK: - Lifecycle serialization (see docs/adr/0002)
+
+  /// Serializes create/import/delete against each other — a `Task`-based actor rather than
+  /// `NSLock`, since these calls `await` across the biometric prompt and holding an `NSLock`
+  /// across a suspension point (where Swift Concurrency may resume on a different underlying
+  /// thread) is unsafe.
+  private actor LifecycleLock {
+    private var locked = false
+    private var waiters: [CheckedContinuation<Void, Never>] = []
+
+    /// Non-blocking: returns `false` immediately if already held (used by create/import, which
+    /// reject rather than queue).
+    func tryAcquire() -> Bool {
+      guard !locked else { return false }
+      locked = true
+      return true
+    }
+
+    /// Blocking: waits until the lock is free, then acquires it (used by delete, which queues).
+    func acquire() async {
+      guard locked else {
+        locked = true
+        return
+      }
+      await withCheckedContinuation { waiters.append($0) }
+    }
+
+    /// Hands ownership directly to the next waiter rather than freeing the lock and letting
+    /// every waiter race a fresh `tryAcquire`/`acquire`.
+    func release() {
+      if !waiters.isEmpty {
+        waiters.removeFirst().resume()
+      } else {
+        locked = false
+      }
+    }
+  }
+
+  private static let lifecycleLock = LifecycleLock()
+
+  /// Serializes `body` — including the biometric/passcode prompt, not just the store writes —
+  /// against every other lifecycle-mutating call, so at most one is ever touching the shared
+  /// metadata store at a time (see docs/adr/0002). Also forecloses a second, separate bug: two
+  /// concurrent `LAContext` evaluations racing each other.
+  ///
+  /// `rejectIfBusy` chooses the policy for a caller that finds the lock already held:
+  /// `createWallet`/`importWallet` reject immediately (`ERR_WALLET_OPERATION_IN_PROGRESS`) so a
+  /// double-tap can never mint two wallets; `deleteWallet` queues instead, since two distinct
+  /// deletes are both legitimate and should both eventually happen.
+  private static func withLifecycleLock<T>(rejectIfBusy: Bool, _ body: () async throws -> T) async throws -> T {
+    if rejectIfBusy {
+      guard await lifecycleLock.tryAcquire() else {
+        throw Exception(
+          name: "OperationInProgress",
+          description: "Another wallet operation is already in progress",
+          code: "ERR_WALLET_OPERATION_IN_PROGRESS"
+        )
+      }
+    } else {
+      await lifecycleLock.acquire()
+    }
+    do {
+      let result = try await body()
+      await lifecycleLock.release()
+      return result
+    } catch {
+      await lifecycleLock.release()
+      throw error
+    }
+  }
+
+  // MARK: - Helpers
+
+  /// Presents a native UIAlertController showing decoded tx details (chain, recipient, amount,
+  /// fee). The user must tap "Confirm & Sign" before biometric auth fires — this is the only
+  /// place in the native module where informed consent is collected.
+  private static func confirmTransaction(chain: ChainKey, unsignedTx: [String: Any]) async throws {
+    let message = try ChainSigner.buildSummary(chain: chain, unsignedTx: unsignedTx)
+    try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in
+      DispatchQueue.main.async {
+        let scene = UIApplication.shared.connectedScenes
+          .filter({ $0.activationState == .foregroundActive })
+          .compactMap({ $0 as? UIWindowScene })
+          .first
+        var rootVC = scene?.windows.first(where: { $0.isKeyWindow })?.rootViewController
+        while let presented = rootVC?.presentedViewController { rootVC = presented }
+        guard let topVC = rootVC else {
+          continuation.resume(throwing: Exception(name: "NoViewController", description: "Cannot present confirmation"))
+          return
+        }
+        let alert = UIAlertController(title: "Confirm Transaction", message: message, preferredStyle: .alert)
+        alert.addAction(UIAlertAction(title: "Cancel", style: .cancel) { _ in
+          continuation.resume(throwing: Exception(name: "UserCancelled", description: "Transaction cancelled by user"))
+        })
+        alert.addAction(UIAlertAction(title: "Confirm & Sign", style: .default) { _ in
+          continuation.resume(returning: ())
+        })
+        topVC.present(alert, animated: true)
+      }
+    }
+  }
+
+  private static func persistNewWallet(wallet: HDWallet, isTestnet: Bool) throws -> [String: Any] {
+    let walletId = UUID().uuidString
+    var addresses: [String: String] = [:]
+    for chain in ChainKey.allCases {
+      addresses[chain.rawValue] = ChainSigner.address(for: chain, wallet: wallet, isTestnet: isTestnet)
+    }
+
+    try NativeWalletStore.saveMnemonic(wallet.mnemonic, walletId: walletId)
+    do {
+      var metadata = try NativeWalletStore.loadMetadata()
+      metadata[walletId] = addresses
+      try NativeWalletStore.saveMetadata(metadata)
+    } catch {
+      // The mnemonic is already persisted but has no metadata pointer — compensate by
+      // best-effort deleting it rather than leaving a permanent, invisible orphan. If this
+      // rollback delete also fails, there's nothing more useful to do than propagate the
+      // original error; the item is at least no worse off than before this call.
+      try? NativeWalletStore.deleteMnemonic(walletId: walletId)
+      throw error
+    }
+
+    return ["walletId": walletId, "addresses": addresses]
+  }
+
+  /// 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 classifyAuthError(evalError, fallbackDescription: "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: classifyAuthError(authError, fallbackDescription: "Authentication failed"))
+        }
+      }
+    }
+  }
+
+  /// Classifies an `LAError` from either `canEvaluatePolicy`'s precheck or `evaluatePolicy`'s
+  /// prompt callback into the same typed error codes Android's `NativeWalletStore.kt`
+  /// (`classifyPromptError`/`AuthUnavailable`) uses, so `use-wallet.ts`'s `WALLET_ERROR_COPY` —
+  /// written once, keyed by code, shared across both platforms — actually fires here instead of
+  /// every prompt failure collapsing into one generic "Authentication failed" banner. This
+  /// matters most for cancellation: dismissing the prompt must produce `ERR_WALLET_AUTH_CANCELLED`
+  /// (mapped to a quiet no-op, not a banner) on both platforms, not just Android.
+  ///
+  /// Deliberately does not attempt an iOS equivalent of Android's `KeyInvalidated`
+  /// (`KeyPermanentlyInvalidatedException` after an enrollment change) — on iOS that surfaces
+  /// later, as a `SecItemCopyMatching` `OSStatus` failure inside `loadMnemonic`, not as an
+  /// `LAError` here; aligning that would mean auditing `NativeWalletStore.classify(_:)`'s
+  /// `errSecAuthFailed`/`errSecInteractionNotAllowed` handling separately; scoped out of this
+  /// pass since a wrong OSStatus->meaning mapping there is materially harder to get right without
+  /// device verification than this prompt-level LAError classification is.
+  private static func classifyAuthError(_ error: Error?, fallbackDescription: String) -> Exception {
+    guard let laError = error as? LAError else {
+      return Exception(
+        name: "AuthenticationFailed",
+        description: error?.localizedDescription ?? fallbackDescription,
+        code: "ERR_AUTHENTICATION_FAILED"
+      )
+    }
+    switch laError.code {
+    case .userCancel, .appCancel, .systemCancel:
+      // User dismissed the prompt rather than authentication actually failing — kept distinct
+      // from the default case below so `WALLET_ERROR_COPY`'s `null` entry for this code can
+      // treat it as a quiet no-op instead of an error to surface (mirrors Android's
+      // `AuthCancelled`).
+      return Exception(name: "AuthCancelled", description: "Authentication was cancelled", code: "ERR_WALLET_AUTH_CANCELLED")
+    case .biometryLockout:
+      // iOS exposes one lockout state (cleared only by a passcode unlock), closest to Android's
+      // ERROR_LOCKOUT_PERMANENT rather than its auto-clearing temporary variant.
+      return Exception(
+        name: "AuthLockedOutPermanent",
+        description: "Too many failed authentication attempts — unlock your device to reset",
+        code: "ERR_WALLET_AUTH_LOCKED_OUT_PERMANENT"
+      )
+    case .biometryNotAvailable, .biometryNotEnrolled, .passcodeNotSet:
+      // Existing-wallet-use-time unavailability (no secure auth is currently satisfiable) —
+      // mirrors Android's `AuthUnavailable` precheck, distinct from `.noDevicePasscode`
+      // (`ERR_NO_DEVICE_PASSCODE`) which is specifically the wallet-*creation*-time gate.
+      return Exception(
+        name: "AuthUnavailable",
+        description: "Authentication unavailable: \(laError.localizedDescription)",
+        code: "ERR_WALLET_AUTH_UNAVAILABLE"
+      )
+    default:
+      return Exception(name: "AuthenticationFailed", description: laError.localizedDescription, code: "ERR_AUTHENTICATION_FAILED")
+    }
+  }
+}

package/ios/ConformanceTests/AddressDerivationConformanceTests.swift

@@ -0,0 +1,39 @@
+import XCTest
+import WalletCore
+
+// iOS companion to android/src/androidTest/.../AddressDerivationConformanceTest.kt.
+// Verifies that HDWallet.getAddressForCoin produces the expected address for every
+// chain under WalletCore 4.1.19 (the pinned version).
+//
+// The test mnemonic is the BIP39 standard test vector — never use with real funds.
+//
+// How to run:
+//   xcodebuild test -workspace ios/vault.xcworkspace -scheme WalletConformanceTests \
+//     -destination 'platform=iOS Simulator,name=iPhone 17'
+final class AddressDerivationConformanceTests: XCTestCase {
+
+  static let mnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about"
+
+  // All addresses confirmed against WalletCore 4.1.19 on-device (Android instrumented test
+  // 2026-08-27; iOS confirmed via this test suite). ETH/BNB/POL share CoinType.ethereum.
+  static let verified: [(coin: CoinType, chain: String, expected: String)] = [
+    (.ethereum,    "ethereum",    "0x9858EfFD232B4033E47d90003D41EC34EcaEda94"),
+    (.smartChain,  "bnb",         "0x9858EfFD232B4033E47d90003D41EC34EcaEda94"),
+    (.ethereum,    "polygon",     "0x9858EfFD232B4033E47d90003D41EC34EcaEda94"),
+    (.bitcoin,     "bitcoin",     "bc1qcr8te4kr609gcawutmrza0j4xv80jy8z306fyu"),
+    (.litecoin,    "litecoin",    "ltc1qjmxnz78nmc8nq77wuxh25n2es7rzm5c2rkk4wh"),
+    (.xrp,         "xrp",         "rHsMGQEkVNJmpGWs8XUBoTBiAAbwxZN5v3"),
+    (.tron,        "tron",        "TUEZSdKsoDHQMeZwihtdoBiN46zxhGWYdH"),
+    (.ton,         "ton",         "UQAzWZa6nM5mJev91wGc7VCSfBoIsYRqKJpV78N8Add9-RKY"),
+    (.solana,      "solana",      "GjJyeC1r2RgkuoCWMyPYkCWSGSGLcz266EaAkLA27AhL"),
+    (.bitcoinCash, "bitcoincash", "bitcoincash:qqyx49mu0kkn9ftfj6hje6g2wfer34yfnq5tahq3q6"),
+  ]
+
+  func testVerifiedAddressesMatch() {
+    let wallet = HDWallet(mnemonic: Self.mnemonic, passphrase: "")!
+    for v in Self.verified {
+      let actual = wallet.getAddressForCoin(coin: v.coin)
+      XCTAssertEqual(actual, v.expected, "chain '\(v.chain)': derived '\(actual)' ≠ expected '\(v.expected)'")
+    }
+  }
+}

package/ios/ConformanceTests/SigningConformanceTests.swift

@@ -0,0 +1,295 @@
+import XCTest
+import WalletCore
+
+// Mirrors Android's SigningConformanceTest.kt: reads conformance/signing-vectors.json and asserts
+// iOS WalletCore 4.1.19 produces byte-for-byte identical signed transactions. Covers every status:
+//   "verified"                  — assert output == expectedSignedTx
+//   "verified-non-deterministic"— assert signing succeeds and output is structurally valid (TON)
+//   "verified-android-only"     — run the same input on iOS to confirm cross-platform parity (TRX)
+//
+// Add this file to an XCTest target in vault.xcworkspace that links WalletCore.xcframework.
+class SigningConformanceTests: XCTestCase {
+
+  private struct SigningVector: Decodable {
+    let chain: String
+    let status: String
+    let unsignedTx: [String: JSONValue]
+    let expectedSignedTx: String?
+  }
+
+  private struct FixtureFile: Decodable {
+    let testMnemonic: String
+    let testPassphrase: String
+    let signingVectors: [SigningVector]
+  }
+
+  // Minimal JSON value type so unsignedTx can be decoded without knowing its shape up front.
+  private enum JSONValue: Decodable {
+    case string(String), int(Int), double(Double), bool(Bool), array([JSONValue]), object([String: JSONValue]), null
+    init(from decoder: Decoder) throws {
+      let c = try decoder.singleValueContainer()
+      if c.decodeNil() { self = .null }
+      else if let v = try? c.decode(Bool.self) { self = .bool(v) }
+      else if let v = try? c.decode(Int.self) { self = .int(v) }
+      else if let v = try? c.decode(Double.self) { self = .double(v) }
+      else if let v = try? c.decode(String.self) { self = .string(v) }
+      else if let v = try? c.decode([JSONValue].self) { self = .array(v) }
+      else { self = .object(try c.decode([String: JSONValue].self)) }
+    }
+    var string: String? { if case .string(let s) = self { return s }; return nil }
+    var int: Int? { if case .int(let i) = self { return i }; return nil }
+    var object: [String: JSONValue]? { if case .object(let o) = self { return o }; return nil }
+    var array: [JSONValue]? { if case .array(let a) = self { return a }; return nil }
+  }
+
+  private func loadFixture() throws -> FixtureFile {
+    let thisFile = URL(fileURLWithPath: #filePath)
+    let url = thisFile
+      .deletingLastPathComponent()
+      .deletingLastPathComponent()
+      .deletingLastPathComponent()
+      .appendingPathComponent("conformance/signing-vectors.json")
+      .standardizedFileURL
+    return try JSONDecoder().decode(FixtureFile.self, from: Data(contentsOf: url))
+  }
+
+  private var wallet: HDWallet!
+
+  override func setUpWithError() throws {
+    let fixture = try loadFixture()
+    guard let w = HDWallet(mnemonic: fixture.testMnemonic, passphrase: fixture.testPassphrase) else {
+      throw XCTSkip("HDWallet init failed")
+    }
+    wallet = w
+  }
+
+  // MARK: - Per-chain tests
+
+  func testEthereum() throws { try runVector(chain: "ethereum") }
+  func testPolygon()  throws { try runVector(chain: "polygon") }
+  func testBitcoin()  throws { try runVector(chain: "bitcoin") }
+  func testLitecoin() throws { try runVector(chain: "litecoin") }
+  func testXrp()      throws { try runVector(chain: "xrp") }
+  func testTron()     throws { try runVector(chain: "tron") }
+  func testSolana()   throws { try runVector(chain: "solana") }
+  func testTon()      throws { try runVector(chain: "ton") }
+
+  // MARK: - Dispatch
+
+  private func runVector(chain: String) throws {
+    let fixture = try loadFixture()
+    guard let v = fixture.signingVectors.first(where: { $0.chain == chain }) else {
+      throw XCTSkip("No vector for chain '\(chain)'")
+    }
+    let tx = v.unsignedTx
+    switch chain {
+    case "ethereum", "polygon": try assertEvm(v, tx: tx)
+    case "bitcoin", "litecoin": try assertUtxo(v, tx: tx)
+    case "xrp":    try assertXrp(v, tx: tx)
+    case "tron":   try assertTron(v, tx: tx)
+    case "solana": try assertSolana(v, tx: tx)
+    case "ton":    try assertTon(v, tx: tx)
+    default: XCTFail("No signing impl for chain '\(chain)'")
+    }
+  }
+
+  // MARK: - EVM
+
+  private func assertEvm(_ v: SigningVector, tx: [String: JSONValue]) throws {
+    let coin: CoinType = .ethereum
+    let pk = wallet.getKeyForCoin(coin: coin)
+    guard let to      = tx["to"]?.string,
+          let nonce   = tx["nonce"]?.int,
+          let gasLim  = tx["gasLimitHex"]?.string,
+          let chainId = tx["chainId"]?.int else {
+      XCTFail("Missing EVM params"); return
+    }
+    let valueHex = tx["valueHex"]?.string ?? "0"
+    var input = EthereumSigningInput()
+    input.chainID    = BigIntHelper(chainId).toMinimal()
+    input.nonce      = BigIntHelper(nonce).toMinimal()
+    input.gasLimit   = Data(hexString: gasLim.padEven())!
+    input.toAddress  = to
+    input.privateKey = pk.data
+    var transfer = EthereumTransaction.Transfer()
+    transfer.amount = Data(hexString: valueHex.padEven()) ?? Data([0])
+    var etx = EthereumTransaction(); etx.transfer = transfer
+    input.transaction = etx
+    if let gp = tx["gasPriceHex"]?.string {
+      input.gasPrice = Data(hexString: gp.padEven())!
+    } else if let mf = tx["maxFeePerGasHex"]?.string,
+              let pf = tx["maxPriorityFeePerGasHex"]?.string {
+      input.txMode = .enveloped
+      input.maxFeePerGas         = Data(hexString: mf.padEven())!
+      input.maxInclusionFeePerGas = Data(hexString: pf.padEven())!
+    }
+    let out: EthereumSigningOutput = AnySigner.sign(input: input, coin: coin)
+    XCTAssertEqual(out.error, .ok, "EVM signing error: \(out.errorMessage)")
+    let signed = "0x" + out.encoded.hexString
+    if v.status == "verified", let expected = v.expectedSignedTx {
+      XCTAssertEqual(signed, expected, "chain '\(v.chain)': signed tx mismatch")
+    }
+  }
+
+  // MARK: - UTXO (BTC / LTC)
+
+  private func assertUtxo(_ v: SigningVector, tx: [String: JSONValue]) throws {
+    let coin: CoinType = v.chain == "litecoin" ? .litecoin : .bitcoin
+    let pk = wallet.getKeyForCoin(coin: coin)
+    guard let toAddress     = tx["toAddress"]?.string,
+          let changeAddress = tx["changeAddress"]?.string,
+          let sendSats      = tx["sendAmountSats"]?.string.flatMap(Int64.init),
+          let spbNum        = tx["satsPerByte"]?.int,
+          let inputArr      = tx["inputs"]?.array else {
+      XCTFail("Missing UTXO params"); return
+    }
+    var input = BitcoinSigningInput()
+    input.hashType      = BitcoinScript.hashTypeForCoin(coinType: coin)
+    input.amount        = sendSats
+    input.byteFee       = Int64(spbNum)
+    input.toAddress     = toAddress
+    input.changeAddress = changeAddress
+    input.useMaxAmount  = false
+    input.coinType      = coin.rawValue
+    input.privateKey    = [pk.data]
+    input.utxo = inputArr.compactMap { entry -> BitcoinUnspentTransaction? in
+      guard let obj      = entry.object,
+            let txId     = obj["txIdHex"]?.string,
+            let vout     = obj["vout"]?.int,
+            let amt      = obj["amountSats"]?.string.flatMap(Int64.init),
+            let script   = obj["scriptPubKeyHex"]?.string,
+            let scriptData = Data(hexString: script),
+            var txIdData   = Data(hexString: txId) else { return nil }
+      txIdData.reverse()
+      var op = BitcoinOutPoint(); op.hash = txIdData; op.index = UInt32(vout)
+      var utxo = BitcoinUnspentTransaction()
+      utxo.outPoint = op; utxo.amount = amt; utxo.script = scriptData
+      return utxo
+    }
+    let out: BitcoinSigningOutput = AnySigner.sign(input: input, coin: coin)
+    XCTAssertEqual(out.error, .ok, "UTXO signing error: \(out.errorMessage)")
+    if v.status == "verified", let expected = v.expectedSignedTx {
+      XCTAssertEqual(out.encoded.hexString, expected, "chain '\(v.chain)': signed tx mismatch")
+    }
+  }
+
+  // MARK: - XRP
+
+  private func assertXrp(_ v: SigningVector, tx: [String: JSONValue]) throws {
+    let pk = wallet.getKeyForCoin(coin: .xrp)
+    guard let account  = tx["Account"]?.string,
+          let dest     = tx["Destination"]?.string,
+          let amount   = tx["Amount"]?.string.flatMap(Int64.init),
+          let fee      = tx["Fee"]?.string.flatMap(Int64.init),
+          let sequence = tx["Sequence"]?.int else {
+      XCTFail("Missing XRP params"); return
+    }
+    var payment = RippleOperationPayment()
+    payment.amount = amount; payment.destination = dest
+    var input = RippleSigningInput()
+    input.privateKey = pk.data; input.account = account
+    input.fee = fee; input.sequence = Int32(sequence)
+    if let lls = tx["LastLedgerSequence"]?.int { input.lastLedgerSequence = Int32(lls) }
+    input.opPayment = payment
+    let out: RippleSigningOutput = AnySigner.sign(input: input, coin: .xrp)
+    XCTAssertEqual(out.error, .ok, "XRP signing error: \(out.errorMessage)")
+    if v.status == "verified", let expected = v.expectedSignedTx {
+      XCTAssertEqual(out.encoded.hexString, expected, "chain 'xrp': signed tx mismatch")
+    }
+  }
+
+  // MARK: - TRX
+
+  private func assertTron(_ v: SigningVector, tx: [String: JSONValue]) throws {
+    let pk = wallet.getKeyForCoin(coin: .tron)
+    guard let txID = tx["txID"]?.string else { XCTFail("Missing TRX txID"); return }
+    var input = TronSigningInput()
+    input.privateKey = pk.data
+    input.txID = txID
+    let out: TronSigningOutput = AnySigner.sign(input: input, coin: .tron)
+    XCTAssertEqual(out.error, .ok, "TRX signing error: \(out.errorMessage)")
+    let signatureHex = out.signature.hexString
+    XCTAssertFalse(signatureHex.isEmpty, "TRX: empty signature")
+    // verified-android-only: same private key + same digest → same ECDSA sig — mismatch is a real bug.
+    if let expected = v.expectedSignedTx,
+       let data = expected.data(using: .utf8),
+       let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+       let sigs = json["signature"] as? [String],
+       let androidSig = sigs.first {
+      XCTAssertEqual(signatureHex, androidSig,
+        "TRX: iOS signature differs from Android — same digest + key must produce same ECDSA sig")
+    }
+  }
+
+  // MARK: - Solana
+
+  private func assertSolana(_ v: SigningVector, tx: [String: JSONValue]) throws {
+    let pk = wallet.getKeyForCoin(coin: .solana)
+    guard let b64 = tx["unsignedTxBase64"]?.string,
+          let txBytes = Data(base64Encoded: b64) else {
+      XCTFail("Missing/invalid Solana unsignedTxBase64"); return
+    }
+    let decoded = TransactionDecoder.decode(coinType: .solana, encodedTx: txBytes)
+    let decodedOut = try SolanaDecodingTransactionOutput(serializedBytes: decoded)
+    XCTAssertEqual(decodedOut.error, .ok, "SOL decode error: \(decodedOut.errorMessage)")
+    let blockhash = decodedOut.transaction.legacy.recentBlockhash
+    let keys = DataVector(); keys.add(data: pk.data)
+    let signedBytes = SolanaTransaction.updateBlockhashAndSign(
+      encodedTx: b64, recentBlockhash: blockhash, privateKeys: keys)
+    let signedOut = try SolanaSigningOutput(serializedBytes: signedBytes)
+    XCTAssertEqual(signedOut.error, .ok, "SOL signing error: \(signedOut.errorMessage)")
+    if v.status == "verified", let expected = v.expectedSignedTx {
+      XCTAssertEqual(signedOut.encoded, expected, "chain 'solana': signed tx mismatch")
+    }
+  }
+
+  // MARK: - TON (non-deterministic — verify structure only)
+
+  private func assertTon(_ v: SigningVector, tx: [String: JSONValue]) throws {
+    let pk = wallet.getKeyForCoin(coin: .ton)
+    guard let toAddress = tx["toAddress"]?.string,
+          let amountStr = tx["amount"]?.string,
+          let nanotons  = UInt64(amountStr),
+          let seqno     = tx["seqno"]?.int else {
+      XCTFail("Missing TON params"); return
+    }
+    var transfer = TheOpenNetworkTransfer()
+    transfer.dest   = toAddress
+    transfer.amount = nanotons
+    transfer.mode   = UInt32(
+      TheOpenNetworkSendMode.payFeesSeparately.rawValue |
+      TheOpenNetworkSendMode.ignoreActionPhaseErrors.rawValue)
+    transfer.bounceable = true
+    if let memo = tx["memoId"]?.string { transfer.comment = memo }
+    var input = TheOpenNetworkSigningInput()
+    input.privateKey     = pk.data
+    input.walletVersion  = .walletV4R2
+    input.sequenceNumber = UInt32(seqno)
+    input.expireAt       = UInt32(Date().timeIntervalSince1970) + 600
+    input.messages       = [transfer]
+    let out: TheOpenNetworkSigningOutput = AnySigner.sign(input: input, coin: .ton)
+    XCTAssertEqual(out.error, .ok, "TON signing error: \(out.errorMessage)")
+    // Non-deterministic due to wall-clock expireAt — check well-formed BOC and 32-byte hash only.
+    XCTAssertTrue(out.encoded.hasPrefix("te6cc"),
+      "TON: unexpected BOC prefix in '\(out.encoded)'")
+    XCTAssertEqual(out.hash.count, 32,
+      "TON: txHash should be 32 bytes, got \(out.hash.count)")
+  }
+}
+
+// MARK: - Helpers
+
+private extension String {
+  func padEven() -> String { count % 2 == 0 ? self : "0" + self }
+}
+
+private struct BigIntHelper {
+  let value: Int
+  init(_ v: Int) { value = v }
+  func toMinimal() -> 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)
+  }
+}