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

package/ios/vendor/AuthonWallet/Wallet/Proof.swift

@@ -0,0 +1,143 @@
+// GENERATED by scripts/sync-native-wallet.mjs from swift/Sources/AuthonWallet/Wallet/Proof.swift. Do not edit: change the source and run the script.
+import Foundation
+
+/// Device public key as the API stores it.
+public struct DevicePublicJwk: Codable, Equatable, Sendable {
+    public var kty: String
+    public var crv: String
+    public var x: String
+    public var y: String
+
+    public init(x: String, y: String) {
+        kty = "EC"
+        crv = "P-256"
+        self.x = x
+        self.y = y
+    }
+
+    /// From a 65-byte uncompressed P-256 point.
+    init(uncompressed point: [UInt8]) throws {
+        guard point.count == 65, point[0] == 4 else { throw WalletError(.internal, "invalid device public key") }
+        self.init(x: Bytes.base64url(Array(point[1..<33])), y: Bytes.base64url(Array(point[33..<65])))
+    }
+
+    var json: JSONValue {
+        .object(JSONObject([("kty", .string(kty)), ("crv", .string(crv)), ("x", .string(x)), ("y", .string(y))]))
+    }
+}
+
+/// Server-issued nonce bound into a wallet key proof (`expiresAt` in Unix seconds).
+public struct ProofNonce: Equatable, Sendable {
+    public var nonce: String
+    public var expiresAt: Int64
+}
+
+/// Wallet key proofs (`apps/wallet/src/proof.ts`): EIP-712 under the wallet's own domain.
+enum WalletProof {
+    static let domainName = "Authon Wallet Proof"
+    static let reservedPrefixes = ["create:", "device:", "restore:"]
+
+    static func canonicalJwk(_ jwk: DevicePublicJwk) -> String {
+        "{\"crv\":\(JSONValue.quote(jwk.crv)),\"kty\":\(JSONValue.quote(jwk.kty)),\"x\":\(JSONValue.quote(jwk.x)),\"y\":\(JSONValue.quote(jwk.y))}"
+    }
+
+    static func devicePublicKeyHash(_ jwk: DevicePublicJwk) -> String {
+        Bytes.hex(Bytes.sha256(Array(canonicalJwk(jwk).utf8)))
+    }
+
+    enum Kind: String {
+        case create = "CreateWallet"
+        case device = "AddDevice"
+        case restore = "RestoreWallet"
+    }
+
+    static func typedData(_ kind: Kind, _ fields: [(String, JSONValue)], bound: ProofNonce) -> JSONValue {
+        func field(_ n: String, _ t: String) -> JSONValue { .object(JSONObject([("name", .string(n)), ("type", .string(t))])) }
+        let head: [JSONValue]
+        switch kind {
+        case .create: head = [field("projectId", "string"), field("userId", "string"), field("deviceKeyHash", "string")]
+        case .device, .restore: head = [field("walletId", "string"), field("shareVersion", "uint256"), field("deviceKeyHash", "string")]
+        }
+        let typeList = head + [field("nonce", "string"), field("expiresAt", "uint256")]
+        return .object(JSONObject([
+            ("domain", .object(JSONObject([("name", .string(domainName)), ("version", .string("1"))]))),
+            ("types", .object(JSONObject([(kind.rawValue, .array(typeList))]))),
+            ("primaryType", .string(kind.rawValue)),
+            ("message", .object(JSONObject(fields + [("nonce", .string(bound.nonce)), ("expiresAt", .number(String(bound.expiresAt)))]))),
+        ]))
+    }
+
+    private static func sign(_ secret: [UInt8], _ td: JSONValue) throws -> String {
+        let account = try WalletShares.account(secret)
+        defer { account.wipe() }
+        return try account.signTypedData(try TypedData(td))
+    }
+
+    static func createTypedData(projectId: String, userId: String, deviceKey: DevicePublicJwk, bound: ProofNonce) -> JSONValue {
+        typedData(.create, [("projectId", .string(projectId)), ("userId", .string(userId)), ("deviceKeyHash", .string(devicePublicKeyHash(deviceKey)))], bound: bound)
+    }
+
+    static func deviceTypedData(walletId: String, shareVersion: Int, deviceKey: DevicePublicJwk, bound: ProofNonce) -> JSONValue {
+        typedData(.device, [("walletId", .string(walletId)), ("shareVersion", .number(String(shareVersion))), ("deviceKeyHash", .string(devicePublicKeyHash(deviceKey)))], bound: bound)
+    }
+
+    /// The restore proof names the next share version (current + 1).
+    static func restoreTypedData(walletId: String, currentShareVersion: Int, deviceKey: DevicePublicJwk, bound: ProofNonce) -> JSONValue {
+        typedData(.restore, [("walletId", .string(walletId)), ("shareVersion", .number(String(currentShareVersion + 1))), ("deviceKeyHash", .string(devicePublicKeyHash(deviceKey)))], bound: bound)
+    }
+
+    static func signCreate(_ secret: [UInt8], projectId: String, userId: String, deviceKey: DevicePublicJwk, bound: ProofNonce) throws -> String {
+        try sign(secret, createTypedData(projectId: projectId, userId: userId, deviceKey: deviceKey, bound: bound))
+    }
+
+    static func signDevice(_ secret: [UInt8], walletId: String, shareVersion: Int, deviceKey: DevicePublicJwk, bound: ProofNonce) throws -> String {
+        try sign(secret, deviceTypedData(walletId: walletId, shareVersion: shareVersion, deviceKey: deviceKey, bound: bound))
+    }
+
+    static func signRestore(_ secret: [UInt8], walletId: String, currentShareVersion: Int, deviceKey: DevicePublicJwk, bound: ProofNonce) throws -> String {
+        try sign(secret, restoreTypedData(walletId: walletId, currentShareVersion: currentShareVersion, deviceKey: deviceKey, bound: bound))
+    }
+
+    /// App text that looks like a (legacy) wallet proof is never signed for an app.
+    static func isReservedMessageText(_ text: String) -> Bool {
+        let scalars = text.unicodeScalars.drop { $0.properties.isWhitespace || $0.value < 0x20 || $0.value == 0xfeff }
+        let t = String(String.UnicodeScalarView(scalars)).lowercased()
+        return reservedPrefixes.contains { t.hasPrefix($0) }
+    }
+
+    /// `{raw}` hex decoded as strict UTF-8; nil when it is not valid UTF-8.
+    static func rawMessageText(_ hex: String) -> String? {
+        let body = hex.hasPrefix("0x") ? String(hex.dropFirst(2)) : hex
+        guard body.count % 2 == 0, let bytes = Bytes.fromHex(body) else { return nil }
+        return String(strictUTF8: bytes)
+    }
+
+    static func isReservedTypedData(_ td: JSONValue) -> Bool {
+        guard case .string(let name) = td["domain"]?["name"] ?? .null else { return false }
+        return name.trimmingCharacters(in: jsWhitespace).lowercased() == domainName.lowercased()
+    }
+
+    /// JavaScript String.prototype.trim whitespace.
+    static let jsWhitespace: CharacterSet = {
+        var set = CharacterSet.whitespacesAndNewlines
+        set.insert(charactersIn: "\u{feff}")
+        return set
+    }()
+}
+
+extension String {
+    /// Strict UTF-8 decoding (TextDecoder with fatal: true).
+    init?(strictUTF8 bytes: [UInt8]) {
+        var it = bytes.makeIterator()
+        var decoder = UTF8()
+        var scalars = String.UnicodeScalarView()
+        loop: while true {
+            switch decoder.decode(&it) {
+            case .scalarValue(let s): scalars.append(s)
+            case .emptyInput: break loop
+            case .error: return nil
+            }
+        }
+        self = String(scalars)
+    }
+}

