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

package/ios/vendor/AuthonWallet/Crypto/HDKey.swift

@@ -0,0 +1,108 @@
+// GENERATED by scripts/sync-native-wallet.mjs from swift/Sources/AuthonWallet/Crypto/HDKey.swift. Do not edit: change the source and run the script.
+import CommonCrypto
+import CryptoKit
+import Foundation
+
+/// BIP39 (English) for 128..256-bit entropy, as @scure/bip39.
+enum BIP39 {
+    static func mnemonic(entropy: [UInt8]) throws -> String {
+        guard entropy.count >= 16, entropy.count <= 32, entropy.count % 4 == 0 else {
+            throw WalletError(.internal, "invalid entropy length")
+        }
+        let checksumBits = entropy.count / 4
+        let hash = Bytes.sha256(entropy)
+        var bits = [Bool]()
+        bits.reserveCapacity(entropy.count * 8 + checksumBits)
+        for b in entropy { for i in (0..<8).reversed() { bits.append((b >> UInt8(i)) & 1 == 1) } }
+        for i in 0..<checksumBits { bits.append((hash[i / 8] >> UInt8(7 - i % 8)) & 1 == 1) }
+        var words = [String]()
+        for w in 0..<(bits.count / 11) {
+            var index = 0
+            for j in 0..<11 { index = index << 1 | (bits[w * 11 + j] ? 1 : 0) }
+            words.append(bip39EnglishWordlist[index])
+        }
+        return words.joined(separator: " ")
+    }
+
+    /// PBKDF2-HMAC-SHA512, 2048 rounds, salt "mnemonic" (empty passphrase).
+    static func seed(mnemonic: String) throws -> [UInt8] {
+        var password = Array(mnemonic.decomposedStringWithCompatibilityMapping.utf8)
+        defer { password.wipe() }
+        let salt = Array("mnemonic".utf8)
+        var out = [UInt8](repeating: 0, count: 64)
+        let status = password.withUnsafeBufferPointer { pw in
+            CCKeyDerivationPBKDF(
+                CCPBKDFAlgorithm(kCCPBKDF2),
+                UnsafeRawPointer(pw.baseAddress!).assumingMemoryBound(to: CChar.self), pw.count,
+                salt, salt.count,
+                CCPseudoRandomAlgorithm(kCCPRFHmacAlgSHA512), 2048,
+                &out, out.count
+            )
+        }
+        guard status == kCCSuccess else { throw WalletError(.internal, "seed derivation failed") }
+        return out
+    }
+}
+
+/// BIP32 private derivation over secp256k1 (scalar addition and public keys in libsecp256k1).
+struct HDNode {
+    private(set) var key: [UInt8]
+    private(set) var chainCode: [UInt8]
+
+    static let hardened: UInt32 = 0x8000_0000
+
+    init(seed: [UInt8]) throws {
+        var i = HDNode.hmac(key: Array("Bitcoin seed".utf8), data: seed)
+        defer { i.wipe() }
+        let k = Array(i[0..<32])
+        guard Secp256k1.isValidPrivateKey(k) else { throw WalletError(.internal, "invalid master key") }
+        key = k
+        chainCode = Array(i[32..<64])
+    }
+
+    private init(key: [UInt8], chainCode: [UInt8]) {
+        self.key = key
+        self.chainCode = chainCode
+    }
+
+    func child(_ index: UInt32) throws -> HDNode {
+        var data: [UInt8]
+        if index >= HDNode.hardened {
+            data = [0] + key
+        } else {
+            data = try Secp256k1.publicKey(of: key, compressed: true)
+        }
+        data += [UInt8(index >> 24), UInt8(truncatingIfNeeded: index >> 16), UInt8(truncatingIfNeeded: index >> 8), UInt8(truncatingIfNeeded: index)]
+        var i = HDNode.hmac(key: chainCode, data: data)
+        defer {
+            i.wipe()
+            data.wipe()
+        }
+        let childKey = try Secp256k1.addTweak(key, Array(i[0..<32]))
+        return HDNode(key: childKey, chainCode: Array(i[32..<64]))
+    }
+
+    /// "m/44'/60'/0'/0/5"
+    func derive(_ path: String) throws -> HDNode {
+        let parts = path.split(separator: "/")
+        guard parts.first == "m" else { throw WalletError(.internal, "invalid path") }
+        var node = self
+        for p in parts.dropFirst() {
+            let hard = p.hasSuffix("'")
+            guard let n = UInt32(hard ? p.dropLast() : p), n < HDNode.hardened else { throw WalletError(.internal, "invalid path") }
+            let next = try node.child(hard ? n + HDNode.hardened : n)
+            node.wipe()
+            node = next
+        }
+        return node
+    }
+
+    mutating func wipe() {
+        key.wipe()
+        chainCode.wipe()
+    }
+
+    private static func hmac(key: [UInt8], data: [UInt8]) -> [UInt8] {
+        Array(HMAC<SHA512>.authenticationCode(for: data, using: SymmetricKey(data: key)))
+    }
+}

