Repository Public
1// SP Wallet Core2// File: Tests/SPWalletCoreTests/AddressValidatorTests.swift3// Description: Differential test of AddressValidator against the backend: Fixtures/address-vectors.json holds the verdict and4// the normalized output of the backend's own `normalizeAddress` for every candidate (generated by5// Fixtures/address-vectors.gen.mts with `npx tsx`, never typed by hand); the Swift verdict and string must be6// identical for every case. Fixtures/address-registry.json is the address-relevant part of networks.ts, compared7// with the table embedded in AddressParameters.swift.8//9// Author: Simon-Pierre Boucher10// Contact: contact@spboucher.ai11import Foundation12import Testing13@testable import SPWalletCore1415enum AddressFixtures {16 struct Case: Decodable { let network: String; let kind: String; let input: String; let valid: Bool; let normalized: String? }17 struct File: Decodable { let networks: [String]; let cases: [Case] }1819 static func data(_ name: String) throws -> Data {20 guard let url = Bundle.module.url(forResource: name, withExtension: "json", subdirectory: "Fixtures") else { throw CocoaError(.fileNoSuchFile) }21 return try Data(contentsOf: url)22 }23 static func vectors() throws -> File { try JSONDecoder().decode(File.self, from: data("address-vectors")) }24 static func registry() throws -> [AddressParameters] { try JSONDecoder().decode([AddressParameters].self, from: data("address-registry")) }2526 /** A `Network` as the API serves it (no utxo / cosmos block), from the embedded table. */27 static func network(_ id: String, family: String? = nil, chainRef: String? = nil) -> Network {28 let p = AddressParameters.find(id: id)29 return Network(id: id, name: id, family: family ?? p?.family ?? "unknown", chainRef: chainRef ?? p?.chainRef ?? "0",30 native: AssetDef(id: "native", symbol: "X", name: "X", decimals: p?.family == "evm" ? 18 : 8, program: nil, onchainSymbol: nil),31 tokens: [], memo: nil, activation: nil, explorerAddr: "", minConf: 1, health: nil)32 }33 static var allNetworks: [Network] { AddressParameters.table.map { network($0.id) } }34}3536private func exact(_ a: String?, _ b: String?) -> Bool {37 switch (a, b) { case (nil, nil): true; case (let x?, let y?): x.utf8.elementsEqual(y.utf8); default: false }38}3940@Suite struct AddressRegistryTests {41 @Test func embeddedTableIsTheBackendRegistry() throws {42 // FAILS when networks.ts gains or loses a network, reorders nothing relevant, or changes a family, a chain reference,43 // a version byte, a bech32 / CashAddr prefix or a script kind (after the fixture is regenerated from the backend).44 let registry = try AddressFixtures.registry()45 #expect(registry.count == 23)46 #expect(registry.map(\.id) == AddressParameters.table.map(\.id))47 for r in registry { #expect(AddressParameters.find(id: r.id) == r, "\(r.id) differs from networks.ts") }48 #expect(AddressParameters.table == registry)49 #expect(try AddressFixtures.vectors().networks == registry.map(\.id))50 }51 @Test func everyFamilyOfTheRegistryHasRules() {52 for p in AddressParameters.table { #expect(AddressValidator.check("", parameters: p) != .unverifiable, "\(p.id)") }53 }54 @Test func unknownOrMismatchedNetworkIsUnverifiableNeverValid() {55 let vitalik = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"56 #expect(AddressValidator.check(vitalik, network: AddressFixtures.network("ethereum")) == .valid(normalized: vitalik))57 #expect(AddressValidator.check(vitalik, network: AddressFixtures.network("linea", family: "evm", chainRef: "59144")) == .unverifiable)58 #expect(AddressValidator.check("anything", network: AddressFixtures.network("monero", family: "xmr", chainRef: "x")) == .unverifiable)59 // same id, but the server describes another chain than the one this build knows: no verdict60 #expect(AddressValidator.check(vitalik, network: AddressFixtures.network("ethereum", chainRef: "5")) == .unverifiable)61 #expect(AddressValidator.check(vitalik, network: AddressFixtures.network("ethereum", family: "sol")) == .unverifiable)62 #expect(AddressValidator.check(vitalik, network: AddressFixtures.network("Ethereum", family: "evm", chainRef: "1")) == .unverifiable)63 // canonically equivalent but different code points (KELVIN SIGN): Swift's String == would call these equal64 #expect(AddressValidator.check("x", network: AddressFixtures.network("bitcoincash", family: "bch", chainRef: "0000000000000000029e471c41818d24b8b74c911071c4ef0b4a0509f9b5a8ce")) != .unverifiable)65 #expect(AddressValidator.check("x", network: AddressFixtures.network("to\u{212a}en", family: "evm", chainRef: "1")) == .unverifiable)66 #expect(AddressValidator.check(vitalik, network: AddressFixtures.network("ethereum", family: "evm", chainRef: "1\u{0301}")) == .unverifiable)67 }68}6970@Suite struct AddressDifferentialTests {71 @Test func swiftVerdictAndNormalizedFormEqualTheBackendOnEveryCase() throws {72 let file = try AddressFixtures.vectors()73 #expect(file.cases.count >= 400)74 var divergences: [String] = [], perNetwork: [String: (valid: Int, invalid: Int)] = [:]75 for c in file.cases {76 guard let p = AddressParameters.find(id: c.network) else { divergences.append("no parameters for \(c.network)"); continue }77 let got = AddressValidator.check(c.input, parameters: p)78 let viaNetwork = AddressValidator.check(c.input, network: AddressFixtures.network(c.network))79 var entry = perNetwork[c.network] ?? (0, 0)80 if c.valid { entry.valid += 1 } else { entry.invalid += 1 }81 perNetwork[c.network] = entry82 let same = c.valid ? exact(got.normalized, c.normalized) : { if case .invalid = got { true } else { false } }()83 if !same || got != viaNetwork {84 divergences.append("\(c.network) [\(c.kind)] \(String(reflecting: c.input)): backend \(c.valid ? "valid → \(c.normalized ?? "?")" : "invalid"), swift \(got)")85 }86 }87 #expect(divergences.isEmpty, "\(divergences.count) divergence(s):\n\(divergences.prefix(40).joined(separator: "\n"))")88 // the fixture covers every network of the registry with at least 6 accepted and 10 refused addresses89 for p in AddressParameters.table {90 let n = perNetwork[p.id] ?? (0, 0)91 #expect(n.valid >= 6 && n.invalid >= 10, "\(p.id): \(n.valid) valid, \(n.invalid) invalid")92 }93 }9495 @Test func normalizedOutputIsAFixedPointAndPureASCII() throws {96 // what the validator returns is itself accepted unchanged: an app may store and resend it97 for c in try AddressFixtures.vectors().cases where c.valid {98 guard let p = AddressParameters.find(id: c.network), let n = c.normalized else { continue }99 #expect(AddressValidator.check(n, parameters: p) == .valid(normalized: n), "\(c.network) \(n)")100 #expect(n.unicodeScalars.allSatisfy { $0.isASCII && $0.value > 0x20 && $0.value < 0x7f })101 }102 }103}104105@Suite struct AddressValidatorBehaviourTests {106 private func check(_ input: String, _ id: String) -> AddressCheck { AddressValidator.check(input, network: AddressFixtures.network(id)) }107108 @Test func evmRules() {109 #expect(check("0xd8da6bf26964af9d7eed9e03e53415d37aa96045", "base") == .valid(normalized: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"))110 #expect(check("0xD8DA6BF26964AF9D7EED9E03E53415D37AA96045", "base") == .valid(normalized: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"))111 #expect(check("0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045\n", "base") == .valid(normalized: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"))112 #expect(check("0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96044", "base") == .invalid(reason: .badChecksum))113 #expect(check("0xD8dA6BF26964aF9D7eEd9e03E53415D37aA96045", "base") == .invalid(reason: .badChecksum))114 #expect(check("0x0000000000000000000000000000000000000000", "base") == .invalid(reason: .reserved))115 #expect(check("0xd8dA6BF26964aF9D7eEd9e03E53415D37aA9604", "base") == .invalid(reason: .malformed))116 #expect(check("bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq", "base") == .invalid(reason: .malformed))117 }118 @Test func bitcoinFamilyRules() {119 #expect(check("BC1QAR0SRRR7XFKVY5L643LYDNW9RE59GTZZWF5MDQ", "bitcoin") == .valid(normalized: "bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq"))120 #expect(check("bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdx", "bitcoin") == .invalid(reason: .badChecksum))121 #expect(check("Bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq", "bitcoin") == .invalid(reason: .mixedCase))122 #expect(check("tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx", "bitcoin") == .invalid(reason: .wrongNetwork))123 #expect(check("BC1SW50QGDZ25J", "bitcoin") == .invalid(reason: .unsupportedType)) // witness v16124 #expect(check("bc1pfeessrawgf", "bitcoin") == .invalid(reason: .unsupportedType)) // pay-to-anchor125 #expect(check("1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa", "bitcoin") == .valid(normalized: "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"))126 #expect(check("1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa", "litecoin") == .invalid(reason: .wrongNetwork))127 #expect(check("1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa", "dogecoin") == .invalid(reason: .wrongNetwork))128 #expect(check("1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNb", "bitcoin") == .invalid(reason: .badChecksum))129 }130 @Test func bitcoinCashRules() {131 let cash = "bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a"132 #expect(check(cash, "bitcoincash") == .valid(normalized: cash))133 #expect(check("qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a", "bitcoincash") == .valid(normalized: cash))134 #expect(check(cash.uppercased(), "bitcoincash") == .valid(normalized: cash))135 #expect(check("1BpEi6DfDAUFd7GtittLSdBeYJvcoaVggu", "bitcoincash") == .valid(normalized: cash)) // the specification's legacy equivalent136 #expect(check("3CWFddi6m4ndiGyKqzYvsFYagqDLPVMTzC", "bitcoincash") == .invalid(reason: .unsupportedType)) // legacy script address137 #expect(check("bchtest:pr6m7j9njldwwzlg9v7v53unlr4jkmx6eyvwc0uz5t", "bitcoincash") == .invalid(reason: .wrongNetwork))138 #expect(check(cash, "bitcoin") == .invalid(reason: .malformed))139 }140 @Test func refusalReasonsOfThePluginFamilies() {141 #expect(check("X7AcgcsBL6XDcUb289X4mJ8djcdyKaB5hJDWMArnXr61cqZ", "xrpl") == .invalid(reason: .unsupportedType)) // X-address142 #expect(check("T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb", "tron") == .invalid(reason: .reserved))143 #expect(check("addr_test1qz2fxv2umyhttkxyxp8x0dlpdt3k6cwng5pxj3jhsydzer3n0d3vllmyqwsx5wktcd8cc3sq835lu7drv2xwl2wywfgs68faae", "cardano") == .invalid(reason: .wrongNetwork))144 #expect(check("addr1w8phkx6acpnf78fuvxn0mkew3l0fd058hzquvz7w36x4gtcyjy7wx", "cardano") == .invalid(reason: .unsupportedType)) // script address145 #expect(check("5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY", "polkadot") == .invalid(reason: .wrongNetwork)) // generic Substrate form146 #expect(check("system", "near") == .invalid(reason: .reserved))147 #expect(check("Alice.near", "near") == .invalid(reason: .mixedCase))148 #expect(check("0x" + String(repeating: "0", count: 63) + "2", "sui") == .invalid(reason: .reserved))149 #expect(check("0x" + String(repeating: "0", count: 63) + "a", "aptos") == .invalid(reason: .reserved))150 #expect(check("0x1", "aptos") == .invalid(reason: .malformed)) // short forms are never padded151 #expect(check("-1:" + String(repeating: "ab", count: 32), "ton") == .invalid(reason: .wrongNetwork)) // masterchain152 #expect(check("0:" + String(repeating: "ab", count: 32), "ton").isValid)153 }154 @Test func plausibleNetworksAfterAScan() {155 let all = AddressFixtures.allNetworks156 let ids = { (s: String) in AddressValidator.plausibleNetworks(for: s, among: all).map(\.id) }157 #expect(ids("0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045") == ["ethereum", "base", "arbitrum", "polygon", "optimism", "bsc", "avalanche", "hyperevm"])158 // a lower-case bech32 address is also a syntactically valid NEAR account name: Bitcoin first, NEAR last (weak)159 #expect(ids("bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq") == ["bitcoin", "near"])160 #expect(ids("TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t") == ["tron"])161 #expect(ids("rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh") == ["xrpl"])162 #expect(ids("GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF") == ["stellar"])163 #expect(ids("1BpEi6DfDAUFd7GtittLSdBeYJvcoaVggu") == ["bitcoin", "bitcoincash"])164 #expect(ids("15oF4uVJwmo4TdGW7VfQxNLavjCXviqxT9S1MgbjMNHr6Sp5") == ["polkadot"])165 #expect(ids("not an address") == [])166 #expect(AddressValidator.plausibleNetworks(for: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045", among: [AddressFixtures.network("linea", family: "evm", chainRef: "59144")]).isEmpty)167 // 64 hex digits are a NEAR implicit account (strong) and nothing else without "0x"168 #expect(ids(String(repeating: "ab", count: 32)) == ["near"])169 #expect(Set(ids("0x" + String(repeating: "ab", count: 32))) == ["aptos", "sui"])170 }171 @Test func addressPoisoningPattern() {172 let real = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045", fake = "0xd8dA00000000000000000000000000000000006045"173 #expect(AddressValidator.sameEndsDifferentMiddle(real, fake))174 #expect(AddressValidator.sameEndsDifferentMiddle(real, fake.uppercased().replacingOccurrences(of: "0X", with: "0x"))) // case-insensitive, as the server175 #expect(!AddressValidator.sameEndsDifferentMiddle(real, real))176 #expect(!AddressValidator.sameEndsDifferentMiddle(real, "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96046"))177 #expect(!AddressValidator.sameEndsDifferentMiddle(real, "0xd9dA6BF26964aF9D7eEd9e03E53415D37aA96045"))178 #expect(AddressValidator.sameEndsDifferentMiddle("TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t", "TR7NHqXXXXXXXXXXXXXXXXXXXXXXXXLj6t"))179 #expect(!AddressValidator.sameEndsDifferentMiddle("", ""))180 // the same text with another case is a different string to the server, with the same ends181 #expect(AddressValidator.sameEndsDifferentMiddle(real, real.lowercased()))182 }183}184