@authon/react-native-wallet 0.0.0-stage → 0.4.0

package/ios/vendor/AuthonWallet/Chains/Solana.swift

@@ -0,0 +1,207 @@
+// GENERATED by scripts/sync-native-wallet.mjs from swift/Sources/AuthonWallet/Chains/Solana.swift. Do not edit: change the source and run the script.
+#if canImport(CMonocypher)
+import CMonocypher
+#endif
+import Foundation
+
+/// Solana transaction signing (docs/wallet/NATIVE.md section 12, `apps/wallet/src/solana.ts`).
+/// The app builds the serialized Message; the wallet parses it only to describe it and signs
+/// the exact bytes.
+enum Solana {
+    static let maxMessage = 1232
+
+    static let system = "11111111111111111111111111111111"
+    static let token = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+    static let token2022 = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
+    static let associatedToken = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+    static let computeBudget = "ComputeBudget111111111111111111111111111111"
+    static let memo = "MemoSq4gqABAXKb96qnH8TyNoJ6CDrADxwaj4uuQ"
+
+    struct Instruction {
+        var programId: String
+        /// nil for an account that comes from an address lookup table.
+        var accounts: [String?]
+        var data: [UInt8]
+    }
+
+    struct Message {
+        var isV0: Bool
+        var numRequiredSignatures: Int
+        var accountKeys: [String]
+        var recentBlockhash: String
+        var instructions: [Instruction]
+        /// Accounts loaded from address lookup tables (v0 only).
+        var lookupAccounts: Int
+    }
+
+    private static func invalid() -> WalletError { WalletError(.invalidRequest, "not a valid Solana message") }
+
+    private struct Reader {
+        let bytes: [UInt8]
+        var pos = 0
+        var done: Bool { pos == bytes.count }
+
+        mutating func u8() throws -> Int {
+            guard pos < bytes.count else { throw invalid() }
+            pos += 1
+            return Int(bytes[pos - 1])
+        }
+
+        mutating func take(_ n: Int) throws -> [UInt8] {
+            guard n >= 0, pos + n <= bytes.count else { throw invalid() }
+            pos += n
+            return Array(bytes[(pos - n)..<pos])
+        }
+
+        /// compact-u16 (shortvec)
+        mutating func len() throws -> Int {
+            var value = 0
+            for i in 0..<3 {
+                let b = try u8()
+                value |= (b & 0x7f) << (7 * i)
+                if b & 0x80 == 0 { return value }
+            }
+            throw invalid()
+        }
+    }
+
+    static func parse(_ bytes: [UInt8]) throws -> Message {
+        guard !bytes.isEmpty, bytes.count <= maxMessage else { throw invalid() }
+        var r = Reader(bytes: bytes)
+        var isV0 = false
+        var first = try r.u8()
+        if first & 0x80 != 0 {
+            guard first & 0x7f == 0 else { throw WalletError(.invalidRequest, "unsupported Solana message version") }
+            isV0 = true
+            first = try r.u8()
+        }
+        let required = first
+        _ = try r.u8() // readonly signed
+        _ = try r.u8() // readonly unsigned
+        let keyCount = try r.len()
+        var keys = [String]()
+        for _ in 0..<keyCount { keys.append(Base58.encode(try r.take(32), alphabet: Base58.bitcoin)) }
+        let blockhash = Base58.encode(try r.take(32), alphabet: Base58.bitcoin)
+        var raw = [(program: Int, accounts: [Int], data: [UInt8])]()
+        for _ in 0..<(try r.len()) {
+            let program = try r.u8()
+            var accounts = [Int]()
+            for _ in 0..<(try r.len()) { accounts.append(try r.u8()) }
+            let data = try r.take(try r.len())
+            raw.append((program, accounts, data))
+        }
+        var lookups = 0
+        if isV0 {
+            for _ in 0..<(try r.len()) {
+                _ = try r.take(32)
+                lookups += try r.take(try r.len()).count
+                lookups += try r.take(try r.len()).count
+            }
+        }
+        guard r.done, required >= 1, required <= keyCount else { throw invalid() }
+        let total = keyCount + lookups
+        func key(_ i: Int) throws -> String? {
+            guard i < total else { throw invalid() }
+            return i < keyCount ? keys[i] : nil
+        }
+        let instructions = try raw.map { ix -> Instruction in
+            // Programs must be static keys.
+            guard let program = try key(ix.program) else { throw invalid() }
+            return Instruction(programId: program, accounts: try ix.accounts.map(key), data: ix.data)
+        }
+        return Message(isV0: isV0, numRequiredSignatures: required, accountKeys: keys, recentBlockhash: blockhash, instructions: instructions, lookupAccounts: lookups)
+    }
+
+    private static func u64(_ d: [UInt8], _ at: Int) throws -> UInt64 {
+        guard d.count >= at + 8 else { throw invalid() }
+        return (0..<8).reduce(UInt64(0)) { $0 | UInt64(d[at + $1]) << (8 * UInt64($1)) }
+    }
+
+    private static func u32(_ d: [UInt8], _ at: Int) throws -> UInt32 {
+        guard d.count >= at + 4 else { throw invalid() }
+        return (0..<4).reduce(UInt32(0)) { $0 | UInt32(d[at + $1]) << (8 * UInt32($1)) }
+    }
+
+    /// Integer amount with `decimals` places, trailing zeros removed.
+    static func units(_ amount: UInt64, _ decimals: Int) -> String {
+        if decimals == 0 { return String(amount) }
+        var digits = String(amount)
+        if digits.count <= decimals { digits = String(repeating: "0", count: decimals - digits.count + 1) + digits }
+        let whole = String(digits.dropLast(decimals))
+        var frac = String(digits.suffix(decimals))
+        while frac.hasSuffix("0") { frac.removeLast() }
+        return whole + (frac.isEmpty ? "" : "." + frac)
+    }
+
+    private static func addr(_ a: String??) -> String { (a ?? nil) ?? "(address from a lookup table)" }
+
+    /// The approval summary. The signer must pay the fee (account 0).
+    static func summarize(_ msg: Message, signer: String, network: String) throws -> SignSummary {
+        guard msg.accountKeys.first == signer else {
+            throw WalletError(.addressMismatch, "the fee payer is not the signing account")
+        }
+        var rows: [SignSummary.Row] = [.init(label: "Network", value: network), .init(label: "Account", value: signer, mono: true)]
+        var warnings = [String]()
+        if msg.numRequiredSignatures > 1 {
+            warnings.append("This transaction needs \(msg.numRequiredSignatures) signatures; you sign as the fee payer.")
+        }
+        if msg.lookupAccounts > 0 { warnings.append("Some accounts come from address lookup tables and cannot be shown.") }
+        for ix in msg.instructions {
+            let d = ix.data
+            func account(_ i: Int) -> String?? { i < ix.accounts.count ? ix.accounts[i] : .some(nil) }
+            let isToken = ix.programId == token || ix.programId == token2022
+            if ix.programId == system, d.count >= 12, try u32(d, 0) == 2 {
+                rows += [.init(label: "Send", value: units(try u64(d, 4), 9) + " SOL"), .init(label: "To", value: addr(account(1)), mono: true)]
+                if (ix.accounts.first ?? nil) != signer { warnings.append("SOL is sent from an account other than yours.") }
+            } else if isToken, d.first == 12, d.count >= 10 {
+                rows += [
+                    .init(label: "Send token", value: units(try u64(d, 1), Int(d[9]))),
+                    .init(label: "Token", value: addr(account(1)), mono: true),
+                    .init(label: "To token account", value: addr(account(2)), mono: true),
+                ]
+            } else if isToken, d.first == 3, d.count >= 9 {
+                rows += [
+                    .init(label: "Send token (raw units)", value: String(try u64(d, 1))),
+                    .init(label: "To token account", value: addr(account(1)), mono: true),
+                ]
+                warnings.append("Token amount is shown in raw units (no decimals in this instruction).")
+            } else if ix.programId == associatedToken, d.isEmpty || d[0] == 0 || d[0] == 1 {
+                rows.append(.init(label: "Create token account", value: addr(account(1)), mono: true))
+            } else if ix.programId == computeBudget, d.first == 2, d.count >= 5 {
+                rows.append(.init(label: "Compute limit", value: String(try u32(d, 1))))
+            } else if ix.programId == computeBudget, d.first == 3, d.count >= 9 {
+                rows.append(.init(label: "Priority fee", value: "\(try u64(d, 1)) micro-lamports per unit"))
+            } else if ix.programId == memo {
+                rows.append(.init(label: "Memo", value: String(decoding: d, as: UTF8.self)))
+            } else {
+                rows.append(.init(label: "Program call", value: ix.programId, mono: true))
+                warnings.append("Calls a program this wallet cannot describe (\(ix.programId)). Approve only if you trust the app.")
+            }
+        }
+        rows.append(.init(label: "Recent blockhash", value: msg.recentBlockhash, mono: true))
+        return SignSummary(kind: .transaction, title: "Solana transaction", rows: rows, body: nil, warnings: warnings, risk: .high)
+    }
+
+    /// The SLIP-0010 key of Solana account `index`. Callers wipe it.
+    static func privateKey(_ secret: [UInt8], index: Int) throws -> [UInt8] {
+        guard WalletShares.isAccountIndex(index) else { throw WalletError(.invalidRequest, "invalid account index") }
+        guard WalletShares.isHdSecret(secret) else { throw WalletError(.accountUnavailable, "this wallet has only EVM account 0") }
+        var seed = try BIP39.seed(mnemonic: try BIP39.mnemonic(entropy: secret))
+        defer { seed.wipe() }
+        return try ChainAddresses.ed25519Key(seed: seed, path: WalletChain.solana.path(index))
+    }
+
+    /// Deterministic RFC 8032 Ed25519 (Monocypher) over the exact message bytes.
+    /// Returns (address, base58 signature).
+    static func sign(_ message: [UInt8], privateKey: [UInt8]) -> (address: String, signature: String) {
+        var seed = privateKey // crypto_ed25519_key_pair wipes its seed argument
+        var secretKey = [UInt8](repeating: 0, count: 64)
+        var publicKey = [UInt8](repeating: 0, count: 32)
+        var signature = [UInt8](repeating: 0, count: 64)
+        crypto_ed25519_key_pair(&secretKey, &publicKey, &seed)
+        message.withUnsafeBufferPointer { m in crypto_ed25519_sign(&signature, secretKey, m.baseAddress, m.count) }
+        secretKey.wipe()
+        seed.wipe()
+        return (Base58.encode(publicKey, alphabet: Base58.bitcoin), Base58.encode(signature, alphabet: Base58.bitcoin))
+    }
+}