package/ios/vendor/AuthonWallet/Crypto/Secp256k1.swift

@@ -0,0 +1,128 @@
+// GENERATED by scripts/sync-native-wallet.mjs from swift/Sources/AuthonWallet/Crypto/Secp256k1.swift. Do not edit: change the source and run the script.
+#if canImport(CKeccak)
+import CKeccak
+#endif
+#if canImport(CSecp256k1)
+import CSecp256k1
+#endif
+import Foundation
+
+enum Keccak {
+    static func hash256(_ data: [UInt8]) -> [UInt8] {
+        var out = [UInt8](repeating: 0, count: 32)
+        data.withUnsafeBufferPointer { input in
+            out.withUnsafeMutableBufferPointer { keccak_256(input.baseAddress, input.count, $0.baseAddress) }
+        }
+        return out
+    }
+}
+
+/// libsecp256k1 (bitcoin-core) wrapper. All curve arithmetic happens in the vendored C library.
+enum Secp256k1 {
+    struct RecoverableSignature {
+        var r: [UInt8]
+        var s: [UInt8]
+        /// 0 or 1.
+        var recoveryId: Int
+    }
+
+    private static let context: OpaquePointer = {
+        let ctx = secp256k1_context_create(UInt32(SECP256K1_CONTEXT_NONE))!
+        // Side-channel blinding of the signing context, as the library recommends.
+        if var seed = try? Bytes.random(32) {
+            _ = secp256k1_context_randomize(ctx, seed)
+            seed.wipe()
+        }
+        return ctx
+    }()
+    private static let lock = NSLock()
+
+    private static func withContext<T>(_ body: (OpaquePointer) throws -> T) rethrows -> T {
+        lock.lock()
+        defer { lock.unlock() }
+        return try body(context)
+    }
+
+    static func isValidPrivateKey(_ key: [UInt8]) -> Bool {
+        key.count == 32 && withContext { secp256k1_ec_seckey_verify($0, key) == 1 }
+    }
+
+    /// Public key, 65-byte uncompressed (0x04 || x || y) or 33-byte compressed.
+    static func publicKey(of key: [UInt8], compressed: Bool) throws -> [UInt8] {
+        guard key.count == 32 else { throw WalletError(.internal, "invalid private key") }
+        return try withContext { ctx in
+            var pub = secp256k1_pubkey()
+            guard secp256k1_ec_pubkey_create(ctx, &pub, key) == 1 else { throw WalletError(.internal, "invalid private key") }
+            var out = [UInt8](repeating: 0, count: compressed ? 33 : 65)
+            var len = out.count
+            let flags = UInt32(compressed ? SECP256K1_EC_COMPRESSED : SECP256K1_EC_UNCOMPRESSED)
+            guard secp256k1_ec_pubkey_serialize(ctx, &out, &len, &pub, flags) == 1 else { throw WalletError(.internal) }
+            return Array(out[0..<len])
+        }
+    }
+
+    /// (key + tweak) mod n, for BIP32 child keys. Fails when tweak >= n or the result is zero.
+    static func addTweak(_ key: [UInt8], _ tweak: [UInt8]) throws -> [UInt8] {
+        var out = key
+        let ok = withContext { secp256k1_ec_seckey_tweak_add($0, &out, tweak) == 1 }
+        guard ok else {
+            out.wipe()
+            throw WalletError(.internal, "invalid child key")
+        }
+        return out
+    }
+
+    /// RFC 6979 deterministic, low-s ECDSA over a 32-byte hash.
+    static func sign(hash: [UInt8], key: [UInt8]) throws -> RecoverableSignature {
+        guard hash.count == 32, key.count == 32 else { throw WalletError(.internal, "invalid signing input") }
+        return try withContext { ctx in
+            var sig = secp256k1_ecdsa_recoverable_signature()
+            guard secp256k1_ecdsa_sign_recoverable(ctx, &sig, hash, key, nil, nil) == 1 else {
+                throw WalletError(.internal, "signing failed")
+            }
+            var compact = [UInt8](repeating: 0, count: 64)
+            var recid: Int32 = 0
+            secp256k1_ecdsa_recoverable_signature_serialize_compact(ctx, &compact, &recid, &sig)
+            return RecoverableSignature(r: Array(compact[0..<32]), s: Array(compact[32..<64]), recoveryId: Int(recid))
+        }
+    }
+
+    /// RFC 6979 deterministic, low-s ECDSA over a 32-byte hash, DER-encoded.
+    static func signDER(hash: [UInt8], key: [UInt8]) throws -> [UInt8] {
+        guard hash.count == 32, key.count == 32 else { throw WalletError(.internal, "invalid signing input") }
+        return try withContext { ctx in
+            var sig = secp256k1_ecdsa_signature()
+            guard secp256k1_ecdsa_sign(ctx, &sig, hash, key, nil, nil) == 1 else { throw WalletError(.internal, "signing failed") }
+            var out = [UInt8](repeating: 0, count: 72)
+            var len = out.count
+            guard secp256k1_ecdsa_signature_serialize_der(ctx, &out, &len, &sig) == 1 else { throw WalletError(.internal, "signing failed") }
+            return Array(out[0..<len])
+        }
+    }
+
+    /// Verifies a DER signature (tests and self-checks).
+    static func verifyDER(_ der: [UInt8], hash: [UInt8], publicKey: [UInt8]) -> Bool {
+        withContext { ctx in
+            var sig = secp256k1_ecdsa_signature()
+            var pub = secp256k1_pubkey()
+            guard secp256k1_ecdsa_signature_parse_der(ctx, &sig, der, der.count) == 1,
+                  secp256k1_ec_pubkey_parse(ctx, &pub, publicKey, publicKey.count) == 1 else { return false }
+            return secp256k1_ecdsa_verify(ctx, &sig, hash, &pub) == 1
+        }
+    }
+
+    /// Recovers the uncompressed public key of a signature (used to verify proofs in tests and checks).
+    static func recover(hash: [UInt8], r: [UInt8], s: [UInt8], recoveryId: Int) -> [UInt8]? {
+        guard hash.count == 32, r.count == 32, s.count == 32, (0...3).contains(recoveryId) else { return nil }
+        return withContext { ctx in
+            var sig = secp256k1_ecdsa_recoverable_signature()
+            guard secp256k1_ecdsa_recoverable_signature_parse_compact(ctx, &sig, r + s, Int32(recoveryId)) == 1 else { return nil }
+            var pub = secp256k1_pubkey()
+            guard secp256k1_ecdsa_recover(ctx, &pub, &sig, hash) == 1 else { return nil }
+            var out = [UInt8](repeating: 0, count: 65)
+            var len = 65
+            secp256k1_ec_pubkey_serialize(ctx, &out, &len, &pub, UInt32(SECP256K1_EC_UNCOMPRESSED))
+            return out
+        }
+    }
+}

