@authon/react-native-wallet 0.1.0 → 0.4.0

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

@@ -0,0 +1,191 @@
+// GENERATED by scripts/sync-native-wallet.mjs from swift/Sources/AuthonWallet/Chains/XRP.swift. Do not edit: change the source and run the script.
+import CryptoKit
+import Foundation
+
+/// XRP Ledger signing (docs/wallet/NATIVE.md section 12, `apps/wallet/src/xrp.ts`). The app sends
+/// the output of ripple-binary-codec encodeForSigning (prefix STX\0); the wallet decodes it only
+/// to describe it and signs SHA-512Half(blob) with secp256k1, DER, low S.
+enum XRP {
+    static let maxBlob = 4096
+    static let signingPrefix: [UInt8] = [0x53, 0x54, 0x58, 0x00]
+
+    struct Tx {
+        var transactionType: Int?
+        var account: String?
+        var destination: String?
+        /// Drops for XRP amounts; `.some(nil)` for issued-token amounts.
+        var amount: UInt64??
+        var fee: UInt64??
+        var sequence: Int?
+        var destinationTag: Int?
+        var lastLedgerSequence: Int?
+        var signingPubKey: [UInt8]?
+        var memos: [String] = []
+    }
+
+    private static func invalid(_ why: String = "not a valid XRP signing blob") -> WalletError { WalletError(.invalidRequest, why) }
+
+    static func address(accountId: [UInt8]) throws -> String {
+        guard accountId.count == 20 else { throw invalid() }
+        let payload = [0x00] + accountId
+        return Base58.encode(payload + ChainAddresses.checksum4(payload), alphabet: Base58.xrp)
+    }
+
+    static func address(publicKey compressed: [UInt8]) throws -> String {
+        try address(accountId: ChainAddresses.hash160(compressed))
+    }
+
+    private struct Reader {
+        let b: [UInt8]
+        var pos = 0
+        var done: Bool { pos >= b.count }
+
+        mutating func u8() throws -> Int {
+            guard pos < b.count else { throw invalid() }
+            pos += 1
+            return Int(b[pos - 1])
+        }
+
+        mutating func take(_ n: Int) throws -> [UInt8] {
+            guard pos + n <= b.count else { throw invalid() }
+            pos += n
+            return Array(b[(pos - n)..<pos])
+        }
+
+        mutating func uint(_ n: Int) throws -> Int { try take(n).reduce(0) { $0 * 256 + Int($1) } }
+
+        /// XRPL variable-length prefix.
+        mutating func vl() throws -> [UInt8] {
+            let b1 = try u8()
+            if b1 <= 192 { return try take(b1) }
+            if b1 <= 240 { return try take(193 + (b1 - 193) * 256 + (try u8())) }
+            if b1 <= 254 { return try take(12481 + (b1 - 241) * 65536 + (try u8()) * 256 + (try u8())) }
+            throw invalid()
+        }
+
+        mutating func field() throws -> (type: Int, code: Int) {
+            let h = try u8()
+            var type = h >> 4
+            var code = h & 0x0f
+            if type == 0 { type = try u8() }
+            if code == 0 { code = try u8() }
+            return (type, code)
+        }
+
+        mutating func amount() throws -> UInt64? {
+            guard pos < b.count else { throw invalid() }
+            if b[pos] & 0x80 != 0 {
+                _ = try take(48) // issued token: 8 value + 20 currency + 20 issuer
+                return nil
+            }
+            let v = try take(8).reduce(UInt64(0)) { $0 << 8 | UInt64($1) }
+            return v & 0x3fff_ffff_ffff_ffff
+        }
+    }
+
+    /// Reads one STObject until its end marker (or the end of the blob at the top level).
+    /// `memos` collects MemoData inside the top-level Memos array.
+    private static func readObject(_ r: inout Reader, _ tx: inout Tx?, depth: Int, memos: inout [String]?) throws {
+        guard depth <= 4 else { throw invalid() }
+        while !r.done {
+            let (type, code) = try r.field()
+            if type == 14 && code == 1 { return } // ObjectEndMarker
+            if type == 15 && code == 1 { return } // ArrayEndMarker
+            switch type {
+            case 1:
+                let v = try r.uint(2)
+                if code == 2 { tx?.transactionType = v }
+            case 2:
+                let v = try r.uint(4)
+                if code == 4 { tx?.sequence = v } else if code == 14 { tx?.destinationTag = v } else if code == 27 { tx?.lastLedgerSequence = v }
+            case 3: _ = try r.take(8)
+            case 4: _ = try r.take(16)
+            case 5: _ = try r.take(32)
+            case 16: _ = try r.take(1)
+            case 17: _ = try r.take(20)
+            case 6:
+                let v = try r.amount()
+                if code == 1 { tx?.amount = .some(v) } else if code == 8 { tx?.fee = .some(v) }
+            case 7:
+                let v = try r.vl()
+                if tx != nil, code == 3 {
+                    tx?.signingPubKey = v
+                } else if tx == nil, code == 13 {
+                    memos?.append(String(decoding: v, as: UTF8.self))
+                }
+            case 8:
+                let v = try r.vl()
+                if tx != nil, code == 1 { tx?.account = try address(accountId: v) } else if tx != nil, code == 3 { tx?.destination = try address(accountId: v) }
+            case 14:
+                var none: Tx? = nil
+                try readObject(&r, &none, depth: depth + 1, memos: &memos)
+            case 15:
+                var none: Tx? = nil
+                if tx != nil && code == 9 {
+                    var collected: [String]? = []
+                    try readObject(&r, &none, depth: depth + 1, memos: &collected)
+                    tx?.memos += collected ?? []
+                } else {
+                    try readObject(&r, &none, depth: depth + 1, memos: &memos)
+                }
+            default:
+                throw invalid("XRP field type \(type) is not supported")
+            }
+        }
+    }
+
+    static func parse(_ blob: [UInt8]) throws -> Tx {
+        guard blob.count >= 5, blob.count <= maxBlob, Array(blob.prefix(4)) == signingPrefix else { throw invalid() }
+        var r = Reader(b: Array(blob.dropFirst(4)))
+        var tx: Tx? = Tx()
+        var memos: [String]? = nil
+        try readObject(&r, &tx, depth: 0, memos: &memos)
+        guard let parsed = tx, parsed.transactionType != nil, parsed.account != nil, parsed.signingPubKey != nil else { throw invalid() }
+        return parsed
+    }
+
+    static func xrp(_ drops: UInt64) -> String { Solana.units(drops, 6) + " XRP" }
+
+    private static let types: [Int: String] = [0: "Payment", 3: "AccountSet", 7: "OfferCreate", 8: "OfferCancel", 12: "SetRegularKey", 20: "TrustSet"]
+
+    static func summarize(_ tx: Tx, signer: String, signerPublicKey: [UInt8]) throws -> SignSummary {
+        guard tx.account == signer else { throw WalletError(.addressMismatch, "the transaction account is not the signing account") }
+        guard tx.signingPubKey == signerPublicKey else {
+            throw WalletError(.invalidRequest, "SigningPubKey must be the signing account public key")
+        }
+        let type = tx.transactionType ?? 0
+        var rows: [SignSummary.Row] = [
+            .init(label: "Network", value: "XRP Ledger"),
+            .init(label: "Account", value: signer, mono: true),
+            .init(label: "Type", value: types[type] ?? "Type \(type)"),
+        ]
+        var warnings = [String]()
+        if type == 0 {
+            switch tx.amount {
+            case .some(.none):
+                rows.append(.init(label: "Send", value: "Issued token amount"))
+                warnings.append("Issued-token payments cannot be described in detail.")
+            case .some(.some(let drops)):
+                rows.append(.init(label: "Send", value: xrp(drops)))
+            case .none:
+                break
+            }
+            if let d = tx.destination, !d.isEmpty { rows.append(.init(label: "To", value: d, mono: true)) }
+            if let tag = tx.destinationTag { rows.append(.init(label: "Destination tag", value: String(tag))) }
+        } else {
+            warnings.append("\(types[type] ?? "This") transaction cannot be described in detail. Approve only if you trust the app.")
+        }
+        for m in tx.memos { rows.append(.init(label: "Memo", value: m)) }
+        if case .some(.some(let fee)) = tx.fee { rows.append(.init(label: "Network fee", value: xrp(fee))) }
+        if let s = tx.sequence { rows.append(.init(label: "Sequence", value: String(s))) }
+        if let l = tx.lastLedgerSequence { rows.append(.init(label: "Valid until ledger", value: String(l))) }
+        return SignSummary(kind: .transaction, title: "XRP Ledger transaction", rows: rows, body: nil, warnings: warnings, risk: .high)
+    }
+
+    static func sha512Half(_ data: [UInt8]) -> [UInt8] { Array(Array(SHA512.hash(data: data))[0..<32]) }
+
+    /// DER (low S) over SHA-512Half of the signing blob, uppercase hex like ripple-keypairs.
+    static func sign(_ blob: [UInt8], privateKey: [UInt8]) throws -> [String: String] {
+        ["signature": Bytes.hex(try Secp256k1.signDER(hash: sha512Half(blob), key: privateKey)).uppercased()]
+    }
+}

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

