Repository Public
1// SP Wallet Core2// File: Tests/SPWalletCoreTests/CryptoTests.swift3// Description: Known-answer tests of the pure-Swift hashes and address codecs, from the published vectors of each standard4// (Keccak team / NIST FIPS 202, RFC 7693, RFC 4648, BIP-173, BIP-350, the CashAddr specification, EIP-55, CRC5// catalogue, SS58). Vectors marked "cross-checked" were recomputed with @noble/hashes 2.4, the backend's library.6//7// Author: Simon-Pierre Boucher8// Contact: contact@spboucher.ai9import Foundation10import Testing11@testable import SPWalletCore1213private func bytes(_ s: String) -> [UInt8] { [UInt8](s.utf8) }14private func hex(_ b: [UInt8]) -> String { Data(b).hex }15private func unhex(_ s: String) -> [UInt8] { [UInt8](Data(hex: s)!) }1617@Suite struct KeccakTests {18 @Test func keccak256IsTheOriginalKeccakNotSHA3() {19 #expect(hex(Keccak.keccak256(bytes(""))) == "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470")20 #expect(hex(Keccak.keccak256(bytes("abc"))) == "4e03657aea45a94fc7d47ba826c8d667c0d1e6e33a64a036ec44f58fa12d6c45")21 #expect(hex(Keccak.sha3_256(bytes(""))) == "a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a") // FIPS 20222 #expect(hex(Keccak.sha3_256(bytes("abc"))) == "3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532")23 #expect(Keccak.keccak256(bytes("abc")) != Keccak.sha3_256(bytes("abc")))24 #expect(Keccak.keccak256(Data("abc".utf8)).hex == "4e03657aea45a94fc7d47ba826c8d667c0d1e6e33a64a036ec44f58fa12d6c45")25 // the ERC-20 selector everyone knows: keccak256("transfer(address,uint256)")[0..<4]26 #expect(hex(Array(Keccak.keccak256(bytes("transfer(address,uint256)")).prefix(4))) == "a9059cbb")27 }28 @Test func blockBoundariesAndLongInput() {29 // rate = 136 bytes: one byte below, exactly at and one byte above the block size (cross-checked)30 #expect(hex(Keccak.keccak256([UInt8](repeating: 0x61, count: 135))) == "34367dc248bbd832f4e3e69dfaac2f92638bd0bbd18f2912ba4ef454919cf446")31 #expect(hex(Keccak.keccak256([UInt8](repeating: 0x61, count: 136))) == "a6c4d403279fe3e0af03729caada8374b5ca54d8065329a3ebcaeb4b60aa386e")32 #expect(hex(Keccak.keccak256([UInt8](repeating: 0x61, count: 137))) == "d869f639c7046b4929fc92a4d988a8b22c55fbadb802c0c66ebcd484f1915f39")33 let million = [UInt8](repeating: 0x61, count: 1_000_000)34 #expect(hex(Keccak.sha3_256(million)) == "5c8875ae474a3634ba4fd55ec85bffd661f32aca75c6d699d0cdcb6c115891c1") // NIST: one million "a"35 #expect(hex(Keccak.keccak256(million)) == "fadae6b49f129bbb812be8407b7b2894f34aecf6dbd1f9b0f0c7e9853098fc96") // cross-checked36 }37 @Test func eip55SpecificationVectors() {38 for a in ["5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed", "fB6916095ca1df60bB79Ce92cE3Ea74c37c5d359", "dbF03B407c01E7cD3CBea99509d93f8DDDC8C6FB", "D1220A0cf47c7B9Be7A2E6BA89F429762e7b9aDb",39 "52908400098527886E0F7030069857D2E4169EE7", "8617E340B3D01FA5F11F306F4090FD50E238070D", "de709f2102306220921060314715629080e2fb77", "27b1fdb04752bbc536007a920d24acb045561c26"] {40 #expect(String(decoding: AddressValidator.eip55(lowerHex: bytes(a.lowercased())), as: UTF8.self) == a)41 }42 }43}4445@Suite struct Blake2bTests {46 @Test func rfc7693AndDigestLengths() {47 // RFC 7693 appendix A48 #expect(hex(Blake2b.hash(bytes("abc"))) == "ba80a53f981c4d0d6a2797b69f12f6e94c212f14685ac4b74b12bb6fdbffa2d17d87c5392aab792dc252d5de4533cc9518d38aa8dbf1925ab92386edd4009923")49 #expect(hex(Blake2b.hash([])) == "786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce")50 #expect(hex(Blake2b.hash([], outputLength: 32)) == "0e5751c026e543b2e8ab2eb06099daa1d1e5df47778f7787faab45cdf12fe3a8")51 #expect(hex(Blake2b.hash(bytes("abc"), outputLength: 32)) == "bddd813c634239723171ef3fee98579b94964e3bb1cb3e427262c8c068d52319")52 #expect(hex(Blake2b.hash(bytes("abc"), outputLength: 28)) == "9bd237b02a29e43bdd6738afa5b53ff0eee178d6210b618e4511aec8")53 }54 @Test func blockBoundaries() {55 // input byte k = k mod 256, lengths around the 128-byte block (cross-checked): BLAKE2b-25656 let expected: [(Int, String)] = [57 (127, "f2fe67ff342e21b8f45e8f2e0bcd1d9243245d50ee6c78042e9c491388791c72"), (128, "c3582f71ebb2be66fa5dd750f80baae97554f3b015663c8be377cfcb2488c1d1"),58 (129, "f7f3c46ba2564ff4c4c162da1f5b605f9f1c4aa6a20652a9f9a337c1a2f5b9c9"), (255, "1d0850ee9bca0abc9601e9deabe1418fedec2fb6ac4150bd5302d2430f9be943"),59 (256, "39a7eb9fedc19aabc83425c6755dd90e6f9d0c804964a1f4aaeea3b9fb599835"), (257, "45f7f084c30bac7cbae2e1963bc6e6b0d8cb227a12927e97fb941d288fb1f9a3"),60 (1000, "c636324d47d89f2b2434dc2c994100663fbbaea880ff020fc5de89dd0f77a1ec"),61 ]62 for (n, digest) in expected { #expect(hex(Blake2b.hash((0..<n).map { UInt8($0 & 0xff) }, outputLength: 32)) == digest, "length \(n)") }63 #expect(hex(Array(Blake2b.hash((0..<128).map { UInt8($0) }).prefix(16))) == "2319e3789c47e2daa5fe807f61bec2a1")64 }65}6667@Suite struct ChecksumAndBaseCodecTests {68 @Test func crc16XmodemCheckValue() {69 #expect(CRC16.xmodem(bytes("123456789")) == 0x31c3) // CRC catalogue, CRC-16/XMODEM70 #expect(CRC16.xmodem([UInt8]()) == 0)71 }72 @Test func base32RFC4648WithoutPadding() {73 let vectors = [("", ""), ("f", "MY"), ("fo", "MZXQ"), ("foo", "MZXW6"), ("foob", "MZXW6YQ"), ("fooba", "MZXW6YTB"), ("foobar", "MZXW6YTBOI")]74 for (plain, encoded) in vectors {75 #expect(Base32.encode(bytes(plain)) == encoded)76 #expect(Base32.decode(encoded) == bytes(plain))77 }78 #expect(Base32.decode("MZ") == nil) // non-zero padding bits79 #expect(Base32.decode("MZXW6===") == nil) // padding characters are not part of this form80 #expect(Base32.decode("mzxw6") == nil)81 #expect(Base32.decode("MZXW1") == nil)82 #expect(Base32.decode("MYA") == nil) // a leftover whole group83 // Stellar strkey of the all-zero ed25519 key (version byte 6 << 3, CRC-16 little-endian)84 var body: [UInt8] = [6 << 3] + [UInt8](repeating: 0, count: 32)85 let crc = CRC16.xmodem(body); body += [UInt8(crc & 0xff), UInt8(crc >> 8)]86 #expect(Base32.encode(body) == "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF")87 }88 @Test func base58BitcoinAndRippleAlphabets() {89 #expect(Base58.bitcoin.encode(bytes("Hello World!")) == "2NEpo7TZRRrLZSi2U")90 #expect(Base58.bitcoin.encode(bytes("The quick brown fox jumps over the lazy dog.")) == "USm3fpXnKG5EUBx2ndxBDMPVciP5hGey2Jh4NDv6gmeo1LkMeiKrLJUUBk6Z")91 #expect(Base58.bitcoin.encode(unhex("0000287fb4cd")) == "11233QC4")92 #expect(Base58.bitcoin.decode("11233QC4") == unhex("0000287fb4cd"))93 #expect(Base58.bitcoin.decode("") == [])94 #expect(Base58.bitcoin.encode([]) == "")95 #expect(Base58.bitcoin.decode("1111") == [0, 0, 0, 0])96 for bad in ["0", "O", "I", "l", "2NEpo7TZRRrLZSi2U ", "2NEpo7TZRRrLZSi2Ü", "+"] { #expect(Base58.bitcoin.decode(bad) == nil, "\(bad)") }97 // Base58Check: the address of the Bitcoin genesis block's coinbase output98 #expect(Base58Check.decode("1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa") == unhex("0062e907b15cbf27d5425399ebf6f0fb50ebb88f18"))99 #expect(Base58Check.encode(unhex("0062e907b15cbf27d5425399ebf6f0fb50ebb88f18")) == "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa")100 #expect(Base58Check.decode("1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNb") == nil)101 #expect(Base58Check.decode("111") == nil)102 // XRP Ledger alphabet: the genesis account103 #expect(Base58.ripple.decode("rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh") == unhex("00b5f762798a53d543a014caf8b297cff8f2f937e8bf32ba9f"))104 #expect(Base58Check.encode(unhex("00b5f762798a53d543a014caf8b297cff8f2f937e8"), alphabet: .ripple) == "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh")105 #expect(Base58Check.decode("rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", alphabet: .ripple) == unhex("00b5f762798a53d543a014caf8b297cff8f2f937e8"))106 }107 @Test func ss58PublishedAccount() {108 // the "Alice" development account of the Substrate documentation, under three network prefixes109 let account = unhex("d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d")110 #expect(SS58.encode(prefix: 0, account: account) == "15oF4uVJwmo4TdGW7VfQxNLavjCXviqxT9S1MgbjMNHr6Sp5")111 #expect(SS58.encode(prefix: 42, account: account) == "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY")112 #expect(SS58.encode(prefix: 2, account: account) == "HNZata7iMYWmk5RvZRTiAsSDhV8366zq2YGb3tLH5Upf74F")113 #expect(SS58.decode("5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY")?.prefix == 42)114 #expect(SS58.decode("5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY")?.account == account)115 #expect(SS58.decode("5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQZ") == nil)116 #expect(SS58.encode(prefix: 64, account: account) == nil)117 #expect(SS58.encode(prefix: 0, account: Array(account.dropLast())) == nil)118 }119}120121@Suite struct Bech32Tests {122 @Test func bip173ValidAndInvalidStrings() {123 let valid = ["A12UEL5L", "a12uel5l", "an83characterlonghumanreadablepartthatcontainsthenumber1andtheexcludedcharactersbio1tt5tgs", "abcdef1qpzry9x8gf2tvdw0s3jn54khce6mua7lmqqqxw",124 "11qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqc8247j", "split1checkupstagehandshakeupstreamerranterredcaperred2y9e3w", "?1ezyfcl"]125 for s in valid {126 let d = Bech32.decode(s, variant: .bech32)127 #expect(d != nil, "\(s)")128 #expect(Bech32.decode(s, variant: .bech32m) == nil, "\(s)")129 if let d { #expect(Bech32.encode(hrp: d.hrp, words: d.words, variant: .bech32) == s.lowercased()) }130 }131 let invalid = ["\u{20}1nwldj5", "\u{7f}1axkwrx", "\u{80}1eym55h", "an84characterslonghumanreadablepartthatcontainsthenumber1andtheexcludedcharactersbio1569pvx", "pzry9x0s0muk", "1pzry9x0s0muk",132 "x1b4n0q5v", "li1dgmt3", "de1lg7wt\u{ff}", "A1G7SGD8", "10a06t8", "1qzzfhee", "A12uEL5L"]133 for s in invalid { #expect(Bech32.decode(s, variant: .bech32) == nil, "\(s)") }134 }135 @Test func bip350ValidAndInvalidStrings() {136 let valid = ["A1LQFN3A", "a1lqfn3a", "an83characterlonghumanreadablepartthatcontainsthetheexcludedcharactersbioandnumber11sg7hg6", "abcdef1l7aum6echk45nj3s0wdvt2fg8x9yrzpqzd3ryx",137 "11llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllludsr8", "split1checkupstagehandshakeupstreamerranterredcaperredlc445v", "?1v759aa"]138 for s in valid {139 let d = Bech32.decode(s, variant: .bech32m)140 #expect(d != nil, "\(s)")141 #expect(Bech32.decode(s, variant: .bech32) == nil, "\(s)")142 if let d { #expect(Bech32.encode(hrp: d.hrp, words: d.words, variant: .bech32m) == s.lowercased()) }143 }144 let invalid = ["\u{20}1xj0phk", "\u{7f}1g6xzxy", "\u{80}1vctc34", "an84characterslonghumanreadablepartthatcontainsthetheexcludedcharactersbioandnumber11d6pts4", "qyrz8wqd2c9m", "1qyrz8wqd2c9m",145 "y1b0jsk6g", "lt1igcx5c0", "in1muywd", "mm1crxm3i", "au1s5cgom", "M1VUXWEZ", "16plkw9", "1p2gdwpf"]146 for s in invalid { #expect(Bech32.decode(s, variant: .bech32m) == nil, "\(s)") }147 }148 @Test func segwitAddressesOfBIP173AndBIP350() {149 // address -> scriptPubKey (OP_n, push length, program)150 let valid: [(String, String, String)] = [151 ("BC1QW508D6QEJXTDG4Y5R3ZARVARY0C5XW7KV8F3T4", "bc", "0014751e76e8199196d454941c45d1b3a323f1433bd6"),152 ("tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7", "tb", "00201863143c14c5166804bd19203356da136c985678cd4d27a1b8c6329604903262"),153 ("bc1pw508d6qejxtdg4y5r3zarvary0c5xw7kw508d6qejxtdg4y5r3zarvary0c5xw7kt5nd6y", "bc", "5128751e76e8199196d454941c45d1b3a323f1433bd6751e76e8199196d454941c45d1b3a323f1433bd6"),154 ("BC1SW50QGDZ25J", "bc", "6002751e"),155 ("bc1zw508d6qejxtdg4y5r3zarvaryvaxxpcs", "bc", "5210751e76e8199196d454941c45d1b3a323"),156 ("tb1qqqqqp399et2xygdj5xreqhjjvcmzhxw4aywxecjdzew6hylgvsesrxh6hy", "tb", "0020000000c4a5cad46221b2a187905e5266362b99d5e91c6ce24d165dab93e86433"),157 ("tb1pqqqqp399et2xygdj5xreqhjjvcmzhxw4aywxecjdzew6hylgvsesf3hn0c", "tb", "5120000000c4a5cad46221b2a187905e5266362b99d5e91c6ce24d165dab93e86433"),158 ("bc1p0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vqzk5jj0", "bc", "512079be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"),159 ]160 for (address, hrp, script) in valid {161 guard let d = SegWitAddress.decode(address, hrp: hrp) else { Issue.record("\(address) must decode"); continue }162 let opcode: UInt8 = d.version == 0 ? 0 : 0x50 + d.version163 #expect(hex([opcode, UInt8(d.program.count)] + d.program) == script)164 #expect(SegWitAddress.encode(hrp: hrp, version: d.version, program: d.program) == address.lowercased())165 #expect(SegWitAddress.decode(address, hrp: hrp == "bc" ? "tb" : "bc") == nil)166 }167 let invalid = [168 "tc1qw508d6qejxtdg4y5r3zarvary0c5xw7kg3g4ty", "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t5", "BC13W508D6QEJXTDG4Y5R3ZARVARY0C5XW7KN40WF2", "bc1rw5uspcuh",169 "bc10w508d6qejxtdg4y5r3zarvary0c5xw7kw508d6qejxtdg4y5r3zarvary0c5xw7kw5rljs90", "BC1QR508D6QEJXTDG4Y5R3ZARVARYV98GJ9P", "tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sL5k7",170 "bc1zw508d6qejxtdg4y5r3zarvaryvqyzf3du", "tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3pjxtptv", "bc1gmk9yu",171 // BIP-350172 "tc1qw508d6qejxtdg4y5r3zarvary0c5xw7kg3g4ty", "bc1p0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vqh2y7hd", "tb1z0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vqglt7rf",173 "BC1S0XLXVLHEMJA6C4DQV22UAPCTQUPFHLXM9H8Z3K2E72Q4K9HCZ7VQ54WELL", "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kemeawh", "tb1q0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vq24jc47",174 "bc1p38j9r5y49hruaue7wxjce0updqjuyyx0kh56v8s25huc6995vvpql3jow4", "BC130XLXVLHEMJA6C4DQV22UAPCTQUPFHLXM9H8Z3K2E72Q4K9HCZ7VQ7ZWS8R", "bc1pw5dgrnzv",175 "bc1p0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7v8n0nx0muaewav253zgeav", "BC1QR508D6QEJXTDG4Y5R3ZARVARYV98GJ9P", "tb1p0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vq47Zagq",176 "bc1p0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7v07qwwzcrf", "tb1p0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vpggkg4j", "bc1gmk9yu",177 ]178 for s in invalid {179 #expect(SegWitAddress.decode(s, hrp: "bc") == nil, "\(s)")180 #expect(SegWitAddress.decode(s, hrp: "tb") == nil, "\(s)")181 }182 }183 @Test func regroupingIsStrict() {184 #expect(Bech32.toWords([0xff]) == [31, 28])185 #expect(Bech32.fromWords([31, 28]) == [0xff])186 #expect(Bech32.fromWords([31, 29]) == nil) // non-zero padding187 #expect(Bech32.fromWords([31, 28, 0]) == nil) // a leftover whole word188 #expect(Bech32.fromWords([32]) == nil)189 #expect(Bech32.fromWords([UInt8]()) == [])190 }191}192193@Suite struct CashAddrTests {194 @Test func specificationVectors() {195 // CashAddr specification: legacy ↔ CashAddr, then the larger hash sizes and other prefixes / types196 let vectors: [(String, UInt8, String)] = [197 ("bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a", 0, "76A04053BDA0A88BDA5177B86A15C3B29F559873"),198 ("bitcoincash:qr6m7j9njldwwzlg9v7v53unlr4jkmx6eylep8ekg2", 0, "F5BF48B397DAE70BE82B3CCA4793F8EB2B6CDAC9"),199 ("bchtest:pr6m7j9njldwwzlg9v7v53unlr4jkmx6eyvwc0uz5t", 1, "F5BF48B397DAE70BE82B3CCA4793F8EB2B6CDAC9"),200 ("pref:pr6m7j9njldwwzlg9v7v53unlr4jkmx6ey65nvtks5", 1, "F5BF48B397DAE70BE82B3CCA4793F8EB2B6CDAC9"),201 ("prefix:0r6m7j9njldwwzlg9v7v53unlr4jkmx6ey3qnjwsrf", 15, "F5BF48B397DAE70BE82B3CCA4793F8EB2B6CDAC9"),202 ("bitcoincash:q9adhakpwzztepkpwp5z0dq62m6u5v5xtyj7j3h2ws4mr9g0", 0, "7ADBF6C17084BC86C1706827B41A56F5CA32865925E946EA"),203 ("bitcoincash:qgagf7w02x4wnz3mkwnchut2vxphjzccwxgjvvjmlsxqwkcw59jxxuz", 0, "3A84F9CF51AAE98A3BB3A78BF16A6183790B18719126325BFC0C075B"),204 ("bitcoincash:qvch8mmxy0rtfrlarg7ucrxxfzds5pamg73h7370aa87d80gyhqxq5nlegake", 0, "3173EF6623C6B48FFD1A3DCC0CC6489B0A07BB47A37F47CFEF4FE69DE825C060"),205 ]206 for (address, type, hash) in vectors {207 let prefix = String(address.split(separator: ":")[0])208 guard let d = CashAddr.decode(address) else { Issue.record("\(address) must decode"); continue }209 #expect(d.prefix == prefix); #expect(d.type == type); #expect(hex(d.hash).uppercased() == hash)210 #expect(CashAddr.encode(prefix: prefix, type: type, hash: d.hash) == address)211 #expect(CashAddr.decode(address.uppercased()) == d)212 #expect(CashAddr.decode(String(address.split(separator: ":")[1]), defaultPrefix: prefix) == d)213 #expect(CashAddr.decode(String(address.split(separator: ":")[1]), defaultPrefix: prefix + "x") == nil) // the prefix is part of the checksum214 }215 // the specification's legacy equivalents, through Base58Check216 #expect(Base58Check.decode("1BpEi6DfDAUFd7GtittLSdBeYJvcoaVggu") == [0] + unhex("76A04053BDA0A88BDA5177B86A15C3B29F559873"))217 #expect(CashAddr.decode("bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6b") == nil)218 #expect(CashAddr.decode("bitcoincash:Qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a") == nil)219 #expect(CashAddr.decode("qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a") == nil) // no prefix to check against220 #expect(CashAddr.encode(prefix: "bitcoincash", type: 0, hash: [UInt8](repeating: 0, count: 21)) == nil)221 #expect(CashAddr.encode(prefix: "BitcoinCash", type: 0, hash: [UInt8](repeating: 0, count: 20)) == nil)222 }223}224