package/ios/vendor/AuthonWallet/Crypto/Shamir.swift

@@ -0,0 +1,123 @@
+// GENERATED by scripts/sync-native-wallet.mjs from swift/Sources/AuthonWallet/Crypto/Shamir.swift. Do not edit: change the source and run the script.
+import Foundation
+
+/// Shamir secret sharing over GF(2^8), byte-compatible with the `shamir-secret-sharing`
+/// 0.0.4 package the web frame uses: polynomial x^8+x^4+x^3+x+1, generator 0xe5, and each
+/// share is the y bytes followed by its x coordinate. Tables are copied from that package
+/// (originally hashicorp/vault shamir/tables.go).
+enum Shamir {
+    private static let logTable: [UInt8] = [
+        0x00, 0xff, 0xc8, 0x08, 0x91, 0x10, 0xd0, 0x36, 0x5a, 0x3e, 0xd8, 0x43, 0x99, 0x77, 0xfe, 0x18,
+        0x23, 0x20, 0x07, 0x70, 0xa1, 0x6c, 0x0c, 0x7f, 0x62, 0x8b, 0x40, 0x46, 0xc7, 0x4b, 0xe0, 0x0e,
+        0xeb, 0x16, 0xe8, 0xad, 0xcf, 0xcd, 0x39, 0x53, 0x6a, 0x27, 0x35, 0x93, 0xd4, 0x4e, 0x48, 0xc3,
+        0x2b, 0x79, 0x54, 0x28, 0x09, 0x78, 0x0f, 0x21, 0x90, 0x87, 0x14, 0x2a, 0xa9, 0x9c, 0xd6, 0x74,
+        0xb4, 0x7c, 0xde, 0xed, 0xb1, 0x86, 0x76, 0xa4, 0x98, 0xe2, 0x96, 0x8f, 0x02, 0x32, 0x1c, 0xc1,
+        0x33, 0xee, 0xef, 0x81, 0xfd, 0x30, 0x5c, 0x13, 0x9d, 0x29, 0x17, 0xc4, 0x11, 0x44, 0x8c, 0x80,
+        0xf3, 0x73, 0x42, 0x1e, 0x1d, 0xb5, 0xf0, 0x12, 0xd1, 0x5b, 0x41, 0xa2, 0xd7, 0x2c, 0xe9, 0xd5,
+        0x59, 0xcb, 0x50, 0xa8, 0xdc, 0xfc, 0xf2, 0x56, 0x72, 0xa6, 0x65, 0x2f, 0x9f, 0x9b, 0x3d, 0xba,
+        0x7d, 0xc2, 0x45, 0x82, 0xa7, 0x57, 0xb6, 0xa3, 0x7a, 0x75, 0x4f, 0xae, 0x3f, 0x37, 0x6d, 0x47,
+        0x61, 0xbe, 0xab, 0xd3, 0x5f, 0xb0, 0x58, 0xaf, 0xca, 0x5e, 0xfa, 0x85, 0xe4, 0x4d, 0x8a, 0x05,
+        0xfb, 0x60, 0xb7, 0x7b, 0xb8, 0x26, 0x4a, 0x67, 0xc6, 0x1a, 0xf8, 0x69, 0x25, 0xb3, 0xdb, 0xbd,
+        0x66, 0xdd, 0xf1, 0xd2, 0xdf, 0x03, 0x8d, 0x34, 0xd9, 0x92, 0x0d, 0x63, 0x55, 0xaa, 0x49, 0xec,
+        0xbc, 0x95, 0x3c, 0x84, 0x0b, 0xf5, 0xe6, 0xe7, 0xe5, 0xac, 0x7e, 0x6e, 0xb9, 0xf9, 0xda, 0x8e,
+        0x9a, 0xc9, 0x24, 0xe1, 0x0a, 0x15, 0x6b, 0x3a, 0xa0, 0x51, 0xf4, 0xea, 0xb2, 0x97, 0x9e, 0x5d,
+        0x22, 0x88, 0x94, 0xce, 0x19, 0x01, 0x71, 0x4c, 0xa5, 0xe3, 0xc5, 0x31, 0xbb, 0xcc, 0x1f, 0x2d,
+        0x3b, 0x52, 0x6f, 0xf6, 0x2e, 0x89, 0xf7, 0xc0, 0x68, 0x1b, 0x64, 0x04, 0x06, 0xbf, 0x83, 0x38,
+    ]
+
+    private static let expTable: [UInt8] = [
+        0x01, 0xe5, 0x4c, 0xb5, 0xfb, 0x9f, 0xfc, 0x12, 0x03, 0x34, 0xd4, 0xc4, 0x16, 0xba, 0x1f, 0x36,
+        0x05, 0x5c, 0x67, 0x57, 0x3a, 0xd5, 0x21, 0x5a, 0x0f, 0xe4, 0xa9, 0xf9, 0x4e, 0x64, 0x63, 0xee,
+        0x11, 0x37, 0xe0, 0x10, 0xd2, 0xac, 0xa5, 0x29, 0x33, 0x59, 0x3b, 0x30, 0x6d, 0xef, 0xf4, 0x7b,
+        0x55, 0xeb, 0x4d, 0x50, 0xb7, 0x2a, 0x07, 0x8d, 0xff, 0x26, 0xd7, 0xf0, 0xc2, 0x7e, 0x09, 0x8c,
+        0x1a, 0x6a, 0x62, 0x0b, 0x5d, 0x82, 0x1b, 0x8f, 0x2e, 0xbe, 0xa6, 0x1d, 0xe7, 0x9d, 0x2d, 0x8a,
+        0x72, 0xd9, 0xf1, 0x27, 0x32, 0xbc, 0x77, 0x85, 0x96, 0x70, 0x08, 0x69, 0x56, 0xdf, 0x99, 0x94,
+        0xa1, 0x90, 0x18, 0xbb, 0xfa, 0x7a, 0xb0, 0xa7, 0xf8, 0xab, 0x28, 0xd6, 0x15, 0x8e, 0xcb, 0xf2,
+        0x13, 0xe6, 0x78, 0x61, 0x3f, 0x89, 0x46, 0x0d, 0x35, 0x31, 0x88, 0xa3, 0x41, 0x80, 0xca, 0x17,
+        0x5f, 0x53, 0x83, 0xfe, 0xc3, 0x9b, 0x45, 0x39, 0xe1, 0xf5, 0x9e, 0x19, 0x5e, 0xb6, 0xcf, 0x4b,
+        0x38, 0x04, 0xb9, 0x2b, 0xe2, 0xc1, 0x4a, 0xdd, 0x48, 0x0c, 0xd0, 0x7d, 0x3d, 0x58, 0xde, 0x7c,
+        0xd8, 0x14, 0x6b, 0x87, 0x47, 0xe8, 0x79, 0x84, 0x73, 0x3c, 0xbd, 0x92, 0xc9, 0x23, 0x8b, 0x97,
+        0x95, 0x44, 0xdc, 0xad, 0x40, 0x65, 0x86, 0xa2, 0xa4, 0xcc, 0x7f, 0xec, 0xc0, 0xaf, 0x91, 0xfd,
+        0xf7, 0x4f, 0x81, 0x2f, 0x5b, 0xea, 0xa8, 0x1c, 0x02, 0xd1, 0x98, 0x71, 0xed, 0x25, 0xe3, 0x24,
+        0x06, 0x68, 0xb3, 0x93, 0x2c, 0x6f, 0x3e, 0x6c, 0x0a, 0xb8, 0xce, 0xae, 0x74, 0xb1, 0x42, 0xb4,
+        0x1e, 0xd3, 0x49, 0xe9, 0x9c, 0xc8, 0xc6, 0xc7, 0x22, 0x6e, 0xdb, 0x20, 0xbf, 0x43, 0x51, 0x52,
+        0x66, 0xb2, 0x76, 0x60, 0xda, 0xc5, 0xf3, 0xf6, 0xaa, 0xcd, 0x9a, 0xa0, 0x75, 0x54, 0x0e, 0x01,
+    ]
+
+    private static func div(_ a: UInt8, _ b: UInt8) throws -> UInt8 {
+        guard b != 0 else { throw WalletError(.internal, "cannot divide by zero") }
+        if a == 0 { return 0 }
+        let diff = (Int(logTable[Int(a)]) - Int(logTable[Int(b)]) + 255) % 255
+        return expTable[diff]
+    }
+
+    private static func mult(_ a: UInt8, _ b: UInt8) -> UInt8 {
+        if a == 0 || b == 0 { return 0 }
+        return expTable[(Int(logTable[Int(a)]) + Int(logTable[Int(b)])) % 255]
+    }
+
+    private static func interpolate(_ xs: [UInt8], _ ys: [UInt8], at x: UInt8) throws -> UInt8 {
+        var result: UInt8 = 0
+        for i in 0..<xs.count {
+            var basis: UInt8 = 1
+            for j in 0..<xs.count where i != j {
+                basis = mult(basis, try div(x ^ xs[j], xs[i] ^ xs[j]))
+            }
+            result ^= mult(ys[i], basis)
+        }
+        return result
+    }
+
+    private static func evaluate(_ coefficients: [UInt8], at x: UInt8) -> UInt8 {
+        var result = coefficients[coefficients.count - 1]
+        for c in coefficients.dropLast().reversed() { result = mult(result, x) ^ c }
+        return result
+    }
+
+    /// Same shuffle as the package's newCoordinates() (a permutation of 1...255).
+    private static func newCoordinates() throws -> [UInt8] {
+        var coordinates = (0..<255).map { UInt8($0 + 1) }
+        let randomIndices = try Bytes.random(255)
+        for i in 0..<255 {
+            let j = Int(randomIndices[i]) % 255
+            coordinates.swapAt(i, j)
+        }
+        return coordinates
+    }
+
+    static func split(_ secret: [UInt8], shares: Int, threshold: Int) throws -> [[UInt8]] {
+        guard !secret.isEmpty, (2...255).contains(shares), (2...255).contains(threshold), shares >= threshold else {
+            throw WalletError(.internal, "invalid split parameters")
+        }
+        let xs = try newCoordinates()
+        var result = (0..<shares).map { i -> [UInt8] in
+            var share = [UInt8](repeating: 0, count: secret.count + 1)
+            share[secret.count] = xs[i]
+            return share
+        }
+        for i in 0..<secret.count {
+            var coefficients = [secret[i]] + (try Bytes.random(threshold - 1))
+            for j in 0..<shares { result[j][i] = evaluate(coefficients, at: xs[j]) }
+            coefficients.wipe()
+        }
+        return result
+    }
+
+    static func combine(_ shares: [[UInt8]]) throws -> [UInt8] {
+        guard (2...255).contains(shares.count) else { throw WalletError(.internal, "need at least 2 shares") }
+        let length = shares[0].count
+        guard length >= 2, shares.allSatisfy({ $0.count == length }) else {
+            throw WalletError(.internal, "all shares must have the same byte length")
+        }
+        let xs = shares.map { $0[length - 1] }
+        guard Set(xs).count == xs.count else { throw WalletError(.internal, "duplicate share") }
+        var secret = [UInt8](repeating: 0, count: length - 1)
+        var ys = [UInt8](repeating: 0, count: shares.count)
+        defer { ys.wipe() }
+        for i in 0..<(length - 1) {
+            for j in 0..<shares.count { ys[j] = shares[j][i] }
+            secret[i] = try interpolate(xs, ys, at: 0)
+        }
+        return secret
+    }
+}

