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

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

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

@@ -0,0 +1,89 @@
+// GENERATED by scripts/sync-native-wallet.mjs from swift/Sources/AuthonWallet/Support/Bytes.swift. Do not edit: change the source and run the script.
+import CryptoKit
+import Foundation
+import Security
+
+enum Bytes {
+    static func random(_ count: Int) throws -> [UInt8] {
+        var out = [UInt8](repeating: 0, count: count)
+        let status = out.withUnsafeMutableBytes { SecRandomCopyBytes(kSecRandomDefault, count, $0.baseAddress!) }
+        guard status == errSecSuccess else { throw WalletError(.internal, "random source unavailable") }
+        return out
+    }
+
+    static func sha256(_ data: [UInt8]) -> [UInt8] { Array(SHA256.hash(data: data)) }
+
+    static func wipe(_ buffers: inout [UInt8]) {
+        buffers.withUnsafeMutableBytes { raw in
+            if let base = raw.baseAddress { memset_s(base, raw.count, 0, raw.count) }
+        }
+    }
+
+    // MARK: - Hex
+
+    static func hex(_ bytes: [UInt8], prefix: Bool = false) -> String {
+        let digits = Array("0123456789abcdef".utf8)
+        var out = [UInt8]()
+        out.reserveCapacity(bytes.count * 2 + 2)
+        if prefix { out += [0x30, 0x78] }
+        for b in bytes {
+            out.append(digits[Int(b >> 4)])
+            out.append(digits[Int(b & 0x0f)])
+        }
+        return String(decoding: out, as: UTF8.self)
+    }
+
+    /// Strict hex decoding with an optional 0x prefix. An odd digit count is left-padded with 0 like viem.
+    static func fromHex(_ value: String, requirePrefix: Bool = false) -> [UInt8]? {
+        var body = Substring(value)
+        if body.hasPrefix("0x") || body.hasPrefix("0X") { body = body.dropFirst(2) } else if requirePrefix { return nil }
+        var chars = Array(body.utf8)
+        if chars.count % 2 == 1 { chars.insert(0x30, at: 0) }
+        var out = [UInt8]()
+        out.reserveCapacity(chars.count / 2)
+        var i = 0
+        while i < chars.count {
+            guard let hi = nibble(chars[i]), let lo = nibble(chars[i + 1]) else { return nil }
+            out.append(hi << 4 | lo)
+            i += 2
+        }
+        return out
+    }
+
+    static func isHex(_ value: String) -> Bool {
+        guard value.hasPrefix("0x") else { return false }
+        return value.utf8.dropFirst(2).allSatisfy { nibble($0) != nil }
+    }
+
+    private static func nibble(_ c: UInt8) -> UInt8? {
+        switch c {
+        case 0x30...0x39: return c - 0x30
+        case 0x61...0x66: return c - 0x61 + 10
+        case 0x41...0x46: return c - 0x41 + 10
+        default: return nil
+        }
+    }
+
+    // MARK: - Base64
+
+    static func base64(_ bytes: [UInt8]) -> String { Data(bytes).base64EncodedString() }
+
+    static func base64url(_ bytes: [UInt8]) -> String {
+        base64(bytes).replacingOccurrences(of: "+", with: "-").replacingOccurrences(of: "/", with: "_")
+            .replacingOccurrences(of: "=", with: "")
+    }
+
+    /// Accepts standard and URL-safe alphabets, with or without padding (like the frame's fromBase64).
+    static func fromBase64(_ value: String) -> [UInt8]? {
+        var s = value.replacingOccurrences(of: "-", with: "+").replacingOccurrences(of: "_", with: "/")
+        let rem = s.count % 4
+        if rem == 1 { return nil }
+        if rem > 0 { s += String(repeating: "=", count: 4 - rem) }
+        guard let data = Data(base64Encoded: s) else { return nil }
+        return Array(data)
+    }
+}
+
+extension Array where Element == UInt8 {
+    mutating func wipe() { Bytes.wipe(&self) }
+}