@@ -0,0 +1,278 @@
+// GENERATED by scripts/sync-native-wallet.mjs from swift/Sources/AuthonWallet/Crypto/Chains.swift. Do not edit: change the source and run the script.
+#if canImport(CKeccak)
+import CKeccak
+#endif
+import CryptoKit
+import Foundation
+
+/// Chains a wallet derives addresses for (docs/wallet/NATIVE.md section 11, `apps/wallet/src/chains.ts`).
+/// Paths match standard wallets, so the same seed gives the same addresses everywhere.
+/// Signing is EVM only for now.
+public enum WalletChain: String, CaseIterable, Sendable {
+    case evm
+    case tron
+    case xrp
+    case bitcoin
+    case bitcoinTestnet = "bitcoin-testnet"
+    case solana
+
+    public func path(_ index: Int) -> String {
+        switch self {
+        case .evm: return "m/44'/60'/0'/0/\(index)"
+        case .tron: return "m/44'/195'/\(index)'/0/0"
+        case .xrp: return "m/44'/144'/\(index)'/0/0"
+        case .bitcoin: return "m/84'/0'/\(index)'/0/0"
+        case .bitcoinTestnet: return "m/84'/1'/\(index)'/0/0"
+        case .solana: return "m/44'/501'/\(index)'/0'"
+        }
+    }
+}
+
+enum ChainAddresses {
+    static func ripemd(_ data: [UInt8]) -> [UInt8] {
+        var out = [UInt8](repeating: 0, count: 20)
+        data.withUnsafeBufferPointer { input in
+            out.withUnsafeMutableBufferPointer { ripemd160(input.baseAddress, UInt32(input.count), $0.baseAddress) }
+        }
+        return out
+    }
+
+    static func hash160(_ data: [UInt8]) -> [UInt8] { ripemd(Bytes.sha256(data)) }
+
+    static func checksum4(_ payload: [UInt8]) -> [UInt8] { Array(Bytes.sha256(Bytes.sha256(payload))[0..<4]) }
+
+    /// Address of a secp256k1 key on a non-Solana chain.
+    static func secpAddress(_ chain: WalletChain, privateKey: [UInt8]) throws -> String {
+        switch chain {
+        case .evm:
+            return try EvmAddress.of(privateKey: privateKey)
+        case .tron:
+            let uncompressed = try Secp256k1.publicKey(of: privateKey, compressed: false)
+            let payload = [0x41] + Array(Keccak.hash256(Array(uncompressed.dropFirst()))[12..<32])
+            return Base58.encode(payload + checksum4(payload), alphabet: Base58.bitcoin)
+        case .xrp:
+            let payload = [0x00] + hash160(try Secp256k1.publicKey(of: privateKey, compressed: true))
+            return Base58.encode(payload + checksum4(payload), alphabet: Base58.xrp)
+        case .bitcoin, .bitcoinTestnet:
+            let program = hash160(try Secp256k1.publicKey(of: privateKey, compressed: true))
+            return Bech32.segwitAddress(hrp: chain == .bitcoin ? "bc" : "tb", version: 0, program: program)
+        case .solana:
+            throw WalletError(.internal, "solana is not a secp256k1 chain")
+        }
+    }
+
+    /// secp256k1 key of account `index` on a BIP32 chain other than EVM. Callers wipe it.
+    static func secpPrivateKey(_ secret: [UInt8], chain: WalletChain, index: Int) throws -> [UInt8] {
+        guard chain != .solana, chain != .evm else { throw WalletError(.internal, "not a BIP32 chain") }
+        guard WalletShares.isAccountIndex(index) else { throw WalletError(.invalidRequest, "invalid account index") }
+        guard WalletShares.isHdSecret(secret) else { throw WalletError(.accountUnavailable, "this wallet has only EVM account 0") }
+        var seed = try BIP39.seed(mnemonic: try BIP39.mnemonic(entropy: secret))
+        defer { seed.wipe() }
+        var root = try HDNode(seed: seed)
+        defer { root.wipe() }
+        var node = try root.derive(chain.path(index))
+        defer { node.wipe() }
+        return node.key
+    }
+
+    /// SLIP-0010 ed25519 derivation; every level is hardened. Callers wipe the 32-byte key.
+    static func ed25519Key(seed: [UInt8], path: String) throws -> [UInt8] {
+        func hmac(_ key: [UInt8], _ data: [UInt8]) -> [UInt8] {
+            Array(HMAC<SHA512>.authenticationCode(for: data, using: SymmetricKey(data: key)))
+        }
+        var i = hmac(Array("ed25519 seed".utf8), seed)
+        var key = Array(i[0..<32])
+        var code = Array(i[32..<64])
+        defer {
+            i.wipe()
+            code.wipe()
+        }
+        for part in path.split(separator: "/").dropFirst() {
+            guard part.hasSuffix("'"), let n = UInt32(part.dropLast()), n < HDNode.hardened else {
+                key.wipe()
+                throw WalletError(.internal, "ed25519 paths are hardened only")
+            }
+            let index = n + HDNode.hardened
+            var data = [0] + key + [UInt8(index >> 24), UInt8(truncatingIfNeeded: index >> 16), UInt8(truncatingIfNeeded: index >> 8), UInt8(truncatingIfNeeded: index)]
+            i.wipe()
+            i = hmac(code, data)
+            data.wipe()
+            key.wipe()
+            code.wipe()
+            key = Array(i[0..<32])
+            code = Array(i[32..<64])
+        }
+        return key
+    }
+
+    static func solanaAddress(seed: [UInt8], index: Int) throws -> String {
+        var key = try ed25519Key(seed: seed, path: WalletChain.solana.path(index))
+        defer { key.wipe() }
+        let pub = try Curve25519.Signing.PrivateKey(rawRepresentation: key).publicKey.rawRepresentation
+        return Base58.encode(Array(pub), alphabet: Base58.bitcoin)
+    }
+
+    /// Addresses of accounts start..<start+count on `chain`. Only HD (BIP39) wallets have chains other than EVM.
+    static func addresses(_ secret: [UInt8], chain: WalletChain, start: Int, count: Int) throws -> [String] {
+        guard WalletShares.isAccountIndex(start), count >= 1, WalletShares.isAccountIndex(start + count - 1) else {
+            throw WalletError(.invalidRequest, "invalid account range")
+        }
+        if chain == .evm { return try WalletShares.addresses(secret, start: start, count: count) }
+        guard WalletShares.isHdSecret(secret) else { throw WalletError(.accountUnavailable, "this wallet has only EVM account 0") }
+        var seed = try BIP39.seed(mnemonic: try BIP39.mnemonic(entropy: secret))
+        defer { seed.wipe() }
+        var out = [String]()
+        out.reserveCapacity(count)
+        if chain == .solana {
+            for i in start..<(start + count) { out.append(try solanaAddress(seed: seed, index: i)) }
+            return out
+        }
+        var root = try HDNode(seed: seed)
+        defer { root.wipe() }
+        for i in start..<(start + count) {
+            var node = try root.derive(chain.path(i))
+            defer { node.wipe() }
+            out.append(try secpAddress(chain, privateKey: node.key))
+        }
+        return out
+    }
+
+    /// Compressed public keys (uppercase hex) of XRP accounts start..<start+count (the SigningPubKey apps need).
+    static func xrpPublicKeys(_ secret: [UInt8], start: Int, count: Int) throws -> [String] {
+        guard WalletShares.isHdSecret(secret) else { throw WalletError(.accountUnavailable, "this wallet has only EVM account 0") }
+        var seed = try BIP39.seed(mnemonic: try BIP39.mnemonic(entropy: secret))
+        defer { seed.wipe() }
+        var root = try HDNode(seed: seed)
+        defer { root.wipe() }
+        return try (start..<(start + count)).map { i in
+            var node = try root.derive(WalletChain.xrp.path(i))
+            defer { node.wipe() }
+            return Bytes.hex(try Secp256k1.publicKey(of: node.key, compressed: true)).uppercased()
+        }
+    }
+}
+
+/// Base58 (Bitcoin and XRP alphabets).
+enum Base58 {
+    static let bitcoin = Array("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz".utf8)
+    static let xrp = Array("rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz".utf8)
+
+    static func encode(_ bytes: [UInt8], alphabet: [UInt8]) -> String {
+        let zeros = bytes.prefix { $0 == 0 }.count
+        var digits = [UInt8]() // little-endian base-58 digits
+        for byte in bytes[zeros...] {
+            var carry = Int(byte)
+            for j in 0..<digits.count {
+                carry += Int(digits[j]) << 8
+                digits[j] = UInt8(carry % 58)
+                carry /= 58
+            }
+            while carry > 0 {
+                digits.append(UInt8(carry % 58))
+                carry /= 58
+            }
+        }
+        let out = [UInt8](repeating: alphabet[0], count: zeros) + digits.reversed().map { alphabet[Int($0)] }
+        return String(decoding: out, as: UTF8.self)
+    }
+
+    static func decode(_ text: String, alphabet: [UInt8]) -> [UInt8]? {
+        let chars = Array(text.utf8)
+        let zeros = chars.prefix { $0 == alphabet[0] }.count
+        var bytes = [UInt8]() // little-endian base-256
+        for c in chars[zeros...] {
+            guard let value = alphabet.firstIndex(of: c) else { return nil }
+            var carry = value
+            for j in 0..<bytes.count {
+                carry += Int(bytes[j]) * 58
+                bytes[j] = UInt8(carry & 0xff)
+                carry >>= 8
+            }
+            while carry > 0 {
+                bytes.append(UInt8(carry & 0xff))
+                carry >>= 8
+            }
+        }
+        return [UInt8](repeating: 0, count: zeros) + bytes.reversed()
+    }
+}
+
+/// Bech32 (BIP173) for SegWit v0 addresses.
+enum Bech32 {
+    static let charset = Array("qpzry9x8gf2tvdw0s3jn54khce6mua7l".utf8)
+    private static let generator: [UInt32] = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3]
+
+    private static func polymod(_ values: [UInt8]) -> UInt32 {
+        var chk: UInt32 = 1
+        for v in values {
+            let top = chk >> 25
+            chk = (chk & 0x1ffffff) << 5 ^ UInt32(v)
+            for i in 0..<5 where (top >> UInt32(i)) & 1 == 1 { chk ^= generator[i] }
+        }
+        return chk
+    }
+
+    private static func hrpExpand(_ hrp: [UInt8]) -> [UInt8] {
+        hrp.map { $0 >> 5 } + [0] + hrp.map { $0 & 31 }
+    }
+
+    /// Bech32 (BIP173) or, with `m`, Bech32m (BIP350, SegWit v1+).
+    static func encode(hrp: String, data: [UInt8], m: Bool = false) -> String {
+        let h = Array(hrp.lowercased().utf8)
+        let mod = polymod(hrpExpand(h) + data + [0, 0, 0, 0, 0, 0]) ^ (m ? 0x2bc8_30a3 : 1)
+        let checksum = (0..<6).map { UInt8((mod >> UInt32(5 * (5 - $0))) & 31) }
+        return String(decoding: h + [UInt8(ascii: "1")] + (data + checksum).map { charset[Int($0)] }, as: UTF8.self)
+    }
+
+    /// (hrp, 5-bit data without checksum), or nil for an invalid string.
+    static func decode(_ text: String) -> (hrp: String, data: [UInt8])? {
+        let bytes = Array(text.utf8)
+        guard bytes.count <= 90, bytes.allSatisfy({ $0 >= 33 && $0 <= 126 }) else { return nil }
+        let lower = text.lowercased(), upper = text.uppercased()
+        guard text == lower || text == upper else { return nil }
+        let chars = Array(lower.utf8)
+        guard let sep = chars.lastIndex(of: UInt8(ascii: "1")), sep >= 1, sep + 7 <= chars.count else { return nil }
+        let hrp = Array(chars[0..<sep])
+        var data = [UInt8]()
+        for c in chars[(sep + 1)...] {
+            guard let v = charset.firstIndex(of: c) else { return nil }
+            data.append(UInt8(v))
+        }
+        guard polymod(hrpExpand(hrp) + data) == 1 else { return nil }
+        return (String(decoding: hrp, as: UTF8.self), Array(data.dropLast(6)))
+    }
+
+    /// Regroups bits (BIP173 convertbits).
+    static func convertBits(_ data: [UInt8], from: Int, to: Int, pad: Bool) -> [UInt8]? {
+        var acc = 0, bits = 0
+        var out = [UInt8]()
+        let maxv = (1 << to) - 1
+        for v in data {
+            guard Int(v) >> from == 0 else { return nil }
+            acc = acc << from | Int(v)
+            bits += from
+            while bits >= to {
+                bits -= to
+                out.append(UInt8((acc >> bits) & maxv))
+            }
+        }
+        if pad {
+            if bits > 0 { out.append(UInt8((acc << (to - bits)) & maxv)) }
+        } else if bits >= from || (acc << (to - bits)) & maxv != 0 {
+            return nil
+        }
+        return out
+    }
+
+    static func segwitAddress(hrp: String, version: UInt8, program: [UInt8]) -> String {
+        encode(hrp: hrp, data: [version] + convertBits(program, from: 8, to: 5, pad: true)!, m: version > 0)
+    }
+
+    /// (version, program) of a SegWit address with the expected HRP.
+    static func decodeSegwit(hrp: String, address: String) -> (version: UInt8, program: [UInt8])? {
+        guard let d = decode(address), d.hrp == hrp, let version = d.data.first, version <= 16,
+              let program = convertBits(Array(d.data.dropFirst()), from: 5, to: 8, pad: false),
+              (2...40).contains(program.count), version != 0 || program.count == 20 || program.count == 32 else { return nil }
+        return (version, program)
+    }
+}

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

