@chainberry/trust-wallet-core 2.5.0 → 2.5.2

package/ios/ChainSigning.swift

@@ -3,6 +3,7 @@ import ExpoModulesCore
 import WalletCore
 
 // All chains this module derives addresses for / signs transactions for.
+
 enum ChainKey: String, CaseIterable {
   case ethereum, bnb, polygon
   case avax, base, arbitrum, optimism, sonic
@@ -10,6 +11,9 @@ enum ChainKey: String, CaseIterable {
   case tron, ton
   case bitcoin, bitcoincash, dogecoin, litecoin
   case xrp
+  case cosmos
+  case aptos
+  case tezos
 
   init(fromJs raw: String) throws {
     guard let key = ChainKey(rawValue: raw) else {
@@ -36,6 +40,9 @@ enum ChainKey: String, CaseIterable {
     case .dogecoin: return "DOGE"
     case .litecoin: return "LTC"
     case .xrp:      return "XRP"
+    case .cosmos:   return "ATOM"
+    case .aptos:    return "APT"
+    case .tezos:    return "XTZ"
     }
   }
 
@@ -52,6 +59,9 @@ enum ChainKey: String, CaseIterable {
     case .dogecoin: return .dogecoin
     case .litecoin: return .litecoin
     case .xrp: return .xrp
+    case .cosmos: return .cosmos
+    case .aptos: return .aptos
+    case .tezos: return .tezos
     }
   }
 }
@@ -147,6 +157,12 @@ enum ChainSigner {
       return try signTon(wallet: wallet, txParams: unsignedTx)
     case .bitcoincash:
       return Result(signedTx: try signBch(wallet: wallet, txParams: unsignedTx), meta: nil)
+    case .cosmos:
+      return Result(signedTx: try signCosmos(wallet: wallet, txParams: unsignedTx), meta: nil)
+    case .aptos:
+      return Result(signedTx: try signAptos(wallet: wallet, txParams: unsignedTx), meta: nil)
+    case .tezos:
+      return Result(signedTx: try signTezos(wallet: wallet, txParams: unsignedTx), meta: nil)
     }
   }
 