package/ios/vendor/AuthonWallet/Wallet/Shares.swift

@@ -0,0 +1,116 @@
+// GENERATED by scripts/sync-native-wallet.mjs from swift/Sources/AuthonWallet/Wallet/Shares.swift. Do not edit: change the source and run the script.
+import Foundation
+
+/// The wallet secret and its shares (`apps/wallet/src/shares.ts`). The secret is BIP39
+/// entropy (16 bytes); a 32-byte secret is a raw key from before HD wallets (account 0 only).
+enum WalletShares {
+    static let hdEntropyBytes = 16
+    static let maxAccountIndex = 0x7fff_ffff
+
+    static func evmPath(_ index: Int) -> String { "m/44'/60'/0'/0/\(index)" }
+
+    static func generateSecret() throws -> [UInt8] { try Bytes.random(hdEntropyBytes) }
+
+    static func isHdSecret(_ secret: [UInt8]) -> Bool { secret.count == hdEntropyBytes }
+
+    static func isAccountIndex(_ index: Int) -> Bool { index >= 0 && index <= maxAccountIndex }
+
+    private static func rootNode(_ secret: [UInt8]) throws -> HDNode {
+        var seed = try BIP39.seed(mnemonic: try BIP39.mnemonic(entropy: secret))
+        defer { seed.wipe() }
+        return try HDNode(seed: seed)
+    }
+
+    /// The EVM private key at account `index`. Callers must wipe the result.
+    static func privateKey(_ secret: [UInt8], index: Int = 0) throws -> [UInt8] {
+        guard isAccountIndex(index) else { throw WalletError(.internal, "invalid account index") }
+        if secret.count == 32 {
+            guard index == 0 else { throw WalletError(.internal, "single-key wallet has only account 0") }
+            return secret
+        }
+        guard isHdSecret(secret) else { throw WalletError(.internal, "unsupported wallet secret") }
+        var root = try rootNode(secret)
+        defer { root.wipe() }
+        var node = try root.derive(evmPath(index))
+        defer { node.wipe() }
+        return node.key
+    }
+
+    static func account(_ secret: [UInt8], index: Int = 0) throws -> EvmAccount {
+        var key = try privateKey(secret, index: index)
+        defer { key.wipe() }
+        return try EvmAccount(privateKey: key)
+    }
+
+    static func address(_ secret: [UInt8], index: Int = 0) throws -> String {
+        let a = try account(secret, index: index)
+        a.wipe()
+        return a.address
+    }
+
+    /// Addresses of accounts start..<start+count. The seed and m/44'/60'/0'/0 are derived once.
+    static func addresses(_ secret: [UInt8], start: Int, count: Int) throws -> [String] {
+        guard isAccountIndex(start), count >= 1, isAccountIndex(start + count - 1) else {
+            throw WalletError(.internal, "invalid account range")
+        }
+        if secret.count == 32 {
+            guard start == 0, count == 1 else { throw WalletError(.internal, "single-key wallet has only account 0") }
+            return [try address(secret)]
+        }
+        guard isHdSecret(secret) else { throw WalletError(.internal, "unsupported wallet secret") }
+        var root = try rootNode(secret)
+        defer { root.wipe() }
+        var parent = try root.derive("m/44'/60'/0'/0")
+        defer { parent.wipe() }
+        var out = [String]()
+        out.reserveCapacity(count)
+        for i in start..<(start + count) {
+            var child = try parent.child(UInt32(i))
+            defer { child.wipe() }
+            out.append(try EvmAddress.of(privateKey: child.key))
+        }
+        return out
+    }
+
+    static func splitUnprotected(_ secret: [UInt8]) throws -> (device: [UInt8], company: [UInt8]) {
+        let s = try Shamir.split(secret, shares: 2, threshold: 2)
+        return (s[0], s[1])
+    }
+
+    static func splitProtected(_ secret: [UInt8]) throws -> (device: [UInt8], company: [UInt8], backup: [UInt8]) {
+        let s = try Shamir.split(secret, shares: 3, threshold: 2)
+        return (s[0], s[1], s[2])
+    }
+
+    static func assemble(_ a: [UInt8], _ b: [UInt8]) throws -> [UInt8] {
+        do {
+            return try Shamir.combine([a, b])
+        } catch {
+            throw WalletError(.internal, "shares cannot be combined")
+        }
+    }
+
+    /// One more share on the same line as `a` and `b` at a fresh x (shares.ts deriveShare):
+    /// shifting both x coordinates by x3 and interpolating at zero yields f(x3).
+    static func deriveShare(_ a: [UInt8], _ b: [UInt8], x: UInt8? = nil) throws -> [UInt8] {
+        guard a.count == b.count, a.count >= 2 else { throw WalletError(.internal, "share length mismatch") }
+        let xa = a[a.count - 1]
+        let xb = b[b.count - 1]
+        var x3: UInt8 = x ?? 0
+        while x3 == 0 || x3 == xa || x3 == xb {
+            guard x == nil else { throw WalletError(.internal, "invalid x") }
+            x3 = try Bytes.random(1)[0]
+        }
+        var shiftedA = a
+        var shiftedB = b
+        shiftedA[a.count - 1] = xa ^ x3
+        shiftedB[b.count - 1] = xb ^ x3
+        defer {
+            shiftedA.wipe()
+            shiftedB.wipe()
+        }
+        var y = try Shamir.combine([shiftedA, shiftedB])
+        defer { y.wipe() }
+        return y + [x3]
+    }
+}