package/ios/vendor/AuthonWallet/EVM/Address.swift

@@ -0,0 +1,57 @@
+// GENERATED by scripts/sync-native-wallet.mjs from swift/Sources/AuthonWallet/EVM/Address.swift. Do not edit: change the source and run the script.
+import Foundation
+
+enum EvmAddress {
+    /// Address of an uncompressed secp256k1 public key (0x04 || x || y), EIP-55 checksummed.
+    static func of(publicKey: [UInt8]) -> String {
+        let hash = Keccak.hash256(Array(publicKey.dropFirst()))
+        return checksum(Bytes.hex(Array(hash[12..<32])))
+    }
+
+    static func of(privateKey: [UInt8]) throws -> String {
+        of(publicKey: try Secp256k1.publicKey(of: privateKey, compressed: false))
+    }
+
+    /// EIP-55 for 40 hex digits (no prefix, any case). Same result as viem getAddress.
+    static func checksum(_ hex40: String) -> String {
+        let lower = hex40.lowercased()
+        let hash = Keccak.hash256(Array(lower.utf8))
+        var out = "0x"
+        for (i, c) in lower.enumerated() {
+            let nibble = (hash[i / 2] >> (i % 2 == 0 ? 4 : 0)) & 0x0f
+            out.append(c.isLetter && nibble >= 8 ? Character(c.uppercased()) : c)
+        }
+        return out
+    }
+
+    /// viem isAddress: 0x + 40 hex digits; with `strict`, mixed case must be a valid checksum.
+    static func isAddress(_ value: String, strict: Bool = true) -> Bool {
+        guard value.count == 42, value.hasPrefix("0x"), Bytes.isHex(value) else { return false }
+        let body = String(value.dropFirst(2))
+        if !strict || body == body.lowercased() || body == body.uppercased() { return true }
+        return checksum(body) == value
+    }
+
+    static func bytes(_ value: String) -> [UInt8]? {
+        guard value.count == 42, value.hasPrefix("0x") else { return nil }
+        return Bytes.fromHex(value)
+    }
+
+    /// viem getAddress for display; anything else is shown as given.
+    static func display(_ value: JSONValue?) -> String {
+        if case .string(let s) = value, isAddress(s, strict: false) { return checksum(String(s.dropFirst(2))) }
+        return value.map(jsString) ?? "undefined"
+    }
+
+    /// JavaScript String(value) for the cases the summaries print.
+    static func jsString(_ value: JSONValue) -> String {
+        switch value {
+        case .null: return "null"
+        case .bool(let b): return b ? "true" : "false"
+        case .number(let n): return n
+        case .string(let s): return s
+        case .array(let a): return a.map(jsString).joined(separator: ",")
+        case .object: return "[object Object]"
+        }
+    }
+}