@@ -239,7 +255,7 @@ enum ChainSigner {
     // TW's sanctioned path. We pass the same blockhash back (no-op refresh) so the
     // tx content is unchanged — only the signature is added.
     let decodedData = TransactionDecoder.decode(coinType: .solana, encodedTx: txData)
-    let decoded = try SolanaDecodingTransactionOutput(serializedData: decodedData)
+    let decoded = try SolanaDecodingTransactionOutput(serializedBytes: decodedData)
     guard decoded.error == .ok else {
       throw Exception(name: "DecodingFailed", description: "Failed to decode SOL tx: \(decoded.errorMessage)")
     }
@@ -247,12 +263,10 @@ enum ChainSigner {
 
     let privateKeys = DataVector()
     privateKeys.add(data: privateKey.data)
-    guard let outputData = SolanaTransaction.updateBlockhashAndSign(
+    let outputData = SolanaTransaction.updateBlockhashAndSign(
       encodedTx: unsignedTxBase64, recentBlockhash: recentBlockhash, privateKeys: privateKeys
-    ) else {
-      throw Exception(name: "SigningFailed", description: "SolanaTransaction.updateBlockhashAndSign returned nil")
-    }
-    let output = try SolanaSigningOutput(serializedData: outputData)
+    )
+    let output = try SolanaSigningOutput(serializedBytes: outputData)
     guard output.error == .ok else {
       throw Exception(name: "SigningFailed", description: output.errorMessage)
     }
@@ -389,26 +403,29 @@ enum ChainSigner {
   private static func signTron(wallet: HDWallet, txParams: [String: Any]) throws -> String {
     let privateKey = wallet.getKeyForCoin(coin: .tron)
 
-    // Pass the full TronGrid unsigned tx JSON via rawJson — wallet-core's direct-sign path
-    // reads txID from the JSON and signs that digest, returning the complete signed tx in output.json.
+    // Sign via txID — wallet-core reads the txID digest and signs it directly.
     // This covers both plain TRX transfers and TRC20 triggerSmartContract payloads.
-    guard JSONSerialization.isValidJSONObject(txParams) else {
-      throw Exception(name: "InvalidParams", description: "TRX tx is not JSON-serializable")
-    }
-    let jsonData = try JSONSerialization.data(withJSONObject: txParams)
-    guard let jsonStr = String(data: jsonData, encoding: .utf8) else {
-      throw Exception(name: "InvalidParams", description: "TRX tx JSON encoding failed")
+    guard let txID = txParams["txID"] as? String else {
+      throw Exception(name: "InvalidParams", description: "Missing txID in TRX tx params")
     }
 
     var input = TronSigningInput()
     input.privateKey = privateKey.data
-    input.rawJson = jsonStr
+    input.txID = txID
 
     let output: TronSigningOutput = AnySigner.sign(input: input, coin: .tron)
     guard output.error == .ok else {
       throw Exception(name: "SigningFailed", description: output.errorMessage)
     }
-    return output.json
+
+    // Reconstruct the full TronGrid broadcast payload with the signature appended.
+    var broadcastTx = txParams
+    broadcastTx["signature"] = [output.signature.hexString]
+    let broadcastData = try JSONSerialization.data(withJSONObject: broadcastTx)
+    guard let broadcastJson = String(data: broadcastData, encoding: .utf8) else {
+      throw Exception(name: "EncodingFailed", description: "TRX broadcast tx JSON encoding failed")
+    }
+    return broadcastJson
   }
 
   // MARK: - XRP
@@ -433,15 +450,15 @@ enum ChainSigner {
     payment.amount = try parseXrpAmountDrops(amountDrops)
     payment.destination = destination
     if let resolvedTag = try parseXrpDestinationTag(destinationTag) {
-      payment.destinationTag = resolvedTag
+      payment.destinationTag = Int64(resolvedTag)
     }
 
     var input = RippleSigningInput()
     input.privateKey = privateKey.data
     input.account = account
     input.fee = try parseXrpFeeDrops(feeDrops)
-    input.sequence = UInt32(sequence)
-    if let lls = lastLedgerSequence { input.lastLedgerSequence = UInt32(lls) }
+    input.sequence = Int32(sequence)
+    if let lls = lastLedgerSequence { input.lastLedgerSequence = Int32(lls) }
     input.opPayment = payment
 
     let output: RippleSigningOutput = AnySigner.sign(input: input, coin: .xrp)
@@ -469,14 +486,11 @@ enum ChainSigner {
 
     let privateKey = wallet.getKeyForCoin(coin: .ton)
 
-    // amount is Data (uint128 big-endian); encode the nanoton UInt64 as 8 big-endian bytes.
     let nanotons = try parseTonNanotons(amountStr)
-    var bigEndianNano = nanotons.bigEndian
-    let amountData = withUnsafeBytes(of: &bigEndianNano) { Data($0) }
 
     var transfer = TheOpenNetworkTransfer()
     transfer.dest = toAddress
-    transfer.amount = amountData
+    transfer.amount = nanotons
     transfer.mode = UInt32(TheOpenNetworkSendMode.payFeesSeparately.rawValue | TheOpenNetworkSendMode.ignoreActionPhaseErrors.rawValue)
     transfer.bounceable = true
     if let memoId { transfer.comment = memoId }
@@ -495,12 +509,179 @@ enum ChainSigner {
     return ChainSigner.Result(signedTx: output.encoded, meta: ["txHash": output.hash.hexString])
   }
 
+  // MARK: - Cosmos (ATOM)
+  // txParams: { accountNumber, sequence, chainId, feeAmount, gas, memo, fromAddress, toAddress,
+  //             amount (uatom, decimal string), denom }
+  // Returns output.serialized — the ready-to-broadcast JSON
+  // {"mode":"BROADCAST_MODE_SYNC","tx_bytes":"<base64>"} posted directly to the Cosmos LCD.
+  private static func signCosmos(wallet: HDWallet, txParams: [String: Any]) throws -> String {
+    guard let fromAddress = txParams["fromAddress"] as? String,
+          let toAddress = txParams["toAddress"] as? String,
+          let amountStr = txParams["amount"] as? String,
+          let feeAmountStr = txParams["feeAmount"] as? String,
+          let denom = txParams["denom"] as? String,
+          let chainId = txParams["chainId"] as? String,
+          let accountNumberNum = txParams["accountNumber"] as? NSNumber,
+          let sequenceNum = txParams["sequence"] as? NSNumber,
+          let gasNum = txParams["gas"] as? NSNumber else {
+      throw Exception(name: "InvalidParams", description: "Missing required Cosmos tx params")
+    }
+    let memo = (txParams["memo"] as? String) ?? ""
+
+    let privateKey = wallet.getKeyForCoin(coin: .cosmos)
+
+    var sendAmount = CosmosAmount()
+    sendAmount.denom = denom
+    sendAmount.amount = amountStr
+
+    var send = CosmosMessage.Send()
+    send.fromAddress = fromAddress
+    send.toAddress = toAddress
+    send.amounts = [sendAmount]
+
+    var message = CosmosMessage()
+    message.sendCoinsMessage = send
+
+    var feeAmt = CosmosAmount()
+    feeAmt.denom = denom
+    feeAmt.amount = feeAmountStr
+
+    var fee = CosmosFee()
+    fee.amounts = [feeAmt]
+    fee.gas = UInt64(gasNum.intValue)
+
+    var input = CosmosSigningInput()
+    input.signingMode = .protobuf
+    input.accountNumber = UInt64(accountNumberNum.intValue)
+    input.chainID = chainId
+    input.sequence = UInt64(sequenceNum.intValue)
+    input.memo = memo
+    input.fee = fee
+    input.messages = [message]
+    input.privateKey = privateKey.data
+    input.mode = .sync
+
+    let output: CosmosSigningOutput = AnySigner.sign(input: input, coin: .cosmos)
+    guard output.error == .ok else {
+      throw Exception(name: "SigningFailed", description: output.errorMessage)
+    }
+    return output.serialized
+  }
+
+  // MARK: - Aptos (APT)
+  // txParams: { sender, sequenceNumber, maxGasAmount, gasUnitPrice, expirationTimestampSecs,
+  //             chainId, toAddress, amount (octas, decimal string) }
+  // Returns output.json — the signed JSON body posted directly to the Aptos REST API.
+  private static func signAptos(wallet: HDWallet, txParams: [String: Any]) throws -> String {
+    guard let sender = txParams["sender"] as? String,
+          let toAddress = txParams["toAddress"] as? String,
+          let amountStr = txParams["amount"] as? String,
+          let seqNum = txParams["sequenceNumber"] as? NSNumber,
+          let maxGas = txParams["maxGasAmount"] as? NSNumber,
+          let gasPrice = txParams["gasUnitPrice"] as? NSNumber,
+          let expiry = txParams["expirationTimestampSecs"] as? NSNumber,
+          let chainId = txParams["chainId"] as? NSNumber else {
+      throw Exception(name: "InvalidParams", description: "Missing required Aptos tx params")
+    }
+    guard let amountOctas = UInt64(amountStr) else {
+      throw Exception(name: "InvalidParams", description: "Invalid Aptos amount: \(amountStr)")
+    }
+
+    let privateKey = wallet.getKeyForCoin(coin: .aptos)
+
+    var transfer = AptosTransferMessage()
+    transfer.to = toAddress
+    transfer.amount = amountOctas
+
+    var input = AptosSigningInput()
+    input.sender = sender
+    input.sequenceNumber = Int64(seqNum.intValue)
+    input.maxGasAmount = UInt64(maxGas.intValue)
+    input.gasUnitPrice = UInt64(gasPrice.intValue)
+    input.expirationTimestampSecs = UInt64(expiry.intValue)
+    input.chainID = UInt32(chainId.intValue)
+    input.privateKey = privateKey.data
+    input.transfer = transfer
+
+    let output: AptosSigningOutput = AnySigner.sign(input: input, coin: .aptos)
+    guard output.error == .ok else {
+      throw Exception(name: "SigningFailed", description: output.errorMessage)
+    }
+    return output.json
+  }
+
+  // MARK: - Tezos (XTZ)
+  // txParams: { branch, fromAddress, toAddress, counter, amount (mutez), fee (mutez),
+  //             gasLimit, storageLimit, needsReveal }
+  // Returns output.encoded hex — posted to /injection/operation as a JSON-encoded string.
+  private static func signTezos(wallet: HDWallet, txParams: [String: Any]) throws -> String {
+    guard let branch = txParams["branch"] as? String,
+          let fromAddress = txParams["fromAddress"] as? String,
+          let toAddress = txParams["toAddress"] as? String,
+          let counterNum = txParams["counter"] as? NSNumber,
+          let amountNum = txParams["amount"] as? NSNumber,
+          let feeNum = txParams["fee"] as? NSNumber,
+          let gasLimitNum = txParams["gasLimit"] as? NSNumber,
+          let storageLimitNum = txParams["storageLimit"] as? NSNumber else {
+      throw Exception(name: "InvalidParams", description: "Missing required Tezos tx params")
+    }
+    let needsReveal = (txParams["needsReveal"] as? Bool) ?? false
+    let counter = counterNum.int64Value
+
+    let privateKey = wallet.getKeyForCoin(coin: .tezos)
+    var operations: [TezosOperation] = []
+
+    if needsReveal {
+      let pubKey = privateKey.getPublicKeyEd25519()
+      var revealData = TezosRevealOperationData()
+      revealData.publicKey = pubKey.data
+
+      var reveal = TezosOperation()
+      reveal.source = fromAddress
+      reveal.counter = counter - 1
+      reveal.fee = 1420
+      reveal.gasLimit = 10600
+      reveal.storageLimit = 0
+      reveal.kind = .reveal
+      reveal.revealOperationData = revealData
+      operations.append(reveal)
+    }
+
+    var txData = TezosTransactionOperationData()
+    txData.destination = toAddress
+    txData.amount = amountNum.int64Value
+
+    var txOp = TezosOperation()
+    txOp.source = fromAddress
+    txOp.counter = counter
+    txOp.fee = feeNum.int64Value
+    txOp.gasLimit = gasLimitNum.int64Value
+    txOp.storageLimit = storageLimitNum.int64Value
+    txOp.kind = .transaction
+    txOp.transactionOperationData = txData
+    operations.append(txOp)
+
+    var opList = TezosOperationList()
+    opList.branch = branch
+    opList.operations = operations
+
+    var input = TezosSigningInput()
+    input.operationList = opList
+    input.privateKey = privateKey.data
+
+    let output: TezosSigningOutput = AnySigner.sign(input: input, coin: .tezos)
+    guard output.error == .ok else {
+      throw Exception(name: "SigningFailed", description: output.errorMessage)
+    }
+    return output.encoded.hexString
+  }
+
   // MARK: - Transaction summary for native confirmation UI
 
-  static func buildSummary(chain: ChainKey, unsignedTx: [String: Any]) -> String {
+  static func buildSummary(chain: ChainKey, unsignedTx: [String: Any]) throws -> String {
     var lines = ["Network: \(chain.rawValue.uppercased())"]
     switch chain {
-    case .ethereum, .bnb, .polygon:
+    case .ethereum, .bnb, .polygon, .avax, .base, .arbitrum, .optimism, .sonic:
       if let to = unsignedTx["to"] as? String { lines.append("To: \(fmtAddr(to))") }
       let val_ = txHexToDouble((unsignedTx["valueHex"] as? String) ?? "0")
       lines.append("Amount: \(fmtAmt(val_ / 1e18)) \(chain.symbol)")
@@ -510,12 +691,41 @@ enum ChainSigner {
       )
       let fee = gasLimit * gasPrice
       if fee > 0 { lines.append("Max fee: \(fmtAmt(fee / 1e18)) \(chain.symbol)") }
+      if let chainId = unsignedTx["chainId"] as? NSNumber { lines.append("Chain ID: \(chainId.intValue)") }
+      if let nonce = unsignedTx["nonce"] as? NSNumber { lines.append("Nonce: \(nonce.intValue)") }
+      let dataHex = (unsignedTx["dataHex"] as? String) ?? ""
+      let stripped = dataHex.hasPrefix("0x") ? String(dataHex.dropFirst(2)) : dataHex
+      if !stripped.isEmpty && stripped != "0" {
+        let sel = stripped.prefix(8).lowercased()
+        if sel == "a9059cbb", stripped.count >= 136 {
+          // transfer(address recipient, uint256 amount)
+          let recipient = "0x" + String(stripped.dropFirst(32).prefix(40))
+          let amountHex = String(stripped.dropFirst(72).prefix(64)).drop(while: { $0 == "0" })
+          lines.append("Token transfer to: \(fmtAddr(recipient))")
+          lines.append("Token amount (raw units): 0x\(amountHex.isEmpty ? "0" : String(amountHex))")
+        } else if sel == "23b872dd", stripped.count >= 200 {
+          // transferFrom(address from, address to, uint256 amount)
+          let to = "0x" + String(stripped.dropFirst(96).prefix(40))
+          let amountHex = String(stripped.dropFirst(136).prefix(64)).drop(while: { $0 == "0" })
+          lines.append("Token transfer to: \(fmtAddr(to))")
+          lines.append("Token amount (raw units): 0x\(amountHex.isEmpty ? "0" : String(amountHex))")
+        } else {
+          lines.append("Contract data: \(stripped.count / 2) bytes — review carefully")
+        }
+      }
 
     case .bitcoin, .dogecoin, .litecoin:
       if let to = unsignedTx["toAddress"] as? String { lines.append("To: \(fmtAddr(to))") }
-      if let sats = (unsignedTx["sendAmountSats"] as? String).flatMap(Int64.init) {
-        lines.append("Amount: \(fmtAmt(Double(sats) / 1e8)) \(chain.symbol)")
-      }
+      let sendSats = (unsignedTx["sendAmountSats"] as? String).flatMap(Int64.init) ?? 0
+      if sendSats > 0 { lines.append("Amount: \(fmtAmt(Double(sendSats) / 1e8)) \(chain.symbol)") }
+      if let change = unsignedTx["changeAddress"] as? String { lines.append("Change to: \(fmtAddr(change))") }
+      if let spb = unsignedTx["satsPerByte"] as? NSNumber { lines.append("Fee rate: \(spb.intValue) sat/vB") }
+      let inputTotal = (unsignedTx["inputs"] as? [[String: Any]])?
+        .compactMap { ($0["amountSats"] as? String).flatMap(Int64.init) }
+        .reduce(Int64(0), +) ?? 0
+      let changeSats = (unsignedTx["changeAmountSats"] as? String).flatMap(Int64.init) ?? 0
+      let totalFee = inputTotal - sendSats - changeSats
+      if totalFee > 0 { lines.append("Total fee: \(fmtAmt(Double(totalFee) / 1e8)) \(chain.symbol)") }
 
     case .xrp:
       if let dest = unsignedTx["Destination"] as? String { lines.append("To: \(fmtAddr(dest))") }
@@ -532,32 +742,208 @@ enum ChainSigner {
       if let nano = (unsignedTx["amount"] as? String).flatMap(UInt64.init) {
         lines.append("Amount: \(fmtAmt(Double(nano) / 1e9)) TON")
       }
+      let memoTon = unsignedTx["memoId"] as? String
+      if let memo = memoTon, !memo.isEmpty { lines.append("Memo: \(memo)") }
+      let feeEst = (memoTon?.isEmpty == false) ? "~0.006" : "~0.005"
+      lines.append("Fee: \(feeEst) TON (estimate)")
 
     case .tron:
       if let rawData = unsignedTx["raw_data"] as? [String: Any],
          let contracts = rawData["contract"] as? [[String: Any]],
-         let param = contracts.first?["parameter"] as? [String: Any],
-         let value = param["value"] as? [String: Any] {
-        if let to = value["to_address"] as? String { lines.append("To: \(fmtAddr(to))") }
-        if let amount = value["amount"] as? Int { lines.append("Amount: \(fmtAmt(Double(amount) / 1e6)) TRX") }
+         let first = contracts.first {
+        let type_ = first["type"] as? String ?? ""
+        if let param = first["parameter"] as? [String: Any],
+           let value = param["value"] as? [String: Any] {
+          switch type_ {
+          case "TransferContract":
+            if let to = value["to_address"] as? String { lines.append("To: \(fmtAddr(to))") }
+            if let amount = value["amount"] as? Int { lines.append("Amount: \(fmtAmt(Double(amount) / 1e6)) TRX") }
+          case "TriggerSmartContract":
+            if let contractAddr = value["contract_address"] as? String {
+              lines.append("Token contract: \(fmtAddr(contractAddr))")
+            }
+            let dataHex = (value["data"] as? String) ?? ""
+            let stripped = dataHex.hasPrefix("0x") ? String(dataHex.dropFirst(2)) : dataHex
+            let sel = stripped.prefix(8).lowercased()
+            if sel == "a9059cbb" && stripped.count >= 136 {
+              // TRC-20 transfer(address, uint256) — ABI encoding identical to EVM
+              let recipientHex = "0x" + String(stripped.dropFirst(32).prefix(40))
+              let amountHex = String(stripped.dropFirst(72).prefix(64)).drop(while: { $0 == "0" })
+              lines.append("TRC-20 to: \(fmtAddr(recipientHex))")
+              lines.append("Token amount (raw units): 0x\(amountHex.isEmpty ? "0" : String(amountHex))")
+            } else {
+              lines.append("Contract call: \(stripped.count / 2) bytes — review carefully")
+            }
+          default:
+            if !type_.isEmpty { lines.append("Contract type: \(type_) — review carefully") }
+          }
+        }
+      }
+      // Verify txID == SHA256(raw_data_hex). raw_data_hex must be present — fail closed if absent
+      // so a JS caller cannot suppress the integrity check by omitting the field.
+      guard let txID = unsignedTx["txID"] as? String else {
+        throw Exception(name: "TxIntegrityFailed", description: "TRX txID missing — signing refused")
       }
+      guard let rawHex = unsignedTx["raw_data_hex"] as? String,
+            let rawBytes = hexData(rawHex) else {
+        throw Exception(name: "TxIntegrityFailed",
+          description: "TRX raw_data_hex missing — cannot verify txID, signing refused")
+      }
+      let computed = Hash.sha256(data: rawBytes)
+      let computedHex = computed.map { String(format: "%02x", $0) }.joined()
+      guard computedHex.lowercased() == txID.lowercased() else {
+        throw Exception(name: "TxIntegrityFailed",
+          description: "TRX txID does not match SHA256(raw_data_hex) — signing refused")
+      }
+      lines.append("TxID verified ✓")
 
     case .solana:
-      lines.append("(Solana — details verified by the network)")
+      // Decode the pre-built tx to extract recipient and lamports (SOL) or destination and
+      // amount (SPL token). Falls closed — throws if the tx cannot be decoded at all.
+      guard let info = decodeSolanaForSummary(unsignedTx) else {
+        throw Exception(name: "UndecodableTx",
+          description: "Cannot decode Solana transaction — signing refused to prevent blind signing")
+      }
+      if info.isSplTransfer {
+        if let dest = info.splDest { lines.append("SPL Token to: \(fmtAddr(dest))") }
+        if let amt = info.splAmount { lines.append("SPL Token amount (raw): \(amt)") }
+      } else {
+        if let to = info.to { lines.append("To: \(fmtAddr(to))") }
+        if let lamports = info.lamports { lines.append("Amount: \(fmtAmt(Double(lamports) / 1e9)) SOL") }
+        if !info.isTransfer { lines.append("Non-transfer instruction — review carefully") }
+      }
 
     case .bitcoincash:
-      if let descriptorJson = unsignedTx["unsignedDescriptorJson"] as? String,
-         let data = descriptorJson.data(using: .utf8),
-         let descriptor = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
-        if let to = descriptor["toAddress"] as? String { lines.append("To: \(fmtAddr(to))") }
-        if let sats = (descriptor["sendAmountSats"] as? NSNumber)?.int64Value {
-          lines.append("Amount: \(fmtAmt(Double(sats) / 1e8)) BCH")
-        }
+      // Fail closed — if descriptor is absent or unparseable we cannot show what will be signed.
+      guard let descriptorJson = unsignedTx["unsignedDescriptorJson"] as? String,
+            let data = descriptorJson.data(using: .utf8),
+            let descriptor = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+        throw Exception(name: "UndecodableTx",
+          description: "Cannot decode BCH descriptor — signing refused to prevent blind signing")
+      }
+      if let to = descriptor["toAddress"] as? String { lines.append("To: \(fmtAddr(to))") }
+      if let sats = (descriptor["sendAmountSats"] as? NSNumber)?.int64Value {
+        lines.append("Amount: \(fmtAmt(Double(sats) / 1e8)) BCH")
+      }
+      if let change = descriptor["changeAddress"] as? String { lines.append("Change to: \(fmtAddr(change))") }
+      if let spb = (descriptor["satsPerByte"] as? NSNumber)?.intValue { lines.append("Fee rate: \(spb) sat/vB") }
+      let bchInputs = (descriptor["inputs"] as? [[String: Any]])?
+        .compactMap { ($0["amountSats"] as? NSNumber)?.int64Value }
+        .reduce(Int64(0), +) ?? 0
+      let bchSend = (descriptor["sendAmountSats"] as? NSNumber)?.int64Value ?? 0
+      let bchChange = (descriptor["changeAmountSats"] as? NSNumber)?.int64Value ?? 0
+      let bchFee = bchInputs - bchSend - bchChange
+      if bchFee > 0 { lines.append("Total fee: \(fmtAmt(Double(bchFee) / 1e8)) BCH") }
+
+    case .cosmos:
+      if let to = unsignedTx["toAddress"] as? String { lines.append("To: \(fmtAddr(to))") }
+      if let uatom = (unsignedTx["amount"] as? String).flatMap(Int64.init) {
+        lines.append("Amount: \(fmtAmt(Double(uatom) / 1_000_000)) ATOM")
+      }
+      if let feeUatom = (unsignedTx["feeAmount"] as? String).flatMap(Int64.init) {
+        lines.append("Fee: \(fmtAmt(Double(feeUatom) / 1_000_000)) ATOM")
+      }
+
+    case .aptos:
+      if let to = unsignedTx["toAddress"] as? String { lines.append("To: \(fmtAddr(to))") }
+      if let octas = (unsignedTx["amount"] as? String).flatMap(UInt64.init) {
+        lines.append("Amount: \(fmtAmt(Double(octas) / 1e8)) APT")
+      }
+      if let maxGas = (unsignedTx["maxGasAmount"] as? NSNumber)?.uint64Value,
+         let gasPrice = (unsignedTx["gasUnitPrice"] as? NSNumber)?.uint64Value {
+        let feeOctas = maxGas * gasPrice
+        lines.append("Max fee: \(fmtAmt(Double(feeOctas) / 1e8)) APT")
+      }
+
+    case .tezos:
+      if let to = unsignedTx["toAddress"] as? String { lines.append("To: \(fmtAddr(to))") }
+      if let mutez = (unsignedTx["amount"] as? NSNumber)?.int64Value {
+        lines.append("Amount: \(fmtAmt(Double(mutez) / 1_000_000)) XTZ")
+      }
+      if let feeMutez = (unsignedTx["fee"] as? NSNumber)?.int64Value {
+        lines.append("Fee: \(fmtAmt(Double(feeMutez) / 1_000_000)) XTZ")
+      }
+      if let reveal = unsignedTx["needsReveal"] as? Bool, reveal {
+        lines.append("(includes reveal operation)")
       }
     }
     return lines.joined(separator: "\n")
   }
 
+  private struct SolanaSummaryInfo {
+    let to: String?
+    let lamports: UInt64?
+    let isTransfer: Bool
+    let splDest: String?
+    let splAmount: UInt64?
+    let isSplTransfer: Bool
+  }
+
+  private static func decodeSolanaForSummary(_ txParams: [String: Any]) -> SolanaSummaryInfo? {
+    guard let b64 = txParams["unsignedTxBase64"] as? String,
+          let txData = Data(base64Encoded: b64) else { return nil }
+    let rawBytes = TransactionDecoder.decode(coinType: .solana, encodedTx: txData)
+    guard let decoded = try? SolanaDecodingTransactionOutput(serializedBytes: rawBytes),
+          decoded.error == .ok else { return nil }
+    let accounts = decoded.transaction.legacy.accountKeys
+    let instrs = decoded.transaction.legacy.instructions
+
+    let systemProgram = "11111111111111111111111111111111"
+    // SPL Token Program and Token-2022
+    let splPrograms: Set<String> = [
+      "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
+      "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
+    ]
+
+    // Find first SystemProgram instruction (skip ComputeBudget etc.)
+    // and first SPL Token instruction in a single pass.
+    var systemIx: TW_Solana_Proto_RawMessage.Instruction? = nil
+    var splIx: TW_Solana_Proto_RawMessage.Instruction? = nil
+    for instr in instrs {
+      let prog = safeGet(accounts, Int(instr.programID)) ?? ""
+      if systemIx == nil && prog == systemProgram { systemIx = instr }
+      if splIx == nil && splPrograms.contains(prog) { splIx = instr }
+    }
+
+    if let ix = systemIx {
+      let to: String? = ix.accounts.count >= 2 ? safeGet(accounts, Int(ix.accounts[1])) : nil
+      // SystemProgram Transfer discriminator: [2, 0, 0, 0] as u32-LE
+      let isTransfer = ix.programData.count >= 12 && ix.programData.prefix(4) == Data([2, 0, 0, 0])
+      var lamports: UInt64?
+      if isTransfer {
+        var v: UInt64 = 0
+        for (i, b) in ix.programData.dropFirst(4).prefix(8).enumerated() { v |= UInt64(b) << (i * 8) }
+        lamports = v
+      }
+      return SolanaSummaryInfo(to: to, lamports: lamports, isTransfer: isTransfer,
+                               splDest: nil, splAmount: nil, isSplTransfer: false)
+    }
+
+    if let ix = splIx {
+      let data = ix.programData
+      // SPL instruction byte 0: 3 = Transfer, 12 = TransferChecked
+      // Transfer: accounts[0]=src, accounts[1]=dest, accounts[2]=owner; data[1..8]=amount LE u64
+      // TransferChecked: accounts[0]=src, accounts[1]=mint, accounts[2]=dest, accounts[3]=owner
+      if !data.isEmpty && data[0] == 3 && data.count >= 9 {
+        let dest = ix.accounts.count >= 2 ? safeGet(accounts, Int(ix.accounts[1])) : nil
+        var amount: UInt64 = 0
+        for (i, b) in data.dropFirst(1).prefix(8).enumerated() { amount |= UInt64(b) << (i * 8) }
+        return SolanaSummaryInfo(to: nil, lamports: nil, isTransfer: false,
+                                 splDest: dest, splAmount: amount, isSplTransfer: true)
+      } else if !data.isEmpty && data[0] == 12 && data.count >= 10 {
+        let dest = ix.accounts.count >= 3 ? safeGet(accounts, Int(ix.accounts[2])) : nil
+        var amount: UInt64 = 0
+        for (i, b) in data.dropFirst(1).prefix(8).enumerated() { amount |= UInt64(b) << (i * 8) }
+        return SolanaSummaryInfo(to: nil, lamports: nil, isTransfer: false,
+                                 splDest: dest, splAmount: amount, isSplTransfer: true)
+      }
+      return SolanaSummaryInfo(to: nil, lamports: nil, isTransfer: false,
+                               splDest: nil, splAmount: nil, isSplTransfer: false)
+    }
+
+    return nil
+  }
+
   private static func txHexToDouble(_ hex: String) -> Double {
     let s = hex.hasPrefix("0x") ? String(hex.dropFirst(2)) : hex
     if let v = UInt64(s, radix: 16) { return Double(v) }
@@ -575,6 +961,10 @@ enum ChainSigner {
 
   // MARK: - Helpers
 
+  private static func safeGet<T>(_ array: [T], _ index: Int) -> T? {
+    array.indices.contains(index) ? array[index] : nil
+  }
+
   // Parses a hex string (with or without 0x, odd or even length) into Data. An empty string
   // deliberately maps to a single zero byte (fields like valueHex already default to "0"
   // when absent — that's a legitimate zero-value transfer, not malformed input). Any