package/ios/vendor/AuthonWallet/Chains/Tron.swift

@@ -0,0 +1,181 @@
+// GENERATED by scripts/sync-native-wallet.mjs from swift/Sources/AuthonWallet/Chains/Tron.swift. Do not edit: change the source and run the script.
+import Foundation
+
+/// TRON transaction signing (docs/wallet/NATIVE.md section 12, `apps/wallet/src/tron.ts`). The app
+/// builds raw_data; the wallet decodes it only to describe it and signs SHA-256(raw_data) like
+/// TronWeb (r || s || v with v = recovery + 27).
+enum Tron {
+    static let maxRawData = 4096
+
+    struct Contract {
+        var type: UInt64
+        /// Decoded fields of TransferContract (1) / TriggerSmartContract (31).
+        var owner: String?
+        var to: String?
+        var amount: UInt64?
+        var contractAddress: String?
+        var callValue: UInt64?
+        var data: [UInt8]?
+    }
+
+    struct RawData {
+        var expiration: UInt64?
+        var timestamp: UInt64?
+        var feeLimit: UInt64?
+        var memo: [UInt8]?
+        var contracts: [Contract]
+    }
+
+    private static func invalid() -> WalletError { WalletError(.invalidRequest, "not a valid TRON raw_data") }
+
+    struct Field {
+        var no: UInt64
+        var varint: UInt64?
+        var bytes: [UInt8]?
+    }
+
+    /// Minimal protobuf reader: varint (0), 64-bit (1), length-delimited (2), 32-bit (5).
+    static func fields(_ buf: [UInt8]) throws -> [Field] {
+        var out = [Field]()
+        var pos = 0
+        func varint() throws -> UInt64 {
+            var v: UInt64 = 0
+            var shift: UInt64 = 0
+            while shift < 64 {
+                guard pos < buf.count else { throw invalid() }
+                let b = buf[pos]
+                pos += 1
+                if shift == 63 && b > 1 { throw invalid() }
+                v |= UInt64(b & 0x7f) << shift
+                if b & 0x80 == 0 { return v }
+                shift += 7
+            }
+            throw invalid()
+        }
+        while pos < buf.count {
+            let key = try varint()
+            let no = key >> 3
+            let wire = key & 7
+            guard no != 0 else { throw invalid() }
+            switch wire {
+            case 0:
+                out.append(Field(no: no, varint: try varint()))
+            case 2:
+                let len = try varint()
+                guard len <= UInt64(buf.count - pos) else { throw invalid() }
+                out.append(Field(no: no, bytes: Array(buf[pos..<(pos + Int(len))])))
+                pos += Int(len)
+            case 1, 5:
+                let len = wire == 1 ? 8 : 4
+                guard pos + len <= buf.count else { throw invalid() }
+                pos += len
+                out.append(Field(no: no))
+            default:
+                throw invalid()
+            }
+        }
+        return out
+    }
+
+    private static func one(_ fs: [Field], _ no: UInt64) -> Field? { fs.first { $0.no == no } }
+
+    static func address(_ raw: [UInt8]) throws -> String {
+        guard raw.count == 21, raw[0] == 0x41 else { throw invalid() }
+        return Base58.encode(raw + ChainAddresses.checksum4(raw), alphabet: Base58.bitcoin)
+    }
+
+    static func parse(_ raw: [UInt8]) throws -> RawData {
+        guard !raw.isEmpty, raw.count <= maxRawData else { throw invalid() }
+        let top = try fields(raw)
+        let contracts = try top.filter { $0.no == 11 && $0.bytes != nil }.map { f -> Contract in
+            let c = try fields(f.bytes!)
+            let type = one(c, 1)?.varint ?? 0
+            var contract = Contract(type: type)
+            let any = one(c, 2)?.bytes
+            let value = try any.flatMap { one(try fields($0), 2)?.bytes }
+            if let value, type == 1 || type == 31 {
+                let v = try fields(value)
+                func addr(_ no: UInt64) throws -> String? { try one(v, no)?.bytes.map(address) }
+                contract.owner = try addr(1)
+                if type == 1 {
+                    contract.to = try addr(2)
+                    contract.amount = one(v, 3)?.varint ?? 0
+                } else {
+                    contract.contractAddress = try addr(2)
+                    contract.callValue = one(v, 3)?.varint ?? 0
+                    contract.data = one(v, 4)?.bytes ?? []
+                }
+            }
+            return contract
+        }
+        guard !contracts.isEmpty else { throw invalid() }
+        return RawData(
+            expiration: one(top, 8)?.varint,
+            timestamp: one(top, 14)?.varint,
+            feeLimit: one(top, 18)?.varint,
+            memo: one(top, 10)?.bytes,
+            contracts: contracts
+        )
+    }
+
+    static func trx(_ sun: UInt64) -> String { Solana.units(sun, 6) + " TRX" }
+
+    private static func word(_ data: [UInt8], _ i: Int) -> [UInt8] { Array(data[(4 + 32 * i)..<(4 + 32 * (i + 1))]) }
+
+    /// `new Date(ms).toISOString()`
+    static func isoDate(_ ms: UInt64) throws -> String {
+        guard ms <= 8_640_000_000_000_000 else { throw invalid() }
+        let f = ISO8601DateFormatter()
+        f.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        f.timeZone = TimeZone(identifier: "UTC")
+        return f.string(from: Date(timeIntervalSince1970: Double(ms) / 1000))
+    }
+
+    static func summarize(_ tx: RawData, signer: String) throws -> SignSummary {
+        var rows: [SignSummary.Row] = [.init(label: "Network", value: "TRON"), .init(label: "Account", value: signer, mono: true)]
+        var warnings = [String]()
+        if tx.contracts.count != 1 { warnings.append("This transaction has \(tx.contracts.count) contracts.") }
+        for c in tx.contracts {
+            if let owner = c.owner, owner != signer {
+                throw WalletError(.addressMismatch, "the transaction owner is not the signing account")
+            }
+            if c.type == 1, let to = c.to, !to.isEmpty {
+                rows += [.init(label: "Send", value: trx(c.amount ?? 0)), .init(label: "To", value: to, mono: true)]
+            } else if c.type == 31, let data = c.data {
+                rows.append(.init(label: "Contract", value: c.contractAddress ?? "?", mono: true))
+                if let v = c.callValue, v > 0 { rows.append(.init(label: "Send", value: trx(v))) }
+                let selector = Bytes.hex(Array(data.prefix(4)))
+                if selector == "a9059cbb" && data.count == 68 {
+                    rows += [
+                        .init(label: "Token transfer to", value: try address([0x41] + word(data, 0)[12...]), mono: true),
+                        .init(label: "Token amount (raw units)", value: BigUInt(bytes: word(data, 1)).description),
+                    ]
+                } else if selector == "095ea7b3" && data.count == 68 {
+                    let amount = BigUInt(bytes: word(data, 1))
+                    rows += [
+                        .init(label: "Allow spender", value: try address([0x41] + word(data, 0)[12...]), mono: true),
+                        .init(label: "Allowance (raw units)", value: amount == BigUInt.power2(256) - BigUInt(1) ? "Unlimited" : amount.description),
+                    ]
+                    warnings.append("This lets another address spend your tokens.")
+                } else {
+                    rows.append(.init(label: "Call data", value: Bytes.hex(data, prefix: true), mono: true))
+                    warnings.append("Calls a contract function this wallet cannot describe. Approve only if you trust the app.")
+                }
+            } else {
+                rows.append(.init(label: "Contract type", value: String(c.type)))
+                warnings.append("TRON contract type \(c.type) cannot be described. Approve only if you trust the app.")
+            }
+        }
+        if let fee = tx.feeLimit { rows.append(.init(label: "Fee limit", value: trx(fee))) }
+        if let memo = tx.memo, !memo.isEmpty { rows.append(.init(label: "Memo", value: String(decoding: memo, as: UTF8.self))) }
+        if let exp = tx.expiration { rows.append(.init(label: "Expires", value: try isoDate(exp))) }
+        return SignSummary(kind: .transaction, title: "TRON transaction", rows: rows, body: nil, warnings: warnings, risk: .high)
+    }
+
+    /// txID = SHA-256(raw_data); signature r || s || (recovery + 27) in lowercase hex.
+    static func sign(_ raw: [UInt8], privateKey: [UInt8]) throws -> [String: String] {
+        let txID = Bytes.sha256(raw)
+        let sig = try Secp256k1.sign(hash: txID, key: privateKey)
+        return ["txID": Bytes.hex(txID), "signature": Bytes.hex(sig.r + sig.s + [UInt8(27 + sig.recoveryId)])]
+    }
+}

