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

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

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

@@ -0,0 +1,193 @@
+// GENERATED by scripts/sync-native-wallet.mjs from swift/Sources/AuthonWallet/EVM/TypedData.swift. Do not edit: change the source and run the script.
+import Foundation
+
+/// EIP-712 v4 hashing with viem's rules (hashTypedData + validateTypedData).
+struct TypedData {
+    struct Field {
+        var name: String
+        var type: String
+    }
+
+    var domain: JSONObject
+    var types: [String: [Field]]
+    var primaryType: String
+    var message: JSONValue
+
+    private static func bad(_ m: String) -> WalletError { WalletError(.invalidRequest, m) }
+
+    init(_ value: JSONValue) throws {
+        guard let obj = value.objectValue else { throw TypedData.bad("typedData must be an object") }
+        let domainValue = obj["domain"] ?? .null
+        if domainValue == .null {
+            domain = JSONObject()
+        } else {
+            guard let d = domainValue.objectValue else { throw TypedData.bad("domain must be an object") }
+            domain = d
+        }
+        guard case .string(let primary) = obj["primaryType"] ?? .null else { throw TypedData.bad("primaryType must be a string") }
+        primaryType = primary
+        message = obj["message"] ?? .null
+        guard let rawTypes = obj["types"]?.objectValue else { throw TypedData.bad("types must be an object") }
+        var parsed = [String: [Field]]()
+        parsed["EIP712Domain"] = TypedData.domainFields(domain)
+        for (name, list) in rawTypes.entries {
+            guard let arr = list.arrayValue else { throw TypedData.bad("types.\(name) must be an array") }
+            parsed[name] = try arr.map { f in
+                guard case .string(let n) = f["name"] ?? .null, case .string(let t) = f["type"] ?? .null else {
+                    throw TypedData.bad("invalid field in \(name)")
+                }
+                return Field(name: n, type: t)
+            }
+        }
+        types = parsed
+    }
+
+    /// getTypesForEIP712Domain: chainId only when it is a number, the others when truthy.
+    private static func domainFields(_ d: JSONObject) -> [Field] {
+        var out = [Field]()
+        if case .string = d["name"] ?? .null { out.append(Field(name: "name", type: "string")) }
+        if d["version"]?.isTruthy == true { out.append(Field(name: "version", type: "string")) }
+        if case .number = d["chainId"] ?? .null { out.append(Field(name: "chainId", type: "uint256")) }
+        if d["verifyingContract"]?.isTruthy == true { out.append(Field(name: "verifyingContract", type: "address")) }
+        if d["salt"]?.isTruthy == true { out.append(Field(name: "salt", type: "bytes32")) }
+        return out
+    }
+
+    func digest() throws -> [UInt8] {
+        try validate()
+        var parts: [UInt8] = [0x19, 0x01]
+        parts += try hashStruct("EIP712Domain", .object(domain))
+        if primaryType != "EIP712Domain" { parts += try hashStruct(primaryType, message) }
+        return Keccak.hash256(parts)
+    }
+
+    // MARK: - Validation (validateTypedData)
+
+    private func validate() throws {
+        func validateData(_ fields: [Field], _ data: JSONValue) throws {
+            for f in fields {
+                let value = data[f.name]
+                let base = f.type.replacingOccurrences(of: #"(\[[0-9]*\])+$"#, with: "", options: .regularExpression)
+                if base == "int" || base == "uint" { throw TypedData.bad("invalid type \(f.type)") }
+                if let (signed, bits) = TypedData.integerType(f.type), let v = value, case .number = v {
+                    guard let n = v.jsBigInt, n.fits(bits: bits, signed: signed) else { throw TypedData.bad("\(f.name) out of range") }
+                }
+                if f.type == "address", case .string(let s) = value ?? .null, !EvmAddress.isAddress(s) {
+                    throw TypedData.bad("invalid address \(s)")
+                }
+                if let size = TypedData.fixedBytesSize(f.type), size > 0 {
+                    guard case .string(let s) = value ?? .null, let b = Bytes.fromHex(s), Bytes.isHex(s), b.count == size else {
+                        throw TypedData.bad("\(f.name) must be \(size) bytes")
+                    }
+                }
+                if let nested = types[f.type] {
+                    guard let v = value else { throw TypedData.bad("missing \(f.name)") }
+                    try validateData(nested, v)
+                }
+            }
+        }
+        if let d = types["EIP712Domain"] { try validateData(d, .object(domain)) }
+        if primaryType != "EIP712Domain" {
+            guard let fields = types[primaryType] else { throw TypedData.bad("unknown primaryType \(primaryType)") }
+            try validateData(fields, message)
+        }
+    }
+
+    /// uint8..uint256 / int8..int256 in steps of 8.
+    static func integerType(_ type: String) -> (Bool, Int)? {
+        let signed = type.hasPrefix("int")
+        guard signed || type.hasPrefix("uint") else { return nil }
+        let digits = type.dropFirst(signed ? 3 : 4)
+        guard let bits = Int(digits), String(bits) == digits, bits >= 8, bits <= 256, bits % 8 == 0 else { return nil }
+        return (signed, bits)
+    }
+
+    /// bytes1..bytes32 (0 for dynamic `bytes`, nil otherwise).
+    static func fixedBytesSize(_ type: String) -> Int? {
+        guard type.hasPrefix("bytes") else { return nil }
+        let digits = type.dropFirst(5)
+        if digits.isEmpty { return 0 }
+        guard let n = Int(digits), String(n) == digits, n >= 1, n <= 32 else { return nil }
+        return n
+    }
+
+    // MARK: - Encoding
+
+    func encodeType(_ primary: String) -> String {
+        var deps = Set<String>()
+        findDependencies(primary, &deps)
+        deps.remove(primary)
+        let sorted = deps.sorted { $0.utf16.lexicographicallyPrecedes($1.utf16) }
+        return ([primary] + sorted).map { t in
+            "\(t)(" + (types[t] ?? []).map { "\($0.type) \($0.name)" }.joined(separator: ",") + ")"
+        }.joined()
+    }
+
+    private func findDependencies(_ type: String, _ results: inout Set<String>) {
+        let base = String(type.prefix { $0.isLetter || $0.isNumber || $0 == "_" })
+        guard !results.contains(base), let fields = types[base] else { return }
+        results.insert(base)
+        for f in fields { findDependencies(f.type, &results) }
+    }
+
+    func hashStruct(_ type: String, _ data: JSONValue) throws -> [UInt8] {
+        Keccak.hash256(try encodeData(type, data))
+    }
+
+    private func encodeData(_ type: String, _ data: JSONValue) throws -> [UInt8] {
+        guard let fields = types[type] else { throw TypedData.bad("unknown type \(type)") }
+        guard case .object = data else { throw TypedData.bad("\(type) value must be an object") }
+        var out = Keccak.hash256(Array(encodeType(type).utf8))
+        for f in fields { out += try encodeField(f.type, data[f.name]) }
+        return out
+    }
+
+    /// One 32-byte word per field.
+    private func encodeField(_ type: String, _ value: JSONValue?) throws -> [UInt8] {
+        if types[type] != nil {
+            guard let v = value else { throw TypedData.bad("missing \(type) value") }
+            return Keccak.hash256(try encodeData(type, v))
+        }
+        if type == "bytes" {
+            guard case .string(let s) = value ?? .null, Bytes.isHex(s), let b = Bytes.fromHex(s) else { throw TypedData.bad("bytes must be hex") }
+            return Keccak.hash256(b)
+        }
+        if type == "string" {
+            guard case .string(let s) = value ?? .null else { throw TypedData.bad("string expected") }
+            return Keccak.hash256(Array(s.utf8))
+        }
+        if type.hasSuffix("]"), let open = type.range(of: "[", options: .backwards) {
+            let inner = String(type[..<open.lowerBound])
+            guard let items = value?.arrayValue else { throw TypedData.bad("array expected for \(type)") }
+            var concat = [UInt8]()
+            for item in items { concat += try encodeField(inner, item) }
+            return Keccak.hash256(concat)
+        }
+        return try encodeAtomic(type, value)
+    }
+
+    private func encodeAtomic(_ type: String, _ value: JSONValue?) throws -> [UInt8] {
+        let v = value ?? .null
+        if type == "address" {
+            guard case .string(let s) = v, EvmAddress.isAddress(s), let b = EvmAddress.bytes(s) else { throw TypedData.bad("invalid address") }
+            return [UInt8](repeating: 0, count: 12) + b
+        }
+        if type == "bool" {
+            guard case .bool(let b) = v else { throw TypedData.bad("bool expected") }
+            return [UInt8](repeating: 0, count: 31) + [b ? 1 : 0]
+        }
+        if let (signed, bits) = TypedData.integerType(type) {
+            guard let n = v.jsBigInt, n.fits(bits: bits, signed: signed), let word = n.word() else {
+                throw TypedData.bad("\(type) value out of range")
+            }
+            return word
+        }
+        if let size = TypedData.fixedBytesSize(type), size > 0 {
+            guard case .string(let s) = v, Bytes.isHex(s), let b = Bytes.fromHex(s), b.count == size else {
+                throw TypedData.bad("\(type) size mismatch")
+            }
+            return b + [UInt8](repeating: 0, count: 32 - size)
+        }
+        throw TypedData.bad("unsupported type \(type)")
+    }
+}

package/ios/vendor/AuthonWallet/Support/BigInteger.swift

@@ -0,0 +1,220 @@
+// GENERATED by scripts/sync-native-wallet.mjs from swift/Sources/AuthonWallet/Support/BigInteger.swift. Do not edit: change the source and run the script.
+import Foundation
+
+/// Unsigned arbitrary-precision integer for amounts, gas and EIP-712 integers. Only the
+/// operations the wallet needs (parsing, printing, encoding, add/sub/mul, compare).
+struct BigUInt: Comparable, Hashable, CustomStringConvertible {
+    /// Little-endian 32-bit limbs without trailing zero limbs.
+    private(set) var limbs: [UInt32]
+
+    init(_ value: UInt64 = 0) {
+        limbs = [UInt32(truncatingIfNeeded: value), UInt32(truncatingIfNeeded: value >> 32)]
+        normalize()
+    }
+
+    init(limbs: [UInt32]) {
+        self.limbs = limbs
+        normalize()
+    }
+
+    /// Big-endian bytes.
+    init(bytes: [UInt8]) {
+        var out = [UInt32]()
+        var i = bytes.count
+        while i > 0 {
+            var limb: UInt32 = 0
+            let start = Swift.max(0, i - 4)
+            for b in bytes[start..<i] { limb = limb << 8 | UInt32(b) }
+            out.append(limb)
+            i = start
+        }
+        self.init(limbs: out)
+    }
+
+    init?(decimal text: String) {
+        guard !text.isEmpty, text.utf8.allSatisfy({ $0 >= 0x30 && $0 <= 0x39 }) else { return nil }
+        var v = BigUInt()
+        for c in text.utf8 { v = v.multiplied(by: 10).adding(UInt32(c - 0x30)) }
+        self = v
+    }
+
+    init?(hexDigits text: String) {
+        guard !text.isEmpty, !text.contains("x"), !text.contains("X"), let bytes = Bytes.fromHex(text) else { return nil }
+        self.init(bytes: bytes)
+    }
+
+    private mutating func normalize() {
+        while let last = limbs.last, last == 0 { limbs.removeLast() }
+    }
+
+    var isZero: Bool { limbs.isEmpty }
+
+    var bitWidth: Int {
+        guard let last = limbs.last else { return 0 }
+        return (limbs.count - 1) * 32 + (32 - last.leadingZeroBitCount)
+    }
+
+    /// Minimal big-endian bytes; zero is empty.
+    var bytes: [UInt8] {
+        var out = [UInt8]()
+        for limb in limbs.reversed() {
+            out += [UInt8(limb >> 24), UInt8(truncatingIfNeeded: limb >> 16), UInt8(truncatingIfNeeded: limb >> 8), UInt8(truncatingIfNeeded: limb)]
+        }
+        if let first = out.firstIndex(where: { $0 != 0 }) { return Array(out[first...]) }
+        return []
+    }
+
+    /// Big-endian, left-padded to `size` bytes; nil when it does not fit.
+    func padded(to size: Int) -> [UInt8]? {
+        let b = bytes
+        guard b.count <= size else { return nil }
+        return [UInt8](repeating: 0, count: size - b.count) + b
+    }
+
+    var uint64: UInt64? {
+        guard limbs.count <= 2 else { return nil }
+        return limbs.enumerated().reduce(UInt64(0)) { $0 | UInt64($1.element) << (32 * UInt64($1.offset)) }
+    }
+
+    static func power2(_ n: Int) -> BigUInt {
+        var l = [UInt32](repeating: 0, count: n / 32 + 1)
+        l[n / 32] = 1 << UInt32(n % 32)
+        return BigUInt(limbs: l)
+    }
+
+    func adding(_ small: UInt32) -> BigUInt { self + BigUInt(UInt64(small)) }
+
+    func multiplied(by small: UInt32) -> BigUInt { self * BigUInt(UInt64(small)) }
+
+    static func + (a: BigUInt, b: BigUInt) -> BigUInt {
+        var out = [UInt32]()
+        var carry: UInt64 = 0
+        for i in 0..<Swift.max(a.limbs.count, b.limbs.count) {
+            let s = UInt64(i < a.limbs.count ? a.limbs[i] : 0) + UInt64(i < b.limbs.count ? b.limbs[i] : 0) + carry
+            out.append(UInt32(truncatingIfNeeded: s))
+            carry = s >> 32
+        }
+        if carry > 0 { out.append(UInt32(carry)) }
+        return BigUInt(limbs: out)
+    }
+
+    /// a - b for a >= b.
+    static func - (a: BigUInt, b: BigUInt) -> BigUInt {
+        precondition(a >= b)
+        var out = [UInt32]()
+        var borrow: Int64 = 0
+        for i in 0..<a.limbs.count {
+            var d = Int64(a.limbs[i]) - Int64(i < b.limbs.count ? b.limbs[i] : 0) - borrow
+            borrow = 0
+            if d < 0 { d += 1 << 32; borrow = 1 }
+            out.append(UInt32(d))
+        }
+        return BigUInt(limbs: out)
+    }
+
+    static func * (a: BigUInt, b: BigUInt) -> BigUInt {
+        if a.isZero || b.isZero { return BigUInt() }
+        var out = [UInt32](repeating: 0, count: a.limbs.count + b.limbs.count)
+        for i in 0..<a.limbs.count {
+            var carry: UInt64 = 0
+            for j in 0..<b.limbs.count {
+                let t = UInt64(a.limbs[i]) * UInt64(b.limbs[j]) + UInt64(out[i + j]) + carry
+                out[i + j] = UInt32(truncatingIfNeeded: t)
+                carry = t >> 32
+            }
+            out[i + b.limbs.count] = UInt32(carry)
+        }
+        return BigUInt(limbs: out)
+    }
+
+    func quotientAndRemainder(dividingBy d: UInt32) -> (BigUInt, UInt32) {
+        var q = [UInt32](repeating: 0, count: limbs.count)
+        var rem: UInt64 = 0
+        for i in stride(from: limbs.count - 1, through: 0, by: -1) {
+            let cur = rem << 32 | UInt64(limbs[i])
+            q[i] = UInt32(cur / UInt64(d))
+            rem = cur % UInt64(d)
+        }
+        return (BigUInt(limbs: q), UInt32(rem))
+    }
+
+    var description: String {
+        if isZero { return "0" }
+        var parts = [String]()
+        var v = self
+        while !v.isZero {
+            let (q, r) = v.quotientAndRemainder(dividingBy: 1_000_000_000)
+            parts.append(String(r))
+            v = q
+        }
+        var out = parts.removeLast()
+        for p in parts.reversed() { out += String(repeating: "0", count: 9 - p.count) + p }
+        return out
+    }
+
+    static func < (a: BigUInt, b: BigUInt) -> Bool {
+        if a.limbs.count != b.limbs.count { return a.limbs.count < b.limbs.count }
+        for i in stride(from: a.limbs.count - 1, through: 0, by: -1) where a.limbs[i] != b.limbs[i] {
+            return a.limbs[i] < b.limbs[i]
+        }
+        return false
+    }
+}
+
+/// Signed integer with JavaScript `BigInt()` parsing semantics.
+struct BigInteger: Equatable, CustomStringConvertible {
+    var negative: Bool
+    var magnitude: BigUInt
+
+    init(_ magnitude: BigUInt, negative: Bool = false) {
+        self.magnitude = magnitude
+        self.negative = negative && !magnitude.isZero
+    }
+
+    /// `BigInt(string)`: surrounding whitespace ignored, empty is 0, 0x/0o/0b prefixes, optional sign for decimals.
+    init?(jsString raw: String) {
+        let s = raw.trimmingCharacters(in: .whitespacesAndNewlines)
+        if s.isEmpty { self.init(BigUInt()); return }
+        let lower = s.lowercased()
+        if lower.hasPrefix("0x") {
+            guard let v = BigUInt(hexDigits: String(s.dropFirst(2))) else { return nil }
+            self.init(v)
+            return
+        }
+        if lower.hasPrefix("0o") || lower.hasPrefix("0b") {
+            let radix: UInt32 = lower.hasPrefix("0o") ? 8 : 2
+            let digits = s.dropFirst(2)
+            guard !digits.isEmpty else { return nil }
+            var v = BigUInt()
+            for c in digits.utf8 {
+                let d = UInt32(c) &- 0x30
+                guard d < radix else { return nil }
+                v = v.multiplied(by: radix).adding(d)
+            }
+            self.init(v)
+            return
+        }
+        var body = Substring(s)
+        var neg = false
+        if body.hasPrefix("-") { neg = true; body = body.dropFirst() } else if body.hasPrefix("+") { body = body.dropFirst() }
+        guard let v = BigUInt(decimal: String(body)) else { return nil }
+        self.init(v, negative: neg)
+    }
+
+    var description: String { (negative ? "-" : "") + magnitude.description }
+
+    /// 32-byte two's complement.
+    func word() -> [UInt8]? {
+        if !negative { return magnitude.padded(to: 32) }
+        let mod = BigUInt.power2(256)
+        guard magnitude <= BigUInt.power2(255) else { return nil }
+        return (mod - magnitude).padded(to: 32)
+    }
+
+    /// Range check for uintN / intN.
+    func fits(bits: Int, signed: Bool) -> Bool {
+        if !signed { return !negative && magnitude.bitWidth <= bits }
+        if negative { return magnitude <= BigUInt.power2(bits - 1) }
+        return magnitude < BigUInt.power2(bits - 1)
+    }
+}