package/ios/vendor/AuthonWallet/Wallet/Summary.swift

@@ -0,0 +1,342 @@
+// GENERATED by scripts/sync-native-wallet.mjs from swift/Sources/AuthonWallet/Wallet/Summary.swift. Do not edit: change the source and run the script.
+import Foundation
+
+/// Human-readable description of a signing request, built from the exact payload that is
+/// signed (`apps/wallet/src/summary.ts`).
+public struct SignSummary: Equatable, Sendable {
+    public enum Kind: String, Sendable { case message, typedData, transaction }
+    public enum Risk: String, Sendable { case low, high }
+
+    public struct Row: Equatable, Sendable {
+        public var label: String
+        public var value: String
+        /// Monospace (addresses, hex).
+        public var mono: Bool
+
+        public init(label: String, value: String, mono: Bool = false) {
+            self.label = label
+            self.value = value
+            self.mono = mono
+        }
+    }
+
+    public var kind: Kind
+    public var title: String
+    public var rows: [Row]
+    /// The complete signed text (message, or typed data message JSON), never shortened.
+    public var body: String?
+    /// Any entry marks the request as dangerous.
+    public var warnings: [String]
+    /// High: moves value or grants spending.
+    public var risk: Risk
+}
+
+enum Summaries {
+    /// Longest text a confirmation shows; longer requests are refused (MESSAGE_TOO_LARGE).
+    static let maxSignText = 16_384
+
+    private static let chains: [Int: (String, String)] = [
+        1: ("Ethereum", "ETH"), 10: ("Optimism", "ETH"), 56: ("BNB Smart Chain", "BNB"), 137: ("Polygon", "POL"),
+        8453: ("Base", "ETH"), 42161: ("Arbitrum One", "ETH"), 43114: ("Avalanche C-Chain", "AVAX"),
+        80002: ("Polygon Amoy (testnet)", "POL"), 84532: ("Base Sepolia (testnet)", "ETH"), 11155111: ("Sepolia (testnet)", "ETH"),
+    ]
+
+    static func chainLabel(_ chainId: Int?) -> String {
+        guard let chainId else { return "Unknown network" }
+        if let c = chains[chainId] { return "\(c.0) (\(chainId))" }
+        return "Chain \(chainId)"
+    }
+
+    private static func nativeSymbol(_ chainId: Int?) -> String { chainId.flatMap { chains[$0]?.1 } ?? "native token" }
+
+    private static let maxUint256 = BigUInt.power2(256) - BigUInt(1)
+    private static let unlimitedThreshold = BigUInt.power2(255)
+    private static let permit2 = "0x000000000022d473030f116ddee9f6b43ac78ba3"
+
+    static func requireShowable(_ text: String) throws -> String {
+        let n = text.utf16.count
+        if n > maxSignText {
+            throw WalletError(.messageTooLarge, "the request has \(n) characters; at most \(maxSignText) can be shown")
+        }
+        return text
+    }
+
+    private static func amountText(_ v: BigUInt, _ unlimited: String = "Unlimited") -> String {
+        v >= unlimitedThreshold ? "\(unlimited) (\(v == maxUint256 ? "max uint256" : v.description))" : v.description
+    }
+
+    /// summary.ts toBigInt: undefined for missing, null, empty or unparsable values.
+    private static func toBigInt(_ v: JSONValue?) -> BigInteger? {
+        guard let v, v != .null, v != .string("") else { return nil }
+        return v.jsBigInt
+    }
+
+    private static func toChainId(_ v: JSONValue?) -> Int? {
+        guard let b = toBigInt(v), let u = b.magnitude.uint64, u <= UInt64(Int.max) else { return nil }
+        return b.negative ? -Int(u) : Int(u)
+    }
+
+    /// viem formatUnits(value, 18).
+    static func formatEther(_ v: BigUInt) -> String {
+        var digits = v.description
+        if digits.count <= 18 { digits = String(repeating: "0", count: 18 - digits.count + 1) + digits }
+        let integer = String(digits.dropLast(18))
+        var fraction = String(digits.suffix(18))
+        while fraction.hasSuffix("0") { fraction.removeLast() }
+        return (integer.isEmpty ? "0" : integer) + (fraction.isEmpty ? "" : ".\(fraction)")
+    }
+
+    // MARK: - Message
+
+    static func message(_ m: ParsedMessage) throws -> SignSummary {
+        switch m {
+        case .text(let s):
+            return SignSummary(kind: .message, title: "Sign message", rows: [], body: try requireShowable(s), warnings: [], risk: .low)
+        case .raw(let hex):
+            let text = WalletProof.rawMessageText(hex)
+            let printable = text.map { t in !t.unicodeScalars.contains { $0.value <= 0x08 || (0x0e...0x1f).contains($0.value) || $0.value == 0x7f } } ?? false
+            return SignSummary(
+                kind: .message,
+                title: "Sign message",
+                rows: printable ? [] : [.init(label: "Format", value: "Raw bytes (not readable text)")],
+                body: try requireShowable(printable ? text! : hex),
+                warnings: printable ? [] : ["This message is not readable text. Only sign it if you trust this site."],
+                risk: .low
+            )
+        }
+    }
+
+    // MARK: - Typed data
+
+    private static let permitTypes: Set<String> = [
+        "Permit", "PermitSingle", "PermitBatch", "PermitTransferFrom", "PermitBatchTransferFrom",
+        "PermitWitnessTransferFrom", "PermitBatchWitnessTransferFrom", "PermitForAll",
+    ]
+    private static let spendingTypes: Set<String> = [
+        "OrderComponents", "Order", "BulkOrder", "OrderParameters", "ForwardRequest", "MetaTransaction", "SafeTx", "Delegation", "Approval",
+    ]
+    private static let spendingKeys: Set<String> = ["spender", "operator", "delegate", "delegatee", "approved", "allowance", "allowed"]
+
+    private static func grantsSpending(_ message: JSONValue) -> Bool {
+        var budget = 2000
+        func walk(_ v: JSONValue, _ depth: Int) -> Bool {
+            budget -= 1
+            if budget < 0 || depth > 12 { return true }
+            if case .array(let a) = v { return a.contains { walk($0, depth + 1) } }
+            guard case .object(let o) = v else { return false }
+            let entries = o.entries.map { ($0.key.lowercased(), $0.value) }
+            let keys = entries.map(\.0)
+            if keys.contains(where: spendingKeys.contains) { return true }
+            let hasCall = entries.contains { k, x in
+                (k == "data" || k == "calldata") && { if case .string(let s) = x { return s != "0x" && s != "" } else { return false } }()
+            }
+            let hasTarget = keys.contains("to") || keys.contains("recipient")
+            let hasValue = keys.contains("value") || keys.contains("amount")
+            if hasCall || (hasTarget && hasValue) { return true }
+            return o.entries.contains { walk($0.value, depth + 1) }
+        }
+        return walk(message, 0)
+    }
+
+    static func typedData(_ td: JSONValue) throws -> SignSummary {
+        let domain = td["domain"]?.objectValue ?? JSONObject()
+        let primaryType = td["primaryType"].map { $0 == .null ? "" : EvmAddress.jsString($0) } ?? ""
+        let message = td["message"].flatMap { $0 == .null ? nil : $0 } ?? .object(JSONObject())
+        var rows = [SignSummary.Row]()
+        if case .string(let name) = domain["name"] ?? .null { rows.append(.init(label: "App or contract", value: name)) }
+        let chainId = toChainId(domain["chainId"])
+        if chainId != nil { rows.append(.init(label: "Network", value: chainLabel(chainId))) }
+        if case .string = domain["verifyingContract"] ?? .null {
+            rows.append(.init(label: "Contract", value: EvmAddress.display(domain["verifyingContract"]), mono: true))
+        }
+        rows.append(.init(label: "Type", value: primaryType.isEmpty ? "unknown" : primaryType))
+
+        var warnings = [String]()
+        let verifying = domain["verifyingContract"]?.stringValue?.lowercased() ?? ""
+        let isPermit2 = domain["name"] == .string("Permit2") || verifying == permit2
+        let permit = permitTypes.contains(primaryType) || isPermit2
+        if permit {
+            warnings.append("This is a token permit. Signing it lets the spender move your tokens without another confirmation.")
+            let spender = message["spender"] ?? message["details"]?["spender"]
+            if let spender { rows.append(.init(label: "Spender", value: EvmAddress.display(spender), mono: true)) }
+            let amount = toBigInt(message["value"]) ?? toBigInt(message["amount"]) ?? toBigInt(message["details"]?["amount"]) ?? toBigInt(message["permitted"]?["amount"])
+            if let amount { rows.append(.init(label: "Amount (token units)", value: amount.negative ? amount.description : amountText(amount.magnitude))) }
+            if let amount, !amount.negative, amount.magnitude >= unlimitedThreshold { warnings.append("The permitted amount is unlimited.") }
+            let deadline = toBigInt(message["deadline"]) ?? toBigInt(message["sigDeadline"]) ?? toBigInt(message["expiry"])
+            if let deadline { rows.append(.init(label: "Valid until", value: deadline.description)) }
+        } else if message["spender"] != nil || message["operator"] != nil {
+            warnings.append("This signature may give another address access to your assets.")
+        }
+        let high = permit || spendingTypes.contains(primaryType) || grantsSpending(message)
+        if high && warnings.isEmpty { warnings.append("This signature may let another address move your assets or act for you.") }
+        return SignSummary(kind: .typedData, title: "Sign data", rows: rows, body: try requireShowable(message.pretty()), warnings: warnings, risk: high ? .high : .low)
+    }
+
+    // MARK: - Transaction
+
+    private enum AbiType { case address, uint, bool, bytes32 }
+
+    private struct AbiFunction {
+        var name: String
+        var signature: String
+        var inputs: [AbiType]
+        var selector: [UInt8] { Array(Keccak.hash256(Array(signature.utf8))[0..<4]) }
+    }
+
+    private static let ercAbi: [AbiFunction] = [
+        .init(name: "transfer", signature: "transfer(address,uint256)", inputs: [.address, .uint]),
+        .init(name: "approve", signature: "approve(address,uint256)", inputs: [.address, .uint]),
+        .init(name: "transferFrom", signature: "transferFrom(address,address,uint256)", inputs: [.address, .address, .uint]),
+        .init(name: "increaseAllowance", signature: "increaseAllowance(address,uint256)", inputs: [.address, .uint]),
+        .init(name: "setApprovalForAll", signature: "setApprovalForAll(address,bool)", inputs: [.address, .bool]),
+        .init(name: "permit", signature: "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)", inputs: [.address, .address, .uint, .uint, .uint, .bytes32, .bytes32]),
+        .init(name: "approve", signature: "approve(address,address,uint160,uint48)", inputs: [.address, .address, .uint, .uint]),
+    ]
+
+    private enum AbiValue {
+        case address(String)
+        case uint(BigUInt)
+        case bool(Bool)
+        case bytes([UInt8])
+
+        var text: String {
+            switch self {
+            case .address(let a): return a
+            case .uint(let u): return u.description
+            case .bool(let b): return b ? "true" : "false"
+            case .bytes(let b): return Bytes.hex(b, prefix: true)
+            }
+        }
+
+        var uint: BigUInt {
+            if case .uint(let u) = self { return u }
+            return BigUInt()
+        }
+    }
+
+    /// viem decodeFunctionData over the ABI above; nil when nothing matches or the data is short or malformed.
+    private static func decode(_ data: [UInt8]) -> (name: String, args: [AbiValue])? {
+        guard data.count >= 4 else { return nil }
+        guard let fn = ercAbi.first(where: { $0.selector == Array(data[0..<4]) }) else { return nil }
+        guard data.count >= 4 + 32 * fn.inputs.count else { return nil }
+        var args = [AbiValue]()
+        for (i, t) in fn.inputs.enumerated() {
+            let word = Array(data[(4 + 32 * i)..<(4 + 32 * (i + 1))])
+            switch t {
+            case .address: args.append(.address(EvmAddress.checksum(Bytes.hex(Array(word[12...])))))
+            case .uint: args.append(.uint(BigUInt(bytes: word)))
+            case .bool:
+                let v = BigUInt(bytes: word)
+                guard v <= BigUInt(1) else { return nil }
+                args.append(.bool(!v.isZero))
+            case .bytes32: args.append(.bytes(word))
+            }
+        }
+        return (fn.name, args)
+    }
+
+    static func transaction(_ tx: JSONObject) -> SignSummary {
+        let chainId = toChainId(tx["chainId"])
+        var rows: [SignSummary.Row] = [.init(label: "Network", value: chainLabel(chainId))]
+        var warnings = [String]()
+        let to: String? = { if case .string(let s) = tx["to"] ?? .null, !s.isEmpty { return s } else { return nil } }()
+        if let to {
+            rows.append(.init(label: "To", value: EvmAddress.display(.string(to)), mono: true))
+        } else {
+            rows.append(.init(label: "To", value: "New contract (deployment)"))
+            warnings.append("This transaction deploys a contract.")
+        }
+        let valueInt = toBigInt(tx["value"])
+        let value = valueInt.map { $0.negative ? BigUInt() : $0.magnitude } ?? BigUInt()
+        rows.append(.init(label: "Amount", value: "\(formatEther(value)) \(nativeSymbol(chainId))"))
+        if let gas = toBigInt(tx["gas"]), let fee = toBigInt(tx["maxFeePerGas"]) ?? toBigInt(tx["gasPrice"]), !gas.negative, !fee.negative {
+            rows.append(.init(label: "Max network fee", value: "\(formatEther(gas.magnitude * fee.magnitude)) \(nativeSymbol(chainId))"))
+        }
+
+        let data: String = {
+            if case .string(let s) = tx["data"] ?? .null { return s }
+            if case .string(let s) = tx["input"] ?? .null { return s }
+            return "0x"
+        }()
+        let hasData = !data.isEmpty && data != "0x"
+        if hasData {
+            let decoded = Bytes.isHex(data) ? Bytes.fromHex(data).flatMap(decode) : nil
+            if let decoded {
+                let a = decoded.args
+                func address(_ i: Int) -> String { a[i].text }
+                switch decoded.name {
+                case "transfer":
+                    rows += [
+                        .init(label: "Action", value: "Token transfer"),
+                        .init(label: "Token", value: EvmAddress.display(to.map { .string($0) }), mono: true),
+                        .init(label: "Recipient", value: address(0), mono: true),
+                        .init(label: "Amount (token units)", value: a[1].text),
+                    ]
+                case "transferFrom":
+                    rows += [
+                        .init(label: "Action", value: "Token transfer from another address"),
+                        .init(label: "From", value: address(0), mono: true),
+                        .init(label: "Recipient", value: address(1), mono: true),
+                        .init(label: "Amount (token units)", value: a[2].text),
+                    ]
+                case "approve":
+                    if a.count == 4 {
+                        rows += [
+                            .init(label: "Action", value: "Permit2 allowance"),
+                            .init(label: "Token", value: address(0), mono: true),
+                            .init(label: "Spender", value: address(1), mono: true),
+                            .init(label: "Amount (token units)", value: amountText(a[2].uint)),
+                        ]
+                    } else {
+                        rows += [
+                            .init(label: "Action", value: "Token approval"),
+                            .init(label: "Token", value: EvmAddress.display(to.map { .string($0) }), mono: true),
+                            .init(label: "Spender", value: address(0), mono: true),
+                            .init(label: "Amount (token units)", value: amountText(a[1].uint)),
+                        ]
+                        if a[1].uint >= unlimitedThreshold { warnings.append("The approved amount is unlimited.") }
+                    }
+                    warnings.append("This lets the spender move your tokens later without asking again.")
+                case "increaseAllowance":
+                    rows += [
+                        .init(label: "Action", value: "Increase token allowance"),
+                        .init(label: "Spender", value: address(0), mono: true),
+                        .init(label: "Added (token units)", value: amountText(a[1].uint)),
+                    ]
+                    warnings.append("This lets the spender move more of your tokens without asking again.")
+                case "setApprovalForAll":
+                    let approved: Bool = { if case .bool(let b) = a[1] { return b } else { return false } }()
+                    rows += [
+                        .init(label: "Action", value: approved ? "Approve all NFTs in a collection" : "Remove collection approval"),
+                        .init(label: "Operator", value: address(0), mono: true),
+                    ]
+                    if approved { warnings.append("The operator could transfer every item you own in this collection.") }
+                case "permit":
+                    rows += [
+                        .init(label: "Action", value: "Token permit"),
+                        .init(label: "Token", value: EvmAddress.display(to.map { .string($0) }), mono: true),
+                        .init(label: "Spender", value: address(1), mono: true),
+                        .init(label: "Amount (token units)", value: amountText(a[2].uint)),
+                    ]
+                    warnings.append("This lets the spender move your tokens later without asking again.")
+                default:
+                    break
+                }
+            } else {
+                rows.append(.init(label: "Action", value: "Contract call (\(String(data.prefix(10))))", mono: true))
+                rows.append(.init(label: "Data", value: "\(max(0, (data.count - 2) / 2)) bytes"))
+            }
+        }
+        if chainId == nil { warnings.append("The network is not specified.") }
+        let risk: SignSummary.Risk = !value.isZero || hasData || to == nil ? .high : .low
+        return SignSummary(kind: .transaction, title: "Approve transaction", rows: rows, body: nil, warnings: warnings, risk: risk)
+    }
+
+    /// The Account row for a non-zero account (ops.ts withAccountRow).
+    static func withAccountRow(_ s: SignSummary, _ account: SignAccount) -> SignSummary {
+        guard account.index != 0, let address = account.address else { return s }
+        var out = s
+        out.rows.insert(.init(label: "Account", value: address, mono: true), at: 0)
+        return out
+    }
+}