package/ios/vendor/AuthonWallet/EVM/EvmAccount.swift

@@ -0,0 +1,48 @@
+// GENERATED by scripts/sync-native-wallet.mjs from swift/Sources/AuthonWallet/EVM/EvmAccount.swift. Do not edit: change the source and run the script.
+import Foundation
+
+/// A secp256k1 key in memory for the duration of one operation. Call `wipe()` when done.
+final class EvmAccount {
+    private var key: [UInt8]
+    let address: String
+
+    init(privateKey: [UInt8]) throws {
+        key = privateKey
+        address = try EvmAddress.of(privateKey: privateKey)
+    }
+
+    deinit { key.wipe() }
+
+    func wipe() { key.wipe() }
+
+    /// r || s || v with v = 27/28 (viem serializeSignature).
+    private func signHash(_ hash: [UInt8]) throws -> String {
+        let sig = try Secp256k1.sign(hash: hash, key: key)
+        return Bytes.hex(sig.r + sig.s + [UInt8(27 + sig.recoveryId)], prefix: true)
+    }
+
+    enum Message {
+        case text(String)
+        case raw([UInt8])
+    }
+
+    static func hashMessage(_ message: Message) -> [UInt8] {
+        let body: [UInt8]
+        switch message {
+        case .text(let s): body = Array(s.utf8)
+        case .raw(let b): body = b
+        }
+        return Keccak.hash256(Array("\u{19}Ethereum Signed Message:\n\(body.count)".utf8) + body)
+    }
+
+    /// EIP-191 personal_sign.
+    func signMessage(_ message: Message) throws -> String { try signHash(EvmAccount.hashMessage(message)) }
+
+    func signTypedData(_ typedData: TypedData) throws -> String { try signHash(try typedData.digest()) }
+
+    /// Serialized signed transaction (0x-prefixed), as viem's account.signTransaction.
+    func signTransaction(_ tx: EvmTransaction) throws -> String {
+        let sig = try Secp256k1.sign(hash: Keccak.hash256(tx.serialized()), key: key)
+        return Bytes.hex(tx.serialized(signature: sig), prefix: true)
+    }
+}

