@authon/react-native-wallet 0.1.0 → 0.4.0

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

@@ -0,0 +1,296 @@
+// GENERATED by scripts/sync-native-wallet.mjs from swift/Sources/AuthonWallet/Chains/Bitcoin.swift. Do not edit: change the source and run the script.
+import Foundation
+
+/// Bitcoin PSBT signing (docs/wallet/NATIVE.md section 12, `apps/wallet/src/bitcoin.ts`). Inputs
+/// whose previous output is the signing account's P2WPKH script are signed (BIP143,
+/// SIGHASH_ALL); other inputs are left alone. Every input must carry witness_utxo.
+enum Bitcoin {
+    static let maxPsbt = 100_000
+
+    private static func invalid(_ why: String = "not a valid PSBT") -> WalletError { WalletError(.invalidRequest, why) }
+
+    struct KeyValue {
+        var key: [UInt8]
+        var value: [UInt8]
+    }
+
+    struct Input {
+        var prevout: [UInt8] // txid (32, internal order) + vout (4)
+        var sequence: [UInt8]
+        var map: [KeyValue]
+
+        var witnessUtxo: (amount: UInt64, script: [UInt8])? {
+            guard let v = map.first(where: { $0.key == [0x01] })?.value else { return nil }
+            return try? Bitcoin.decodeTxOut(v)
+        }
+    }
+
+    struct Output {
+        var amount: UInt64
+        var script: [UInt8]
+    }
+
+    /// A version 0 PSBT. Key-value pairs are kept as read and written back in the same order.
+    struct Psbt {
+        var global: [KeyValue]
+        var version: [UInt8]
+        var locktime: [UInt8]
+        var inputs: [Input]
+        var outputs: [Output]
+        var outputMaps: [[KeyValue]]
+    }
+
+    // MARK: - Reading
+
+    private struct Reader {
+        let b: [UInt8]
+        var pos = 0
+        var done: Bool { pos == b.count }
+
+        mutating func take(_ n: Int) throws -> [UInt8] {
+            guard n >= 0, n <= b.count - pos else { throw invalid() }
+            pos += n
+            return Array(b[(pos - n)..<pos])
+        }
+
+        mutating func compact() throws -> Int {
+            let first = try take(1)[0]
+            switch first {
+            case 0xfd: return Int(le(try take(2)))
+            case 0xfe: return Int(le(try take(4)))
+            case 0xff:
+                let v = le(try take(8))
+                guard v <= UInt64(Int32.max) else { throw invalid() }
+                return Int(v)
+            default: return Int(first)
+            }
+        }
+
+        mutating func varBytes() throws -> [UInt8] { try take(try compact()) }
+
+        /// One map; ends at the 0x00 separator. Duplicate keys are invalid.
+        mutating func map() throws -> [KeyValue] {
+            var out = [KeyValue]()
+            while true {
+                let key = try varBytes()
+                if key.isEmpty { return out }
+                let value = try varBytes()
+                guard !out.contains(where: { $0.key == key }) else { throw invalid() }
+                out.append(KeyValue(key: key, value: value))
+            }
+        }
+    }
+
+    static func le(_ b: [UInt8]) -> UInt64 { b.enumerated().reduce(UInt64(0)) { $0 | UInt64($1.element) << (8 * UInt64($1.offset)) } }
+    static func le64(_ v: UInt64) -> [UInt8] { (0..<8).map { UInt8(truncatingIfNeeded: v >> (8 * UInt64($0))) } }
+
+    static func compact(_ n: Int) -> [UInt8] {
+        if n < 0xfd { return [UInt8(n)] }
+        if n <= 0xffff { return [0xfd, UInt8(n & 0xff), UInt8(n >> 8)] }
+        return [0xfe] + (0..<4).map { UInt8(truncatingIfNeeded: n >> (8 * $0)) }
+    }
+
+    static func decodeTxOut(_ b: [UInt8]) throws -> (amount: UInt64, script: [UInt8]) {
+        var r = Reader(b: b)
+        let amount = le(try r.take(8))
+        let script = try r.varBytes()
+        guard r.done else { throw invalid() }
+        return (amount, script)
+    }
+
+    static func parse(_ bytes: [UInt8]) throws -> Psbt {
+        guard !bytes.isEmpty, bytes.count <= maxPsbt else { throw invalid() }
+        var r = Reader(b: bytes)
+        guard try r.take(5) == [0x70, 0x73, 0x62, 0x74, 0xff] else { throw invalid() }
+        let global = try r.map()
+        if let v = global.first(where: { $0.key == [0xfb] })?.value, le(v) != 0 { throw invalid("only PSBT version 0 is supported") }
+        guard let unsigned = global.first(where: { $0.key == [0x00] })?.value else { throw invalid() }
+        var t = Reader(b: unsigned)
+        let version = try t.take(4)
+        let inCount = try t.compact()
+        guard inCount > 0 else { throw invalid() } // also rejects a segwit marker
+        var inputs = [Input]()
+        for _ in 0..<inCount {
+            let prevout = try t.take(36)
+            guard try t.varBytes().isEmpty else { throw invalid() } // unsigned: empty scriptSig
+            inputs.append(Input(prevout: prevout, sequence: try t.take(4), map: []))
+        }
+        var outputs = [Output]()
+        for _ in 0..<(try t.compact()) {
+            let amount = le(try t.take(8))
+            outputs.append(Output(amount: amount, script: try t.varBytes()))
+        }
+        let locktime = try t.take(4)
+        guard t.done else { throw invalid() }
+        for i in inputs.indices {
+            inputs[i].map = try r.map()
+            if let utxo = inputs[i].map.first(where: { $0.key == [0x01] }) { _ = try decodeTxOut(utxo.value) }
+            if let sighash = inputs[i].map.first(where: { $0.key == [0x03] })?.value, sighash != [1, 0, 0, 0] {
+                throw invalid("only SIGHASH_ALL inputs can be signed")
+            }
+        }
+        var outputMaps = [[KeyValue]]()
+        for _ in outputs { outputMaps.append(try r.map()) }
+        guard r.done else { throw invalid() }
+        return Psbt(global: global, version: version, locktime: locktime, inputs: inputs, outputs: outputs, outputMaps: outputMaps)
+    }
+
+    static func serialize(_ p: Psbt) -> [UInt8] {
+        func map(_ m: [KeyValue]) -> [UInt8] {
+            var out = [UInt8]()
+            for kv in m {
+                out += compact(kv.key.count)
+                out += kv.key
+                out += compact(kv.value.count)
+                out += kv.value
+            }
+            out.append(0)
+            return out
+        }
+        var out: [UInt8] = [0x70, 0x73, 0x62, 0x74, 0xff]
+        out += map(p.global)
+        for i in p.inputs { out += map(i.map) }
+        for m in p.outputMaps { out += map(m) }
+        return out
+    }
+
+    // MARK: - Scripts and addresses
+
+    static func p2wpkh(_ compressed: [UInt8]) -> [UInt8] { [0x00, 0x14] + ChainAddresses.hash160(compressed) }
+
+    private static func hrp(_ chain: WalletChain) -> String { chain == .bitcoin ? "bc" : "tb" }
+
+    /// Address of a standard output script, or nil.
+    static func address(script s: [UInt8], chain: WalletChain) -> String? {
+        let main = chain == .bitcoin
+        func base58(_ version: UInt8, _ hash: ArraySlice<UInt8>) -> String {
+            let payload = [version] + hash
+            return Base58.encode(payload + ChainAddresses.checksum4(payload), alphabet: Base58.bitcoin)
+        }
+        if s.count == 25, s[0] == 0x76, s[1] == 0xa9, s[2] == 0x14, s[23] == 0x88, s[24] == 0xac { return base58(main ? 0x00 : 0x6f, s[3..<23]) }
+        if s.count == 23, s[0] == 0xa9, s[1] == 0x14, s[22] == 0x87 { return base58(main ? 0x05 : 0xc4, s[2..<22]) }
+        if s.count == 22, s[0] == 0x00, s[1] == 0x14 { return Bech32.segwitAddress(hrp: hrp(chain), version: 0, program: Array(s[2...])) }
+        if s.count == 34, s[0] == 0x00, s[1] == 0x20 { return Bech32.segwitAddress(hrp: hrp(chain), version: 0, program: Array(s[2...])) }
+        if s.count == 34, s[0] == 0x51, s[1] == 0x20 { return Bech32.segwitAddress(hrp: hrp(chain), version: 1, program: Array(s[2...])) }
+        return nil
+    }
+
+    static func btc(_ sats: UInt64) -> String { Solana.units(sats, 8) + " BTC" }
+
+    private static func ownInputs(_ p: Psbt, script: [UInt8]) -> [Int] {
+        p.inputs.indices.filter { p.inputs[$0].witnessUtxo?.script == script }
+    }
+
+    static func summarize(_ p: Psbt, signer: String, chain: WalletChain) throws -> SignSummary {
+        guard let decoded = Bech32.decodeSegwit(hrp: hrp(chain), address: signer), decoded.version == 0, decoded.program.count == 20 else {
+            throw WalletError(.invalidRequest, "address is not a Bitcoin address of this network")
+        }
+        let script = [0x00, 0x14] + decoded.program
+        var rows: [SignSummary.Row] = [
+            .init(label: "Network", value: chain == .bitcoin ? "Bitcoin" : "Bitcoin testnet"),
+            .init(label: "Account", value: signer, mono: true),
+        ]
+        var warnings = [String]()
+        var inputs: UInt64 = 0
+        for i in p.inputs {
+            guard let utxo = i.witnessUtxo else { throw invalid("every input needs witness_utxo") }
+            let (sum, overflow) = inputs.addingReportingOverflow(utxo.amount)
+            guard !overflow else { throw invalid() }
+            inputs = sum
+        }
+        let mine = ownInputs(p, script: script)
+        guard !mine.isEmpty else { throw WalletError(.addressMismatch, "no input belongs to the signing account") }
+        if mine.count != p.inputs.count {
+            warnings.append("\(p.inputs.count - mine.count) of \(p.inputs.count) inputs are not yours and are not signed.")
+        }
+        rows.append(.init(label: "Spending", value: btc(inputs)))
+        var outputs: UInt64 = 0
+        for o in p.outputs {
+            let (sum, overflow) = outputs.addingReportingOverflow(o.amount)
+            guard !overflow else { throw invalid() }
+            outputs = sum
+            let to: String
+            if let a = address(script: o.script, chain: chain) {
+                to = a
+            } else {
+                to = "non-standard output"
+                warnings.append("An output has a script this wallet cannot show as an address.")
+            }
+            rows.append(o.script == script
+                ? .init(label: "Change back to you", value: btc(o.amount))
+                : .init(label: "Send \(btc(o.amount)) to", value: to, mono: true))
+        }
+        guard outputs <= inputs else { throw invalid("outputs exceed inputs") }
+        let fee = inputs - outputs
+        rows.append(.init(label: "Network fee", value: btc(fee)))
+        if fee.multipliedReportingOverflow(by: 10).partialValue > inputs && fee > 100_000 {
+            warnings.append("The network fee is more than 10% of the amount spent.")
+        }
+        return SignSummary(kind: .transaction, title: "Bitcoin transaction", rows: rows, body: nil, warnings: warnings, risk: .high)
+    }
+
+    // MARK: - Signing
+
+    private static func dsha(_ b: [UInt8]) -> [UInt8] { Bytes.sha256(Bytes.sha256(b)) }
+
+    private static func serializeOutputs(_ p: Psbt) -> [UInt8] {
+        p.outputs.flatMap { le64($0.amount) + compact($0.script.count) + $0.script }
+    }
+
+    /// BIP143 SIGHASH_ALL digest of input `index` spending a P2WPKH output of `pubkeyHash`.
+    static func sighash(_ p: Psbt, index: Int, pubkeyHash: [UInt8], amount: UInt64) -> [UInt8] {
+        let hashPrevouts = dsha(p.inputs.flatMap(\.prevout))
+        let hashSequence = dsha(p.inputs.flatMap(\.sequence))
+        let hashOutputs = dsha(serializeOutputs(p))
+        let scriptCode: [UInt8] = [0x19, 0x76, 0xa9, 0x14] + pubkeyHash + [0x88, 0xac]
+        let input = p.inputs[index]
+        var preimage: [UInt8] = p.version
+        preimage += hashPrevouts
+        preimage += hashSequence
+        preimage += input.prevout
+        preimage += scriptCode
+        preimage += le64(amount)
+        preimage += input.sequence
+        preimage += hashOutputs
+        preimage += p.locktime
+        preimage += [1, 0, 0, 0]
+        return dsha(preimage)
+    }
+
+    /// Signs the signer's inputs. Returns the signed PSBT (partial signatures added) and, when
+    /// every input was ours, the finalized raw transaction.
+    static func sign(_ psbt: Psbt, privateKey: [UInt8]) throws -> [String: String] {
+        var p = psbt
+        let pub = try Secp256k1.publicKey(of: privateKey, compressed: true)
+        let script = p2wpkh(pub)
+        let pubkeyHash = Array(script[2...])
+        let mine = ownInputs(p, script: script)
+        guard !mine.isEmpty else { throw WalletError(.addressMismatch) }
+        var witnesses = [Int: [UInt8]]()
+        for i in mine {
+            let amount = p.inputs[i].witnessUtxo!.amount
+            let sig = try Secp256k1.signDER(hash: sighash(p, index: i, pubkeyHash: pubkeyHash, amount: amount), key: privateKey) + [0x01]
+            let key = [0x02] + pub
+            if let at = p.inputs[i].map.firstIndex(where: { $0.key == key }) {
+                p.inputs[i].map[at].value = sig
+            } else {
+                p.inputs[i].map.append(KeyValue(key: key, value: sig))
+            }
+            witnesses[i] = compact(2) + compact(sig.count) + sig + compact(pub.count) + pub
+        }
+        var result = ["psbt": Bytes.base64(serialize(p))]
+        guard mine.count == p.inputs.count else { return result }
+        var tx = p.version + [0x00, 0x01] + compact(p.inputs.count)
+        for i in p.inputs { tx += i.prevout + [0x00] + i.sequence }
+        tx += compact(p.outputs.count) + serializeOutputs(p)
+        for i in p.inputs.indices { tx += witnesses[i]! }
+        tx += p.locktime
+        result["txHex"] = Bytes.hex(tx)
+        return result
+    }
+
+    /// Partial signatures (by input) for checks: the value of the PSBT_IN_PARTIAL_SIG entry for `pubkey`.
+    static func partialSignatures(_ p: Psbt, pubkey: [UInt8]) -> [[UInt8]?] {
+        p.inputs.map { i in i.map.first(where: { $0.key == [0x02] + pubkey })?.value }
+    }
+}

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)])]
+    }
+}