@@ -87,6 +87,30 @@ enum Secp256k1 {
         }
     }
 
+    /// 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 }

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

@@ -35,6 +35,10 @@ public struct WalletAppConfig: Equatable, Sendable {
     public var prfSaltVersion: BackupVersion
     public var rpId: String
     public var minFrameProtocol: Int?
+    /// `X-Request-Id` of the app-config response.
+    public var diagnosticId: String? = nil
+    /// False when the API answered 403/404 (unknown publishable key or project).
+    var projectFound = true
 }
 
 enum ProofKind: String {
@@ -90,6 +94,11 @@ final class WalletAPIClient: @unchecked Sendable {
     struct Response {
         var status: Int
         var data: JSONObject
+        /// `X-Request-Id` response header.
+        var requestId: String?
+
+        /// The server's diagnostic ID: `requestId` in the body, else the header.
+        var diagnosticId: String? { data["requestId"]?.stringValue ?? requestId }
     }
 
     private func call(_ method: String, _ path: String, _ token: String?, _ body: JSONValue? = nil) async throws -> Response {
@@ -110,20 +119,21 @@ final class WalletAPIClient: @unchecked Sendable {
         do {
             (data, response) = try await session.data(for: req)
         } catch {
-            throw WalletError(.apiError, "network error")
+            throw WalletError.network()
         }
-        let status = (response as? HTTPURLResponse)?.statusCode ?? 0
+        let http = response as? HTTPURLResponse
         let parsed = (try? JSONValue.parse(String(decoding: data, as: UTF8.self)))?.objectValue ?? JSONObject()
-        return Response(status: status, data: parsed)
+        return Response(status: http?.statusCode ?? 0, data: parsed, requestId: http?.value(forHTTPHeaderField: "X-Request-Id"))
     }
 
     private func ensureOk(_ res: Response) throws -> JSONObject {
         if (200..<300).contains(res.status) { return res.data }
+        let id = res.diagnosticId
         if case .string(let code) = res.data["code"] ?? .null {
-            if Self.restoreCodes.contains(code) { throw WalletError(.needsRestore) }
-            if Self.knownCodes.contains(code), let c = WalletErrorCode(rawValue: code) { throw WalletError(c) }
+            if Self.restoreCodes.contains(code) { throw WalletError(.needsRestore, diagnosticId: id) }
+            if Self.knownCodes.contains(code), let c = WalletErrorCode(rawValue: code) { throw WalletError(c, diagnosticId: id) }
         }
-        throw WalletError(Self.statusCodes[res.status] ?? .apiError)
+        throw WalletError(Self.statusCodes[res.status] ?? .apiError, diagnosticId: id)
     }
 
     private static func string(_ v: JSONValue?) -> String? { v?.stringValue }
@@ -184,7 +194,7 @@ final class WalletAPIClient: @unchecked Sendable {
         let query = "platform=\(Self.encode(platform))&appId=\(Self.encode(appId))"
         let res = try await call("GET", "/app-config?\(query)", nil)
         if res.status == 403 || res.status == 404 {
-            return WalletAppConfig(projectId: nil, allowed: false, approved: false, enabled: false, chainIds: [], confirmSigning: true, prfSaltVersion: .v1, rpId: "wallet.authon.dev", minFrameProtocol: nil)
+            return WalletAppConfig(projectId: nil, allowed: false, approved: false, enabled: false, chainIds: [], confirmSigning: true, prfSaltVersion: .v1, rpId: "wallet.authon.dev", minFrameProtocol: nil, diagnosticId: res.diagnosticId, projectFound: false)
         }
         let data = try ensureOk(res)
         let cfg = data["walletConfig"]?.objectValue ?? JSONObject()
@@ -198,7 +208,8 @@ final class WalletAPIClient: @unchecked Sendable {
             confirmSigning: cfg["confirmSigning"] != .bool(false),
             prfSaltVersion: Self.int(cfg["prfSaltVersion"]) == 2 ? .v2 : .v1,
             rpId: rpId,
-            minFrameProtocol: Self.int(data["minFrameProtocol"])
+            minFrameProtocol: Self.int(data["minFrameProtocol"]),
+            diagnosticId: res.diagnosticId
         )
     }