package/ios/vendor/AuthonWallet/EVM/Transaction.swift

@@ -0,0 +1,165 @@
+// GENERATED by scripts/sync-native-wallet.mjs from swift/Sources/AuthonWallet/EVM/Transaction.swift. Do not edit: change the source and run the script.
+import Foundation
+
+indirect enum RLPItem {
+    case bytes([UInt8])
+    case list([RLPItem])
+
+    func encoded() -> [UInt8] {
+        switch self {
+        case .bytes(let b):
+            if b.count == 1, b[0] < 0x80 { return b }
+            return RLPItem.header(b.count, offset: 0x80) + b
+        case .list(let items):
+            let body = items.flatMap { $0.encoded() }
+            return RLPItem.header(body.count, offset: 0xc0) + body
+        }
+    }
+
+    private static func header(_ length: Int, offset: UInt8) -> [UInt8] {
+        if length < 56 { return [offset + UInt8(length)] }
+        let len = BigUInt(UInt64(length)).bytes
+        return [offset + 55 + UInt8(len.count)] + len
+    }
+}
+
+/// An EVM transaction as viem serializes it (legacy with EIP-155, EIP-2930, EIP-1559).
+struct EvmTransaction {
+    enum Kind: String { case legacy, eip2930, eip1559 }
+
+    struct AccessEntry {
+        var address: [UInt8]
+        var storageKeys: [[UInt8]]
+    }
+
+    var kind: Kind
+    var chainId: BigUInt
+    var nonce: BigUInt
+    var gas: BigUInt?
+    var gasPrice: BigUInt?
+    var maxFeePerGas: BigUInt?
+    var maxPriorityFeePerGas: BigUInt?
+    var to: [UInt8]?
+    var value: BigUInt?
+    var data: [UInt8]
+    var accessList: [AccessEntry]
+
+    private static let maxUint256 = BigUInt.power2(256) - BigUInt(1)
+
+    /// From the parsed request (see WalletOps.parseTransaction): numeric fields are already integers.
+    init(_ tx: JSONObject) throws {
+        func bad(_ m: String) -> WalletError { WalletError(.invalidRequest, m) }
+        func uint(_ name: String) throws -> BigUInt? {
+            guard let v = tx[name], v != .null else { return nil }
+            guard let n = v.jsBigInt, !n.negative else { throw bad("\(name) must be a non-negative integer") }
+            return n.magnitude
+        }
+        let maxFee = try uint("maxFeePerGas")
+        let maxPriority = try uint("maxPriorityFeePerGas")
+        let price = try uint("gasPrice")
+        let typeName: String
+        if let t = tx["type"], t.isTruthy {
+            guard case .string(let s) = t else { throw bad("unsupported transaction type") }
+            typeName = s
+        } else if tx["authorizationList"] != nil || tx["blobs"] != nil || tx["blobVersionedHashes"] != nil || tx["maxFeePerBlobGas"] != nil || tx["sidecars"] != nil {
+            throw bad("blob and EIP-7702 transactions are not supported")
+        } else if maxFee != nil || maxPriority != nil {
+            typeName = "eip1559"
+        } else if price != nil {
+            typeName = tx["accessList"] != nil ? "eip2930" : "legacy"
+        } else {
+            throw bad("cannot infer the transaction type")
+        }
+        if typeName == "eip4844" || typeName == "eip7702" { throw bad("blob and EIP-7702 transactions are not supported") }
+        // viem serializes any other type name as a legacy transaction.
+        kind = Kind(rawValue: typeName) ?? .legacy
+
+        guard let chain = try uint("chainId") else { throw bad("chainId required") }
+        chainId = chain
+        nonce = try uint("nonce") ?? BigUInt()
+        gas = try uint("gas")
+        gasPrice = price
+        maxFeePerGas = maxFee
+        maxPriorityFeePerGas = maxPriority
+        value = try uint("value")
+
+        if let t = tx["to"], t.isTruthy {
+            guard case .string(let s) = t, EvmAddress.isAddress(s), let b = EvmAddress.bytes(s) else { throw bad("invalid to address") }
+            to = b
+        } else {
+            to = nil
+        }
+        if let d = tx["data"], d != .null {
+            guard case .string(let s) = d, Bytes.isHex(s), let b = Bytes.fromHex(s) else { throw bad("data must be hex") }
+            data = b
+        } else {
+            data = []
+        }
+        var list = [AccessEntry]()
+        if kind != .legacy, let raw = tx["accessList"], raw != .null {
+            guard let entries = raw.arrayValue else { throw bad("accessList must be an array") }
+            for e in entries {
+                guard case .string(let a) = e["address"] ?? .null, EvmAddress.isAddress(a, strict: false), let ab = EvmAddress.bytes(a),
+                      let keys = e["storageKeys"]?.arrayValue else { throw bad("invalid accessList entry") }
+                var sk = [[UInt8]]()
+                for k in keys {
+                    guard case .string(let ks) = k, ks.count == 66, Bytes.isHex(ks), let kb = Bytes.fromHex(ks) else {
+                        throw bad("storage keys must be 32 bytes")
+                    }
+                    sk.append(kb)
+                }
+                list.append(AccessEntry(address: ab, storageKeys: sk))
+            }
+        }
+        accessList = list
+
+        switch kind {
+        case .eip1559:
+            guard !chainId.isZero else { throw bad("invalid chainId") }
+            if let f = maxFeePerGas, f > EvmTransaction.maxUint256 { throw bad("maxFeePerGas too high") }
+            if let p = maxPriorityFeePerGas, let f = maxFeePerGas, !p.isZero, !f.isZero, p > f { throw bad("maxPriorityFeePerGas above maxFeePerGas") }
+        case .eip2930:
+            guard !chainId.isZero else { throw bad("invalid chainId") }
+            if maxFeePerGas?.isZero == false || maxPriorityFeePerGas?.isZero == false { throw bad("maxFeePerGas is not an EIP-2930 field") }
+            if let p = gasPrice, p > EvmTransaction.maxUint256 { throw bad("gasPrice too high") }
+        case .legacy:
+            guard !chainId.isZero else { throw bad("invalid chainId") }
+            if maxFeePerGas?.isZero == false || maxPriorityFeePerGas?.isZero == false { throw bad("maxFeePerGas is not a legacy field") }
+            if let p = gasPrice, p > EvmTransaction.maxUint256 { throw bad("gasPrice too high") }
+        }
+    }
+
+    private func num(_ v: BigUInt?) -> RLPItem { .bytes(v?.bytes ?? []) }
+
+    private var accessListItem: RLPItem {
+        .list(accessList.map { .list([.bytes($0.address), .list($0.storageKeys.map { .bytes($0) })]) })
+    }
+
+    /// viem serializeTransaction(tx, signature?).
+    func serialized(signature: Secp256k1.RecoverableSignature? = nil) -> [UInt8] {
+        let trim: ([UInt8]) -> [UInt8] = { BigUInt(bytes: $0).bytes }
+        switch kind {
+        case .legacy:
+            var fields: [RLPItem] = [num(nonce), num(gasPrice), num(gas), .bytes(to ?? []), num(value), .bytes(data)]
+            if let sig = signature {
+                let v = chainId * BigUInt(2) + BigUInt(UInt64(35 + sig.recoveryId))
+                fields += [num(v), .bytes(trim(sig.r)), .bytes(trim(sig.s))]
+            } else {
+                fields += [num(chainId), .bytes([]), .bytes([])]
+            }
+            return RLPItem.list(fields).encoded()
+        case .eip2930, .eip1559:
+            var fields: [RLPItem] = [num(chainId), num(nonce)]
+            if kind == .eip1559 {
+                fields += [num(maxPriorityFeePerGas), num(maxFeePerGas)]
+            } else {
+                fields += [num(gasPrice)]
+            }
+            fields += [num(gas), .bytes(to ?? []), num(value), .bytes(data), accessListItem]
+            if let sig = signature {
+                fields += [.bytes(sig.recoveryId == 1 ? [1] : []), .bytes(trim(sig.r)), .bytes(trim(sig.s))]
+            }
+            return [kind == .eip1559 ? 0x02 : 0x01] + RLPItem.list(fields).encoded()
+        }
+    }
+}