package/ios/vendor/AuthonWallet/Chains/XRP.swift

@@ -0,0 +1,191 @@
+// GENERATED by scripts/sync-native-wallet.mjs from swift/Sources/AuthonWallet/Chains/XRP.swift. Do not edit: change the source and run the script.
+import CryptoKit
+import Foundation
+
+/// XRP Ledger signing (docs/wallet/NATIVE.md section 12, `apps/wallet/src/xrp.ts`). The app sends
+/// the output of ripple-binary-codec encodeForSigning (prefix STX\0); the wallet decodes it only
+/// to describe it and signs SHA-512Half(blob) with secp256k1, DER, low S.
+enum XRP {
+    static let maxBlob = 4096
+    static let signingPrefix: [UInt8] = [0x53, 0x54, 0x58, 0x00]
+
+    struct Tx {
+        var transactionType: Int?
+        var account: String?
+        var destination: String?
+        /// Drops for XRP amounts; `.some(nil)` for issued-token amounts.
+        var amount: UInt64??
+        var fee: UInt64??
+        var sequence: Int?
+        var destinationTag: Int?
+        var lastLedgerSequence: Int?
+        var signingPubKey: [UInt8]?
+        var memos: [String] = []
+    }
+
+    private static func invalid(_ why: String = "not a valid XRP signing blob") -> WalletError { WalletError(.invalidRequest, why) }
+
+    static func address(accountId: [UInt8]) throws -> String {
+        guard accountId.count == 20 else { throw invalid() }
+        let payload = [0x00] + accountId
+        return Base58.encode(payload + ChainAddresses.checksum4(payload), alphabet: Base58.xrp)
+    }
+
+    static func address(publicKey compressed: [UInt8]) throws -> String {
+        try address(accountId: ChainAddresses.hash160(compressed))
+    }
+
+    private struct Reader {
+        let b: [UInt8]
+        var pos = 0
+        var done: Bool { pos >= b.count }
+
+        mutating func u8() throws -> Int {
+            guard pos < b.count else { throw invalid() }
+            pos += 1
+            return Int(b[pos - 1])
+        }
+
+        mutating func take(_ n: Int) throws -> [UInt8] {
+            guard pos + n <= b.count else { throw invalid() }
+            pos += n
+            return Array(b[(pos - n)..<pos])
+        }
+
+        mutating func uint(_ n: Int) throws -> Int { try take(n).reduce(0) { $0 * 256 + Int($1) } }
+
+        /// XRPL variable-length prefix.
+        mutating func vl() throws -> [UInt8] {
+            let b1 = try u8()
+            if b1 <= 192 { return try take(b1) }
+            if b1 <= 240 { return try take(193 + (b1 - 193) * 256 + (try u8())) }
+            if b1 <= 254 { return try take(12481 + (b1 - 241) * 65536 + (try u8()) * 256 + (try u8())) }
+            throw invalid()
+        }
+
+        mutating func field() throws -> (type: Int, code: Int) {
+            let h = try u8()
+            var type = h >> 4
+            var code = h & 0x0f
+            if type == 0 { type = try u8() }
+            if code == 0 { code = try u8() }
+            return (type, code)
+        }
+
+        mutating func amount() throws -> UInt64? {
+            guard pos < b.count else { throw invalid() }
+            if b[pos] & 0x80 != 0 {
+                _ = try take(48) // issued token: 8 value + 20 currency + 20 issuer
+                return nil
+            }
+            let v = try take(8).reduce(UInt64(0)) { $0 << 8 | UInt64($1) }
+            return v & 0x3fff_ffff_ffff_ffff
+        }
+    }
+
+    /// Reads one STObject until its end marker (or the end of the blob at the top level).
+    /// `memos` collects MemoData inside the top-level Memos array.
+    private static func readObject(_ r: inout Reader, _ tx: inout Tx?, depth: Int, memos: inout [String]?) throws {
+        guard depth <= 4 else { throw invalid() }
+        while !r.done {
+            let (type, code) = try r.field()
+            if type == 14 && code == 1 { return } // ObjectEndMarker
+            if type == 15 && code == 1 { return } // ArrayEndMarker
+            switch type {
+            case 1:
+                let v = try r.uint(2)
+                if code == 2 { tx?.transactionType = v }
+            case 2:
+                let v = try r.uint(4)
+                if code == 4 { tx?.sequence = v } else if code == 14 { tx?.destinationTag = v } else if code == 27 { tx?.lastLedgerSequence = v }
+            case 3: _ = try r.take(8)
+            case 4: _ = try r.take(16)
+            case 5: _ = try r.take(32)
+            case 16: _ = try r.take(1)
+            case 17: _ = try r.take(20)
+            case 6:
+                let v = try r.amount()
+                if code == 1 { tx?.amount = .some(v) } else if code == 8 { tx?.fee = .some(v) }
+            case 7:
+                let v = try r.vl()
+                if tx != nil, code == 3 {
+                    tx?.signingPubKey = v
+                } else if tx == nil, code == 13 {
+                    memos?.append(String(decoding: v, as: UTF8.self))
+                }
+            case 8:
+                let v = try r.vl()
+                if tx != nil, code == 1 { tx?.account = try address(accountId: v) } else if tx != nil, code == 3 { tx?.destination = try address(accountId: v) }
+            case 14:
+                var none: Tx? = nil
+                try readObject(&r, &none, depth: depth + 1, memos: &memos)
+            case 15:
+                var none: Tx? = nil
+                if tx != nil && code == 9 {
+                    var collected: [String]? = []
+                    try readObject(&r, &none, depth: depth + 1, memos: &collected)
+                    tx?.memos += collected ?? []
+                } else {
+                    try readObject(&r, &none, depth: depth + 1, memos: &memos)
+                }
+            default:
+                throw invalid("XRP field type \(type) is not supported")
+            }
+        }
+    }
+
+    static func parse(_ blob: [UInt8]) throws -> Tx {
+        guard blob.count >= 5, blob.count <= maxBlob, Array(blob.prefix(4)) == signingPrefix else { throw invalid() }
+        var r = Reader(b: Array(blob.dropFirst(4)))
+        var tx: Tx? = Tx()
+        var memos: [String]? = nil
+        try readObject(&r, &tx, depth: 0, memos: &memos)
+        guard let parsed = tx, parsed.transactionType != nil, parsed.account != nil, parsed.signingPubKey != nil else { throw invalid() }
+        return parsed
+    }
+
+    static func xrp(_ drops: UInt64) -> String { Solana.units(drops, 6) + " XRP" }
+
+    private static let types: [Int: String] = [0: "Payment", 3: "AccountSet", 7: "OfferCreate", 8: "OfferCancel", 12: "SetRegularKey", 20: "TrustSet"]
+
+    static func summarize(_ tx: Tx, signer: String, signerPublicKey: [UInt8]) throws -> SignSummary {
+        guard tx.account == signer else { throw WalletError(.addressMismatch, "the transaction account is not the signing account") }
+        guard tx.signingPubKey == signerPublicKey else {
+            throw WalletError(.invalidRequest, "SigningPubKey must be the signing account public key")
+        }
+        let type = tx.transactionType ?? 0
+        var rows: [SignSummary.Row] = [
+            .init(label: "Network", value: "XRP Ledger"),
+            .init(label: "Account", value: signer, mono: true),
+            .init(label: "Type", value: types[type] ?? "Type \(type)"),
+        ]
+        var warnings = [String]()
+        if type == 0 {
+            switch tx.amount {
+            case .some(.none):
+                rows.append(.init(label: "Send", value: "Issued token amount"))
+                warnings.append("Issued-token payments cannot be described in detail.")
+            case .some(.some(let drops)):
+                rows.append(.init(label: "Send", value: xrp(drops)))
+            case .none:
+                break
+            }
+            if let d = tx.destination, !d.isEmpty { rows.append(.init(label: "To", value: d, mono: true)) }
+            if let tag = tx.destinationTag { rows.append(.init(label: "Destination tag", value: String(tag))) }
+        } else {
+            warnings.append("\(types[type] ?? "This") transaction cannot be described in detail. Approve only if you trust the app.")
+        }
+        for m in tx.memos { rows.append(.init(label: "Memo", value: m)) }
+        if case .some(.some(let fee)) = tx.fee { rows.append(.init(label: "Network fee", value: xrp(fee))) }
+        if let s = tx.sequence { rows.append(.init(label: "Sequence", value: String(s))) }
+        if let l = tx.lastLedgerSequence { rows.append(.init(label: "Valid until ledger", value: String(l))) }
+        return SignSummary(kind: .transaction, title: "XRP Ledger transaction", rows: rows, body: nil, warnings: warnings, risk: .high)
+    }
+
+    static func sha512Half(_ data: [UInt8]) -> [UInt8] { Array(Array(SHA512.hash(data: data))[0..<32]) }
+
+    /// DER (low S) over SHA-512Half of the signing blob, uppercase hex like ripple-keypairs.
+    static func sign(_ blob: [UInt8], privateKey: [UInt8]) throws -> [String: String] {
+        ["signature": Bytes.hex(try Secp256k1.signDER(hash: sha512Half(blob), key: privateKey)).uppercased()]
+    }
+}