Repository Public
1// SP Wallet Core2// File: Tests/SPWalletCoreTests/NFTTests.swift3// Description: The NFT domain: canonical bytes of the three passkey-approved objects against the backend's own vectors, strict4// refusals, decoding of every answer shape, the request contract of every route, and the prepare → check → bind →5// approve path (intent ≠ request, review ≠ intent, challenge mismatch, expiry).6// Fixtures (Fixtures/nft-*.json) are copied in shape from the TypeScript that produces them:7// nft-capabilities services/api/src/nft/service.ts `capabilities()` + test/nft-api.test.ts (matrix expectations)8// nft-list services/api/src/nft/routes.ts `summary` + the `GET /nfts` answer9// nft-item-* packages/nft/src/model.ts `NftAsset` + service.ts `present()` + transfer.ts `transferVerdict`10// nft-activity packages/nft/src/model.ts `NftEvent` + service.ts `activity()` + transfer-routes.ts `nftOutcomeRecorder`11// nft-collection services/api/src/nft/provider.ts `CollectionInfo` + service.ts `collection()`12// nft-market* packages/nft/src/market.ts + services/api/src/nft/market/{service,routes}.ts13// nft-valuation services/api/src/nft/market/routes.ts `GET /nfts/valuation`14// nft-utxo-locks services/api/src/nft/transfer-routes.ts `GET /utxo-locks` + utxo.ts `UtxoRow`15// Vectors: Vectors/SPW-NFT-INTENT-v1, SPW-NFT-ALLOW-v1, SPW-UTXO-LOCKS-v1 (lead) + Vectors/nft-edge-cases.json, all16// generated by packages/core/src/nft-intent.ts itself (`npx tsx /tmp/spw-vectors-nft.mts`).17//18// Author: Simon-Pierre Boucher19// Contact: contact@spboucher.ai20import Foundation21import Testing22@testable import SPWalletCore2324private enum NFTT {25 static let rp = "wallet.example.test"26 /** Inside the approval window of the lead's NFT intent vectors (expiresAt 1794000120). */27 static let now = Date(timeIntervalSince1970: 1_794_000_010)2829 static func fixture(_ name: String) throws -> String { String(decoding: try TestResources.data(name, in: "Fixtures"), as: UTF8.self) }30 static func decode<T: Decodable>(_ name: String, as type: T.Type = T.self) throws -> T { try APICoding.decoder().decode(T.self, from: try TestResources.data(name, in: "Fixtures")) }31 static func text(_ v: JSONValue) throws -> String { String(decoding: try APICoding.encoder().encode(v), as: UTF8.self) }32 static func vector(_ name: String, in file: String) throws -> CanonicalVector { try #require(try CanonicalVector.load(file).first { $0.name == name }) }33 static func options(_ hashHex: String, rp: String = rp) -> JSONValue {34 ["challenge": .string(Data(hex: hashHex)!.base64URL), "rpId": .string(rp), "userVerification": "required", "timeout": 180000, "allowCredentials": [["id": "Y3JlZA", "type": "public-key", "transports": ["internal"]]]]35 }36 static func setting(_ v: JSONValue, _ path: [String], _ value: JSONValue?) -> JSONValue {37 guard case .object(var o) = v, let k = path.first else { return value ?? .null }38 if path.count == 1 { o[k] = value } else { o[k] = setting(o[k] ?? .object([:]), Array(path.dropFirst()), value) }39 return .object(o)40 }4142 /** The asset key an intent is about, as the inventory names it. */43 static func key(of intent: JSONValue) -> String {44 let asset = intent["asset"]!.stringValue!, network = intent["network"]!.stringValue!45 if let t = intent["tokenId"]?.stringValue { return "evm:\(network):\(asset.lowercased())/\(t)" }46 return "sol:\(network):\(asset)"47 }48 static func request(for intent: JSONValue, to: String? = nil, quantity: String? = nil, standard: NFTTransferStandard? = nil, key: String? = nil) -> NFTTransferRequest {49 NFTTransferRequest(key: key ?? Self.key(of: intent), standard: standard ?? NFTTransferStandard(rawValue: intent["standard"]!.stringValue!)!,50 to: to ?? intent["to"]!.stringValue!, quantity: quantity ?? intent["quantity"]!.stringValue!, from: intent["from"]!.stringValue!)51 }52 /** The answer of `POST /nfts/transfer/prepare` (transfer-routes.ts) around a canonical intent: proposal (`nftView`), review (`NftReview`), options. */53 static func prepareAnswer(intent: JSONValue, hashHex: String, challengeHex: String? = nil) -> JSONValue {54 let s = { (k: String) in intent[k]! }55 let review: JSONValue = [56 "key": .string(key(of: intent)), "network": s("network"), "networkName": "Ethereum", "standard": s("standard"), "method": .string(NFTTransferStandard(rawValue: s("standard").stringValue!)!.method),57 "asset": s("asset"), "tokenId": intent["tokenId"] ?? .null, "quantity": s("quantity"), "program": s("program"), "from": s("from"), "to": s("to"), "toKind": "account",58 "fee": ["estimate": "1800000000000000", "max": s("maxFee"), "symbol": "ETH", "decimals": 18, "rent": nil], "warnings": ["contract_recipient"],59 "simulation": ["ok": true, "detail": "eth_call from the wallet address succeeded", "used": "61234",60 "changes": [["code": "evm_owner_of_token", "params": ["tokenId": "8520"], "what": "owner of token 8520", "before": s("from"), "after": s("to")]]],61 "verified": ["standard": "ERC-165: ERC-721 declared, and ownerOf answers", "ownership": "ownerOf(8520) = this wallet", "endpoints": 2, "at": "2026-11-17T15:00:00.000Z"],62 "accounts": [], "creatorMetadata": ["name": "Ape #8520", "collectionName": nil, "imageId": "m0123456789abcdef0123456789abcdef01234567"],63 ]64 let proposal: JSONValue = [65 "id": s("proposalId"), "state": "pending_approval", "network": s("network"), "networkName": "Ethereum", "asset": s("asset"), "symbol": "NFT", "decimals": 0,66 "amount": s("quantity"), "amountDisplay": s("quantity"), "from": s("from"), "to": s("to"), "note": "", "memo": nil, "feeEstimate": "1800000000000000", "maxFee": s("maxFee"),67 "feeSymbol": "ETH", "feeDecimals": 18, "feeDisplay": "0.0018", "maxFeeDisplay": "0.003", "warnings": ["contract_recipient"], "intentHash": .string(hashHex), "txid": nil, "explorer": nil,68 "confirmations": 0, "error": nil, "errorCode": nil, "errorParams": nil, "createdAt": "2026-11-17T15:00:00.000Z", "updatedAt": "2026-11-17T15:00:00.000Z", "expiresAt": "2026-11-17T15:03:00.000Z",69 "broadcastAt": nil, "finalizedAt": nil, "kind": "nft", "swap": nil, "bridge": nil, "xswap": nil, "execution": nil, "nft": review,70 ]71 return ["proposal": proposal, "intent": intent, "review": review, "options": options(challengeHex ?? hashHex), "replayed": false]72 }73}7475private final class StubAuthenticator: PasskeyAuthenticator, @unchecked Sendable {76 private let lock = NSLock()77 private var _asked: [PasskeyRequestOptions] = []78 var asked: [PasskeyRequestOptions] { lock.withLock { _asked } }79 func assert(_ options: PasskeyRequestOptions, rpId: String) async throws -> PasskeyAssertion {80 lock.withLock { _asked.append(options) }81 return PasskeyAssertion(credentialId: Data("cred".utf8), clientDataJSON: Data("{}".utf8), authenticatorData: Data([1, 2, 3]), signature: Data([4, 5, 6]), userHandle: nil)82 }83 func register(_ options: PasskeyCreationOptions, rpId: String) async throws -> PasskeyRegistration { throw PasskeyError.notAvailable("stub") }84}8586// MARK: - canonical objects8788@Suite struct NFTCanonicalTests {89 static let files = ["SPW-NFT-INTENT-v1.json", "SPW-NFT-ALLOW-v1.json", "SPW-UTXO-LOCKS-v1.json", "nft-edge-cases.json"]9091 @Test func everyVectorReproducesTheBackendBytesAndHash() throws {92 var seen: [String: Int] = [:]93 for file in Self.files {94 for v in try CanonicalVector.load(file) {95 let object: any PasskeyApprovable96 switch v.domain {97 case NFTIntent.domain: object = try NFTIntent(served: v.object)98 case NFTAllowIntent.domain: object = try NFTAllowIntent(served: v.object)99 case UTXOLockIntent.domain: object = try UTXOLockIntent(served: v.object)100 default: Issue.record("unexpected domain \(v.domain) in \(file)"); continue101 }102 #expect(try object.canonicalBytes().hex == v.canonicalHex, "canonical bytes of \(file) \(v.name)")103 #expect(try object.approvalDigest().hex == v.hashHex, "hash of \(file) \(v.name)")104 #expect(try object.canonicalBytes().starts(with: Data(v.domain.utf8) + [0]))105 seen[v.domain, default: 0] += 1106 }107 }108 #expect((seen[NFTIntent.domain] ?? 0) >= 13 && (seen[NFTAllowIntent.domain] ?? 0) >= 4 && (seen[UTXOLockIntent.domain] ?? 0) >= 6)109 }110111 @Test func theVectorsCoverEveryStandardAndEveryOptionalField() throws {112 let intents = try (CanonicalVector.load("SPW-NFT-INTENT-v1.json") + CanonicalVector.load("nft-edge-cases.json")).filter { $0.domain == NFTIntent.domain }.map { try NFTIntent(served: $0.object) }113 for s in NFTTransferStandard.allCases { #expect(intents.contains { $0.standard == s }, "standard \(s.rawValue)") }114 #expect(intents.contains { $0.evm != nil && $0.tokenId == "0" } && intents.contains { $0.standard == .erc1155 && $0.quantity != "1" })115 #expect(intents.contains { $0.sol?.createAta == true } && intents.contains { $0.sol?.createAta == false } && intents.contains { $0.sol != nil && $0.sol?.createAta == nil })116 #expect(intents.contains { $0.sol?.ruleSet != nil } && intents.contains { $0.sol?.collection != nil } && intents.contains { $0.sol?.tokenProgram == "token2022" } && intents.contains { $0.sol?.tokenProgram == "token" })117 #expect(intents.contains { $0.sol?.ruleSet != nil && $0.sol?.collection != nil && $0.sol?.createAta != nil })118 let allows = try (CanonicalVector.load("SPW-NFT-ALLOW-v1.json")).map { try NFTAllowIntent(served: $0.object) }119 #expect(allows.contains { $0.action == .add } && allows.contains { $0.action == .remove })120 let locks = try (CanonicalVector.load("SPW-UTXO-LOCKS-v1.json") + CanonicalVector.load("nft-edge-cases.json").filter { $0.domain == UTXOLockIntent.domain }).map { try UTXOLockIntent(served: $0.object) }121 for r in UTXOLockIntent.Reason.allCases { #expect(locks.contains { $0.reason == r }, "reason \(r.rawValue)") }122 #expect(locks.contains { $0.action == .lock } && locks.contains { $0.action == .unlock } && locks.contains { $0.outpoints.count >= 3 } && locks.contains { $0.outpoints.contains { $0.vout == 4_294_967_295 } })123 }124125 @Test func tokenIdIsSerializedAfterThePolicyVersionsNotNextToTheAsset() throws {126 let i = try NFTIntent(served: NFTT.vector("erc721", in: "SPW-NFT-INTENT-v1.json").object)127 let names = i.fields().map(\.0)128 #expect(names.firstIndex(of: "tokenId") == names.firstIndex(of: "nftPolicyVersion")! + 1)129 #expect(names.prefix(9) == ["v", "kind", "proposalId", "keyId", "network", "chainRef", "standard", "asset", "quantity"])130 }131132 @Test func aMatchingChallengeVerifiesAndAnyOtherIsRefused() throws {133 let v = try NFTT.vector("erc721", in: "SPW-NFT-INTENT-v1.json"), intent = try NFTIntent(served: v.object)134 let ok = PasskeyRequestOptions(challenge: Data(hex: v.hashHex)!.base64URL, rpId: NFTT.rp)135 #expect(try ApprovalBinding.verify(intent, options: ok, rpId: NFTT.rp).digest.hex == v.hashHex)136 var other = Data(hex: v.hashHex)!; other[31] ^= 1137 #expect(throws: ApprovalError.challengeMismatch) { try ApprovalBinding.verify(intent, options: .init(challenge: other.base64URL, rpId: NFTT.rp), rpId: NFTT.rp) }138 // the hash of the same fields under the fund-transfer domain is not the NFT challenge139 var w = CanonicalWriter(domain: "SPW-INTENT-v1"); for (k, val) in intent.fields() { w.field(k, val) }140 #expect(w.data != (try intent.canonicalBytes()))141 #expect(throws: ApprovalError.wrongRelyingParty("evil.example")) { try ApprovalBinding.verify(intent, options: .init(challenge: ok.challenge, rpId: "evil.example"), rpId: NFTT.rp) }142 }143144 @Test func changingAnyFieldChangesTheDigest() throws {145 let base = try NFTT.vector("erc721", in: "SPW-NFT-INTENT-v1.json").object, digest = try NFTIntent(served: base).approvalDigest()146 let changes: [([String], JSONValue)] = [147 (["to"], "0x90F79bf6EB2c4f870365E785982E1f101E93b906"), (["tokenId"], "8521"), (["asset"], "0x90F79bf6EB2c4f870365E785982E1f101E93b906"), (["quantity"], "2"), (["network"], "base"), (["chainRef"], "8453"),148 (["standard"], "erc1155"), (["maxFee"], "3000000000000001"), (["expiresAt"], 1_794_000_121), (["nftPolicyVersion"], 3), (["program"], "0x90F79bf6EB2c4f870365E785982E1f101E93b906"), (["evm", "nonce"], 32), (["evm", "gasLimit"], "120001"),149 ]150 for (path, value) in changes { #expect(try NFTIntent(served: NFTT.setting(base, path, value)).approvalDigest() != digest, "field \(path.joined(separator: "."))") }151 }152153 @Test func anUnknownFieldIsARefusalInEveryObjectAndSection() throws {154 let evm = try NFTT.vector("erc721", in: "SPW-NFT-INTENT-v1.json").object, sol = try NFTT.vector("solana-metaplex-pnft-with-rule-set", in: "SPW-NFT-INTENT-v1.json").object155 let allow = try NFTT.vector("add-evm", in: "SPW-NFT-ALLOW-v1.json").object, lock = try NFTT.vector("lock-one-owner", in: "SPW-UTXO-LOCKS-v1.json").object156 #expect(throws: ApprovalError.self) { try NFTIntent(served: NFTT.setting(evm, ["data"], "0xa22cb465")) } // no calldata can ride along157 #expect(throws: ApprovalError.self) { try NFTIntent(served: NFTT.setting(evm, ["evm", "data"], "0xdeadbeef")) }158 #expect(throws: ApprovalError.self) { try NFTIntent(served: NFTT.setting(evm, ["operator"], "0x90F79bf6EB2c4f870365E785982E1f101E93b906")) }159 #expect(throws: ApprovalError.self) { try NFTIntent(served: NFTT.setting(sol, ["sol", "instructions"], [])) }160 #expect(throws: ApprovalError.self) { try NFTIntent(served: NFTT.setting(sol, ["sol", "authorizationData"], "x")) }161 #expect(throws: ApprovalError.self) { try NFTAllowIntent(served: NFTT.setting(allow, ["label"], "mine")) }162 #expect(throws: ApprovalError.self) { try UTXOLockIntent(served: NFTT.setting(lock, ["all"], true)) }163 var first = lock["outpoints"]![0]!; first = NFTT.setting(first, ["value"], "546")164 #expect(throws: ApprovalError.self) { try UTXOLockIntent(served: NFTT.setting(lock, ["outpoints"], [first])) }165 // through the decoder too: a served answer with an unknown field does not decode166 #expect(throws: DecodingError.self) { try NFTT.setting(evm, ["memo"], "x").decode(NFTIntent.self) }167 }168169 @Test func whatTheBackendSchemasRefuseIsRefused() throws {170 let evm = try NFTT.vector("erc721", in: "SPW-NFT-INTENT-v1.json").object, sol = try NFTT.vector("solana-metaplex-core-in-collection", in: "SPW-NFT-INTENT-v1.json").object171 let allow = try NFTT.vector("add-evm", in: "SPW-NFT-ALLOW-v1.json").object, lock = try NFTT.vector("lock-three-ord-order-kept", in: "SPW-UTXO-LOCKS-v1.json").object172 let bad: [(JSONValue, [String], JSONValue?)] = [173 (evm, ["kind"], "transfer"), (evm, ["v"], 2), (evm, ["standard"], "metaplex-bubblegum"), (evm, ["standard"], "ordinals-inscription"), (evm, ["tokenId"], "08520"), (evm, ["tokenId"], "0x2148"), (evm, ["tokenId"], nil),174 (evm, ["tokenId"], 8520), (evm, ["quantity"], "1.0"), (evm, ["quantity"], 1), (evm, ["maxFee"], "-1"), (evm, ["proposalId"], "not-a-uuid"), (evm, ["network"], "Ethereum"), (evm, ["asset"], "0xBC4C"), (evm, ["to"], ""),175 (evm, ["expiresAt"], 0), (evm, ["policyVersion"], -1), (evm, ["evm", "nonce"], -1), (evm, ["evm", "nonce"], "31"), (evm, ["evm"], nil),176 (evm, ["sol"], sol["sol"]!), // two chain sections177 (sol, ["sol", "computeUnitLimit"], 400_001), (sol, ["sol", "computeUnitLimit"], 0), (sol, ["sol", "tokenProgram"], "token2023"), (sol, ["sol", "createAta"], "1"), (sol, ["sol", "collection"], "0OIl"), (sol, ["sol", "ruleSet"], "short"),178 ]179 for (base, path, value) in bad {180 let o: JSONValue = value == nil && path == ["evm"] ? .object(base.objectValue!.filter { $0.key != "evm" }) : NFTT.setting(base, path, value ?? .null)181 #expect(throws: ApprovalError.self, "\(path.joined(separator: ".")) = \(String(describing: value))") { try NFTIntent(served: o) }182 }183 for (path, value) in [(["kind"], JSONValue.string("nft-transfer")), (["action"], "replace"), (["address"], "0x1"), (["requestId"], "x"), (["createdAt"], "1794000000")] {184 #expect(throws: ApprovalError.self, "allow \(path)") { try NFTAllowIntent(served: NFTT.setting(allow, path, value)) }185 }186 let p0 = lock["outpoints"]![0]!187 for (path, value) in [(["kind"], JSONValue.string("nft-allow")), (["action"], "drop"), (["reason"], "api"), (["outpoints"], []), (["outpoints"], [p0, p0]), (["outpoints"], [NFTT.setting(p0, ["vout"], 4_294_967_296)]),188 (["outpoints"], [NFTT.setting(p0, ["txid"], "AB")]), (["outpoints"], .array(Array(repeating: p0, count: 101)))] {189 #expect(throws: ApprovalError.self, "locks \(path) \(value)") { try UTXOLockIntent(served: NFTT.setting(lock, path, value)) }190 }191 }192193 @Test func theThreeObjectsAndTheFundTransferIntentAreNotInterchangeable() throws {194 let nft = try NFTT.vector("erc721", in: "SPW-NFT-INTENT-v1.json").object, allow = try NFTT.vector("add-evm", in: "SPW-NFT-ALLOW-v1.json").object195 let lock = try NFTT.vector("lock-one-owner", in: "SPW-UTXO-LOCKS-v1.json").object, fund = try #require(try CanonicalVector.load("SPW-INTENT-v1.json").first).object196 #expect(throws: ApprovalError.self) { try Intent(served: nft) }197 #expect(throws: ApprovalError.self) { try NFTIntent(served: fund) }198 #expect(throws: ApprovalError.self) { try NFTIntent(served: allow) }199 #expect(throws: ApprovalError.self) { try NFTAllowIntent(served: lock) }200 #expect(throws: ApprovalError.self) { try UTXOLockIntent(served: allow) }201 #expect(Set([NFTIntent.domain, NFTAllowIntent.domain, UTXOLockIntent.domain, "SPW-INTENT-v1"]).count == 4)202 }203204 @Test func theImpliedCallOfEachStandardIsTheBackends() {205 // NFT_TRANSFER_METHOD of packages/core/src/nft-intent.ts206 #expect(NFTTransferStandard.erc721.method == "safeTransferFrom(address,address,uint256)")207 #expect(NFTTransferStandard.erc1155.method == "safeTransferFrom(address,address,uint256,uint256,bytes) — data empty")208 #expect(NFTTransferStandard.metaplexCore.method == "Core TransferV1 (no compression proof)")209 #expect(NFTTransferStandard.allCases.map(\.rawValue) == ["erc721", "erc1155", "spl-token-2022", "metaplex-token-metadata", "metaplex-pnft", "metaplex-core"])210 #expect(NFTStandard.metaplexBubblegum.transferStandard == nil && NFTStandard.ordinalsInscription.transferStandard == nil && NFTStandard.evmNonstandard.transferStandard == nil && NFTStandard.splToken.transferStandard == nil)211 }212}213214// MARK: - decoding215216@Suite struct NFTDecodingTests {217 @Test func capabilityMatrixIsReadAsServed() throws {218 let c: NFTCapabilities = try NFTT.decode("nft-capabilities.json")219 let sol = try #require(c.chain("solana")), eth = try #require(c.chain("ethereum")), btc = try #require(c.chain("bitcoin")), ada = try #require(c.chain("cardano"))220 #expect(sol.inventory == "partial" && sol.reason == "sections_blocked:compressed" && sol.unlockedBy == "NFT_SOLANA_DAS_URL" && sol.sections.count == 2 && sol.sections[1].status == "blocked_by_provider")221 #expect(sol.canPrepareTransfer(of: .metaplexPNFT) && !sol.canPrepareTransfer(of: .metaplexBubblegum) && sol.standards.contains(.metaplexBubblegum))222 #expect(eth.inventory == "blocked_by_provider" && eth.canPrepareTransfer(of: .erc1155) && eth.lookup && eth.manualAdd && !eth.marketRead)223 #expect(!btc.canPrepareTransfers && btc.transferReason == "ordinals_transfer_not_supported" && btc.receive && !btc.lookup && btc.standards == [.ordinalsInscription])224 #expect(ada.inventory == "unsupported" && ada.transferReason == "no_adapter" && !ada.receive && ada.standards.isEmpty)225 #expect(!c.anyMarketWrite && c.mediaMaxBytes == 26_214_400 && c.limits?["dailyBytes"] == 2_147_483_648)226 #expect(c.providers.first { $0.id == "ordinals" }?.sends == "not_built" && c.providers.first { $0.id == "opensea" }?.unlockedBy == "OPENSEA_API_KEY")227 #expect(c.budget?.first?.bytes == "482113")228 }229230 @Test func inventoryRowsKeepSpamAndBlockReasonsAsStatements() throws {231 let l: NFTList = try NFTT.decode("nft-list.json")232 #expect(l.total == 7 && l.hiddenSpam == 3 && l.cursor == 2 && l.sync?.running == ["solana"] && l.sync?.lastSyncedAt?["solana"] != nil)233 #expect(l.valuation?.state == "unavailable" && l.valuation?.reason == "no_reliable_valuation")234 let a = l.items[0], b = l.items[1]235 #expect(a.standard == .erc721 && a.tokenId == "8520" && a.transferable == true && a.spam == nil && a.image?.id == "m0123456789abcdef0123456789abcdef01234567" && a.collection?.verifiedOnChain == .unsupported)236 #expect(b.standard == .metaplexBubblegum && b.transferable == false && b.transferBlockedBy == "compressed_transfer_not_supported" && b.spam?.by == "solana-das" && b.stale && b.displayName == "FREE AIRDROP" && b.verifiedAt == nil)237 }238239 @Test func itemPageERC721KeepsCreatorContentAsInertData() throws {240 let a: NFTAsset = try NFTT.decode("nft-item-erc721.json")241 #expect(a.standard == .erc721 && a.tokenId == "8520" && a.contractAddress == "0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D" && a.assetAddress == a.contractAddress && a.quantity == "1")242 #expect(a.supply == .unknown(reason: nil) && a.royaltyBps == .unknown(reason: "erc2981 not read") && a.creators == .unsupported && a.ownership.frozen == .unsupported && a.ownership.owner.value == a.ownerAddress)243 #expect(a.ownership.source.isChainVerified && a.sources.map(\.category) == ["onchain", "creator_metadata"] && a.collection?.source?.blockRef?.number == "21000000")244 // untrusted strings stay strings; a javascript: link is never a link; the animation URL is text and an opaque proxy id245 #expect(a.metadata.description == "<script>alert(1)</script> a description kept as text" && a.metadata.externalUrl == "javascript:alert(1)" && a.metadata.safeExternalURL == nil)246 #expect(a.metadata.raw?["animation_url"]?.stringValue == "https://evil.example/run.html")247 #expect(a.media[1].role == "animation" && a.media[1].sourceUri == "https://evil.example/run.html" && a.media[1].isActiveContent && !a.media[0].isActiveContent)248 #expect(a.metadata.attributes.map(\.malformed) == [false, false, true] && a.metadata.attributes[1].value == .int(7) && a.metadata.attributes[1].maxValue == "10" && a.metadata.attributes[2].raw == .string("not an object"))249 #expect(a.metadata.traitStatistics?.computed == false)250 #expect(a.capabilities.transferable && a.capabilities.marketActions == false && a.capabilities.marketBlockedBy == "market_not_integrated")251 #expect(a.transfer?.transferable == true && a.transfer?.route == NFTTransferStandard.erc721.method && a.transfer?.standard.transferStandard == .erc721)252 #expect(a.marketSources?.first?.state == "needs_key" && a.spamFlaggedBy == nil && a.origin == "manual" && a.verifiedAt != nil && a.goneAt == nil)253 // offline snapshots: the model survives a round trip254 #expect(try JSONValue.from(a).decode(NFTAsset.self) == a)255 }256257 @Test func itemPageSolanaCoreLookupNotHeld() throws {258 // the lookup of test/nft-api.test.ts: a Core asset another wallet holds — quantity "0" is a value, not an absence259 let a: NFTAsset = try NFTT.decode("nft-item-sol-core.json")260 #expect(a.standard == .metaplexCore && a.tokenId == nil && a.mintAddress == a.assetId && a.quantity == "0" && a.supply.value == "1" && a.ownerAddress == nil && a.origin == "lookup")261 #expect(a.collection?.verifiedOnChain == .known(true) && a.creators.value?.first?.share == 100 && a.royaltyBps.value == 500 && a.ownership.delegate == NFTKnown<String>.none && a.ownership.frozen.value == false)262 #expect(!a.ownership.heldByWallet && a.capabilities.transferBlockedBy == ["not_in_wallet"] && a.capabilities.transferWarnings == ["core_collection_permanent_delegate", "mutable_metadata"] && a.transfer == nil)263 #expect(a.ownership.source.isStale && a.metadata.mutable.value == true && a.metadata.safeExternalURL?.host == "phygitals.com" && a.spamFlaggedBy == "solana-das")264 let m = try #require(a.market)265 #expect(m.source.category == "market" && m.source.source == "magiceden" && m.listed.value == true && m.listingPrice.value?.display == "1.5" && m.collectionFloor.value?.amount == "900000000")266 #expect(m.bestOffer == .unknown(reason: "not requested from this source") && m.lastSale.value == nil)267 #expect(a.displayName == "2016 Pokemon XY Special Box Promo")268 #expect(throws: ApprovalError.self) { try NFTTransferRequest(item: try NFTT.decode("nft-item-sol-core.json", as: NFTAsset.self).withStandard("metaplex-bubblegum"), to: "x") }269 }270271 @Test func aStateOrStandardOfANewerServerIsKeptVerbatim() throws {272 let k = try JSONDecoder().decode(NFTKnown<String>.self, from: Data(#"{"state":"pending_index","value":"x"}"#.utf8))273 #expect(k == .unrecognized("pending_index") && k.value == nil)274 #expect(throws: DecodingError.self) { try JSONDecoder().decode(NFTKnown<String>.self, from: Data(#"{"state":"known"}"#.utf8)) }275 #expect(try JSONDecoder().decode(NFTKnown<Bool>.self, from: Data(#"{"state":"known","value":false}"#.utf8)) == .known(false))276 let s = try JSONDecoder().decode(NFTStandard.self, from: Data(#""erc6551-account""#.utf8))277 #expect(s.rawValue == "erc6551-account" && s.transferStandard == nil)278 }279280 @Test func eventsAndCollections() throws {281 let a: NFTActivity = try NFTT.decode("nft-activity.json")282 #expect(a.events.count == 2 && a.completeness == "recent_window" && a.canLoadOlder && a.cursor?.hasPrefix("20999000|") == true && a.error == nil)283 #expect(a.events[0].type == "transfer-out" && a.events[0].index == "spw-transfer" && a.events[0].price == nil && !a.events[0].isFinal && a.events[0].date != nil)284 #expect(a.events[1].type == "sale" && a.events[1].price?.display == "30" && a.events[1].at == nil && a.events[1].isFinal && a.events[1].source.category == "computed")285 #expect(a.events[1].marketProgram?.name == "Seaport 1.6" && a.events[1].market?.washTrade == .unknown(reason: nil) && a.events[1].market?.fees?.first?.bps == 50)286 let c: NFTCollectionDetail = try NFTT.decode("nft-collection.json")287 #expect(c.info?.standard == .metaplexCore && c.info?.size.value == "8421" && c.metadata?.imageId?.hasPrefix("m") == true && c.held == 2 && c.error == nil)288 let counts = try JSONDecoder().decode([NFTCollectionCount].self, from: Data(#"[{"collection_key":"sol:solana:phygZDQZJZVHvJGYPGoKPYUtXw7mstSYtTtcuh8LJcC","chain":"solana","n":2,"name":null}]"#.utf8)) // store.ts collectionCounts289 #expect(counts[0].count == 2 && counts[0].collectionKey.hasPrefix("sol:solana:"))290 }291292 @Test func marketAnswerKeepsOneRowPerSourceWithItsSourceAndDate() throws {293 let m: NFTMarketAnswer = try NFTT.decode("nft-market.json")294 let os = m.sources[0], me = m.sources[1]295 #expect(os.status.isOK && os.status.stale && os.status.code == "provider_rate_limited" && os.status.fetchedAt == ISO8601.parse("2026-11-17T14:40:00.000Z") && os.status.stamp?.category == "market" && os.status.attribution?.text == "Powered by OpenSea")296 #expect(os.ask.value?.price.display == "31.5" && os.ask.value?.price.precision == "exact" && os.ask.value?.protocol?.name == "seaport" && os.ask.value?.fees?.first?.kind == "creator_royalty")297 #expect(os.bestOffer.value?.scope == "collection" && os.bestOffer.value?.price.currency.id == "ethereum:0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2" && os.bestOffer.value?.price.precision == "source_decimal")298 #expect(os.lastSale.value?.at == "2026-10-01T00:00:00Z" && os.collectionFloor.value?.display == "28" && os.verification?.by == "OpenSea" && os.rarity?.value?.outOf == "10000" && os.flags?.nsfw == .unknown(reason: nil))299 #expect(!me.status.isOK && me.status.state == "needs_key" && me.status.unlockedBy == "NFT_MARKET_MAGICEDEN" && me.status.stamp == nil && me.ask.value == nil && me.listed == .unknown(reason: nil))300 #expect(m.contradictions.first?.field == "ask" && m.rates["ethereum:native"]?.usd == "3120.55" && m.rates["ethereum:native"]?.source == "coingecko")301 // market writes are not built: every action is served unavailable, and the item has no value302 #expect(m.actions.count == 7 && !m.anyActionAvailable && m.actions.allSatisfy { $0.reason == "market_writes_not_built" })303 #expect(m.value?.state == "unavailable" && m.external?.notice.walletConnect == false && m.external?.notice.keyExport == false && m.external?.links.first?.name == "OpenSea")304 }305306 @Test func marketCollectionProvidersTraitsOrdersEventsAndFloorEstimate() throws {307 let c: NFTCollectionMarketAnswer = try NFTT.decode("nft-market-collection.json")308 let s = c.sources[0]309 #expect(s.floor.value?.display == "28" && s.volumes[0].volume == nil && s.volumes[0].reported?.symbol == "ETH" && s.volumes[1].volume?.display == "120" && s.listedCount == .unknown(reason: nil) && s.totalSupply.value == "9998")310 #expect(s.traits.value?.total == "9998" && s.traits.value?.truncated == true && s.traits.value?.categories[0].values[1].count == "1229" && s.imageId != nil && s.bannerId == nil && s.definitions?["floor"] != nil)311 let p: NFTMarketProviders = try NFTT.decode("nft-market-providers.json")312 #expect(p.providers[0].state == "on" && p.providers[0].sends == "mint_only" && p.providers[0].budget?.day.limit == 5000 && p.providers[0].budget?.day.date == "2026-11-17" && p.providers[0].ttlSeconds?["collection"] == 600 && p.providers[0].verification == "live")313 #expect(p.providers[1].state == "needs_key" && p.providers[1].budget == nil && p.providers[1].sends == "nothing_until_enabled" && p.actions.allSatisfy { !$0.available } && p.notice?.outsideWallet == true)314 let e: NFTFloorEstimate = try NFTT.decode("nft-valuation.json")315 #expect(e.enabled && e.state == "unavailable" && e.excludedFromWalletTotal && e.estimate?.indicativeUsd == "378.90" && e.estimate?.collectionsCounted == 1 && e.estimate?.collectionsWithoutFloor == 1)316 #expect(e.estimate?.collections[0].used?.indicative.amount == "1800000000" && e.estimate?.collections[1].used == nil && e.estimate?.collections[1].reason == "no_api_key" && e.estimate?.rates["solana:native"]?.cad == nil)317 let off = try APICoding.decoder().decode(NFTFloorEstimate.self, from: Data(#"{"enabled":false,"state":"unavailable","reason":"no_reliable_valuation","excludedFromWalletTotal":true,"estimate":null}"#.utf8))318 #expect(!off.enabled && off.estimate == nil)319 // market/service.ts `orders()` and `events()`; market/routes.ts `/market/traits`320 let status = #"{"provider":"opensea","name":"OpenSea","state":"ok","code":null,"unlockedBy":null,"stale":false,"stamp":{"category":"market","source":"opensea","detail":"OpenSea","fetchedAt":"2026-11-17T14:55:00.000Z","confidence":"market_reported","freshness":"fresh","covers":["market"]},"attribution":null}"#321 let money = #"{"amount":"31500000000000000000","currency":{"network":"ethereum","asset":"native","symbol":"ETH","decimals":18},"precision":"exact"}"#322 let listings = try APICoding.decoder().decode(NFTMarketOrders<NFTMarketListing>.self, from: Data(#"{"key":"k","kind":"listings","sources":[{"status":\#(status),"items":[{"orderId":"0xh","price":\#(money),"quantity":"1","seller":null,"venue":"OpenSea","protocol":null,"createdAt":null,"expiresAt":null,"fees":null}],"cursor":"next"}],"rates":{},"asOf":"2026-11-17T15:00:00.000Z","actions":[{"id":"buy","available":false,"reason":"market_writes_not_built"}]}"#.utf8))323 #expect(listings.sources[0].items[0].price.display == "31.5" && listings.sources[0].cursor == "next" && listings.actions[0].available == false)324 let offers = try APICoding.decoder().decode(NFTMarketOrders<NFTMarketOffer>.self, from: Data(#"{"key":"k","kind":"offers","sources":[{"status":\#(status),"items":[{"orderId":null,"price":\#(money),"quantity":"1","bidder":"0x1","venue":null,"scope":"item","createdAt":null,"expiresAt":"2026-12-01T00:00:00Z","fees":null}],"cursor":null}],"rates":{},"asOf":"2026-11-17T15:00:00.000Z","actions":[]}"#.utf8))325 #expect(offers.sources[0].items[0].scope == "item" && offers.kind == "offers")326 let events = try APICoding.decoder().decode(NFTMarketEvents.self, from: Data(#"{"key":"k","sources":[{"status":\#(status),"events":[{"type":"sale","providerType":"item_sold","at":"2026-10-01T00:00:00Z","tx":"0xbbb","index":null,"from":"0x1","to":"0x2","quantity":"1","price":\#(money),"venue":"OpenSea","orderId":null,"flags":{"washTrade":{"state":"known","value":true}},"fees":null}],"cursor":null}],"rates":{},"asOf":"2026-11-17T15:00:00.000Z"}"#.utf8))327 #expect(events.sources[0].events[0].flags?.washTrade == .known(true) && events.sources[0].events[0].providerType == "item_sold" && events.sources[0].events[0].date != nil)328 let traits = try APICoding.decoder().decode(NFTTraitAnswer.self, from: Data(#"{"key":"k","computed":true,"reason":null,"sources":[{"provider":"opensea","name":"OpenSea","computed":true,"reason":null,"total":"9998","fetchedAt":"2026-11-17T14:55:00.000Z","stale":false,"method":"count of items with the value ÷ item total, both stated by the source","rows":[{"traitType":"Fur","value":"Golden Brown","frequency":{"count":"778","total":"9998","percent":"7.78"}},{"traitType":"Hat","value":"None","frequency":null}]},{"provider":"magiceden","name":"Magic Eden","computed":false,"reason":"trait_counts_unavailable","rows":[]}],"mutableMetadata":null}"#.utf8))329 #expect(traits.computed && traits.sources[0].rows[0].frequency?.percent == "7.78" && traits.sources[0].rows[1].frequency == nil && traits.sources[1].computed == false && traits.sources[1].total == nil)330 let none = try APICoding.decoder().decode(NFTTraitAnswer.self, from: Data(#"{"key":"k","computed":false,"reason":"no_collection","sources":[]}"#.utf8))331 #expect(!none.computed && none.reason == "no_collection")332 }333334 @Test func transferViewVerdictAllowListAndOutpointLocks() throws {335 let v = try NFTT.vector("erc721", in: "SPW-NFT-INTENT-v1.json")336 let t = try NFTT.prepareAnswer(intent: v.object, hashHex: v.hashHex)["proposal"]!.decode(NFTTransfer.self) // `nftView` = view(p) + nft337 #expect(t.id == v.object["proposalId"]?.stringValue && t.state == .pendingApproval && t.proposal.kind == "nft" && t.proposal.symbol == "NFT" && t.proposal.decimals == 0 && t.proposal.amount == "1")338 #expect(t.review?.method == NFTTransferStandard.erc721.method && t.review?.fee.maxDisplay == "0.003" && t.review?.simulation.changes.first?.code == "evm_owner_of_token" && t.review?.verified.endpoints == 2 && t.review?.toKind == "account")339 #expect(try JSONValue.from(t).decode(NFTTransfer.self) == t)340 let verdict = try APICoding.decoder().decode(NFTTransferVerdictAnswer.self, from: Data(#"{"transferable":false,"blockedBy":["network_disabled_by_policy"],"warnings":["semi_fungible"],"standard":"erc1155","route":"safeTransferFrom(address,address,uint256,uint256,bytes) — data empty","signer":{"reachable":true,"halted":false,"supportsNft":true,"signedToday":2,"maxPerDay":5,"allowlistOnly":false,"maxErc1155Quantity":"10"},"broadcast":true}"#.utf8))341 #expect(!verdict.transferable && verdict.blockedBy == ["network_disabled_by_policy"] && verdict.signer.maxPerDay == 5 && verdict.signer.maxErc1155Quantity == "10" && verdict.broadcast == true)342 let unreachable = try APICoding.decoder().decode(NFTTransferVerdictAnswer.self, from: Data(#"{"transferable":true,"blockedBy":[],"warnings":[],"standard":"erc721","route":"safeTransferFrom(address,address,uint256)","signer":{"reachable":false},"broadcast":false}"#.utf8))343 #expect(!unreachable.signer.reachable && unreachable.signer.supportsNft == nil && unreachable.broadcast == false)344 let allow = try APICoding.decoder().decode(NFTAllowList.self, from: Data(#"{"allowlistOnly":true,"entries":[{"network":"ethereum","address":"0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC","approvedAt":1794000000}],"supported":true}"#.utf8))345 #expect(allow.allowlistOnly && allow.entries[0].approvedAt == 1_794_000_000 && allow.supported)346 let old = try APICoding.decoder().decode(NFTAllowList.self, from: Data(#"{"allowlistOnly":false,"entries":[],"supported":false}"#.utf8)) // a signer that predates NFT transfers347 #expect(!old.supported)348 let u: UTXOLocksView = try NFTT.decode("nft-utxo-locks.json")349 #expect(u.mode == "heuristic" && !u.ordConfigured && u.signerSupportsLocks && u.utxos[0].signerLock?.reason == "owner" && u.utxos[0].excludedBy == ["signer_locked", "heuristic_small"] && !u.utxos[0].spendable && u.utxos[1].spendable)350 #expect(u.staleLocks[0].reason == "ord" && u.transfer == "not_supported" && u.transferReason == "ordinals_transfer_not_supported" && u.utxos[1].value == 2_500_000)351 }352353 @Test func assetKeysAndLinks() {354 let k = NFTKey("evm:ethereum:0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d/8520")355 #expect(k?.family == "evm" && k?.chainId == "ethereum" && k?.evm?.contract == "0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d" && k?.evm?.tokenId == "8520")356 #expect(NFTKey("sol:solana:CMhGwGHMbVaBmxebfU3t5eViSf6FKHnvFCBNiA1D659j")?.evm == nil)357 for bad in ["", "evm", "evm:ethereum", "EVM:ethereum:x", "evm:ethereum:a b", "evm:ethereum:a?b", "evm:ethereum:a%2f", "evm::x", "evm:ethereum:a:b"] { #expect(NFTKey(bad) == nil, "\(bad)") }358 #expect(NFTLinks.safe("https://example.org/a?b=1")?.host == "example.org")359 for bad in ["javascript:alert(1)", "data:text/html,<script>", "ipfs://Qm", "https://user:pw@example.org/", "file:///etc/passwd", "", "//example.org"] { #expect(NFTLinks.safe(bad) == nil, "\(bad)") }360 #expect(NFTLinks.safe(nil) == nil)361 }362}363364private extension NFTAsset {365 /** The same asset under another standard name (test helper). */366 func withStandard(_ s: String) throws -> NFTAsset {367 guard case .object(var o) = try JSONValue.from(self) else { return self }368 o["standard"] = .string(s)369 return try JSONValue.object(o).decode()370 }371}372373// MARK: - request contract of the read routes374375@Suite struct NFTReadContractTests {376 static let key = "evm:ethereum:0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d/8520"377378 @Test func capabilitiesListSyncItemActivity() async throws {379 let (client, t, _) = MockTransport.client(); let api = NFTAPI(client)380 t.enqueue(json: try NFTT.fixture("nft-capabilities.json"))381 _ = try await api.capabilities()382 #expect(t.last?.method == "GET" && t.last?.path == "/api/v1/nfts/capabilities" && t.last?.query.isEmpty == true && t.last?.headers["X-SPW-CSRF"] == nil)383384 t.enqueue(json: try NFTT.fixture("nft-list.json"))385 _ = try await api.list()386 #expect(t.last?.path == "/api/v1/nfts" && t.last?.query.isEmpty == true) // the server's defaults apply387 t.enqueue(json: try NFTT.fixture("nft-list.json"))388 _ = try await api.list(NFTListQuery(chain: "solana", collection: "sol:solana:phygZDQZJZVHvJGYPGoKPYUtXw7mstSYtTtcuh8LJcC", status: .inWallet, search: "ape #1", sort: .name, spam: .only, cursor: 48, limit: 100))389 #expect(t.last?.query == ["chain": "solana", "collection": "sol:solana:phygZDQZJZVHvJGYPGoKPYUtXw7mstSYtTtcuh8LJcC", "status": "in_wallet", "q": "ape #1", "sort": "name", "spam": "only", "cursor": "48", "limit": "100"])390391 t.enqueue(json: #"{"running":["solana"]}"#)392 #expect(try await api.sync().running == ["solana"])393 #expect(t.last?.method == "POST" && t.last?.path == "/api/v1/nfts/sync" && t.last?.body == .object([:]) && t.last?.headers["X-SPW-CSRF"] == "1" && t.last?.headers["Origin"] == "https://wallet.example.test")394 t.enqueue(json: #"{"running":[]}"#)395 _ = try await api.sync(chain: "base")396 #expect(t.last?.body == ["chain": "base"])397398 t.enqueue(json: try NFTT.fixture("nft-item-erc721.json"))399 #expect(try await api.item(key: Self.key).key == Self.key)400 #expect(t.last?.method == "GET" && t.last?.path == "/api/v1/nfts/item" && t.last?.query == ["key": Self.key])401 t.enqueue(status: 404, json: #"{"error":"nft_not_found","message":"this NFT is not in the inventory; use the lookup to open it"}"#)402 do { _ = try await api.item(key: Self.key); Issue.record("expected 404") } catch let e as APIError { #expect(e.status == 404 && e.code == "nft_not_found") }403404 t.enqueue(json: try NFTT.fixture("nft-activity.json"))405 _ = try await api.activity(key: Self.key)406 #expect(t.last?.path == "/api/v1/nfts/activity" && t.last?.query == ["key": Self.key])407 t.enqueue(json: try NFTT.fixture("nft-activity.json"))408 _ = try await api.activity(key: Self.key, cursor: "20999000|x", limit: 50, type: .transferOut, loadOlder: true)409 #expect(t.last?.query == ["key": Self.key, "cursor": "20999000|x", "limit": "50", "type": "transfer-out", "more": "1"])410 }411412 @Test func collectionsLookupRefreshTrackingReceive() async throws {413 let (client, t, _) = MockTransport.client(); let api = NFTAPI(client)414 t.enqueue(json: #"{"items":[{"collection_key":"sol:solana:phygZDQZJZVHvJGYPGoKPYUtXw7mstSYtTtcuh8LJcC","chain":"solana","n":2,"name":"Phygitals"}]}"#)415 #expect(try await api.collections().first?.count == 2)416 #expect(t.last?.method == "GET" && t.last?.path == "/api/v1/nfts/collections")417418 t.enqueue(json: try NFTT.fixture("nft-collection.json"))419 _ = try await api.collection(key: "sol:solana:phygZDQZJZVHvJGYPGoKPYUtXw7mstSYtTtcuh8LJcC")420 #expect(t.last?.path == "/api/v1/nfts/collection" && t.last?.query == ["key": "sol:solana:phygZDQZJZVHvJGYPGoKPYUtXw7mstSYtTtcuh8LJcC"])421422 t.enqueue(json: try NFTT.fixture("nft-item-sol-core.json"))423 _ = try await api.lookup(NFTReference(chain: "solana", address: "CMhGwGHMbVaBmxebfU3t5eViSf6FKHnvFCBNiA1D659j"))424 #expect(t.last?.method == "POST" && t.last?.path == "/api/v1/nfts/lookup" && t.last?.body == ["chain": "solana", "address": "CMhGwGHMbVaBmxebfU3t5eViSf6FKHnvFCBNiA1D659j"]) // strict body: no null tokenId425426 t.enqueue(json: try NFTT.fixture("nft-item-erc721.json"))427 _ = try await api.refreshMetadata(key: Self.key)428 #expect(t.last?.method == "POST" && t.last?.path == "/api/v1/nfts/refresh-metadata" && t.last?.body == ["key": .string(Self.key)])429 t.enqueue(status: 429, json: #"{"error":"nft_provider_rate_limited","message":"NFT source spw: provider_rate_limited","data":{"source":"spw","code":"provider_rate_limited","detail":"refresh_cooldown"}}"#)430 do { _ = try await api.refreshMetadata(key: Self.key); Issue.record("expected 429") } catch let e as APIError { #expect(e.code == "nft_provider_rate_limited" && e.data?["detail"]?.stringValue == "refresh_cooldown") }431432 t.enqueue(json: try NFTT.fixture("nft-item-erc721.json"))433 _ = try await api.track(NFTReference(chain: "ethereum", address: "0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D", tokenId: "8520"))434 #expect(t.last?.method == "POST" && t.last?.path == "/api/v1/nfts/manual" && t.last?.body == ["chain": "ethereum", "address": "0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D", "tokenId": "8520"])435436 t.enqueue(json: #"{"ok":true,"removed":true}"#)437 #expect(try await api.untrack(key: Self.key).removed)438 #expect(t.last?.method == "DELETE" && t.last?.path == "/api/v1/nfts/manual" && t.last?.query == ["key": Self.key] && t.last?.headers["X-SPW-CSRF"] == "1")439440 t.enqueue(json: #"{"items":[{"network":"bitcoin","name":"Bitcoin","family":"btc","address":"bc1qcr8te4kr609gcawutmrza0j4xv80jy8z306fyu","standards":["ordinals-inscription"],"detection":"blocked_by_provider","warnings":["ordinals_heuristic_only","ordinals_no_transfer","arrival_after_confirmation"]}]}"#)441 let r = try await api.receiveAddresses()442 #expect(r[0].warnings.contains("ordinals_no_transfer") && r[0].standards == [.ordinalsInscription] && r[0].detection == "blocked_by_provider")443 #expect(t.last?.method == "GET" && t.last?.path == "/api/v1/nfts/receive")444 }445446 @Test func mediaOnlyThroughTheProxyByOpaqueId() async throws {447 let (client, t, _) = MockTransport.client(); let api = NFTAPI(client)448 let id = "m0123456789abcdef0123456789abcdef01234567", png = Data([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0, 0])449 t.enqueue(data: png, headers: ["Content-Type": "image/png", "Content-Security-Policy": "sandbox; default-src 'none'", "X-Content-Type-Options": "nosniff"])450 let m = try await api.media(id: id)451 #expect(m.data == png && m.mime == "image/png" && m.kind == "image" && !m.isActiveContent)452 let r = try #require(t.last)453 #expect(r.method == "GET" && r.path == "/api/v1/nfts/media/\(id)" && r.query.isEmpty && r.headers["Cookie"] == "__Host-spw=test-session-token") // never `run=1`454 #expect(r.headers["Accept"]?.contains("image/*") == true)455456 t.enqueue(data: Data("<svg xmlns='http://www.w3.org/2000/svg'><script>1</script></svg>".utf8), headers: ["Content-Type": "image/svg+xml; charset=utf-8"])457 let svg = try await api.media(id: id)458 #expect(svg.mime == "image/svg+xml" && svg.kind == "image" && svg.isActiveContent && svg.contentType == "image/svg+xml; charset=utf-8")459 t.enqueue(data: Data("<html>".utf8), headers: ["Content-Type": "text/html; charset=utf-8"])460 #expect(try await api.media(id: id).isActiveContent)461462 // an answer outside the proxy's allow-list, or larger than accepted, is not handed to the app463 t.enqueue(data: Data("MZ".utf8), headers: ["Content-Type": "application/octet-stream"])464 do { _ = try await api.media(id: id); Issue.record("expected a refusal") } catch let e as APIError { #expect(e.code == "media_unexpected_type") }465 t.enqueue(data: png, headers: ["Content-Type": "image/png"])466 do { _ = try await api.media(id: id, maxBytes: 4); Issue.record("expected a refusal") } catch let e as APIError { #expect(e.code == "media_too_large") }467468 // the server's refusals (routes.ts): 403 blocked, 413 too large, 502 unreachable — code in data469 t.enqueue(status: 403, json: #"{"error":"media_blocked","message":"media blocked: mime_mismatch","data":{"code":"mime_mismatch"}}"#)470 do { _ = try await api.media(id: id); Issue.record("expected 403") } catch let e as APIError { #expect(e.status == 403 && e.code == "media_blocked" && e.data?["code"]?.stringValue == "mime_mismatch") }471472 // anything that is not an opaque id never leaves the device: no URL, no path, no other route473 let before = t.requests.count474 for bad in ["https://evil.example/a.png", "../../auth/state", "m0123", "M0123456789abcdef0123456789abcdef01234567", "m0123456789abcdef0123456789abcdef01234567?run=1", "ipfs://QmImage"] {475 do { _ = try await api.media(id: bad); Issue.record("expected a refusal for \(bad)") } catch let e as APIError { #expect(e.code == "bad_media_id") }476 do { _ = try await api.mediaInfo(id: bad); Issue.record("expected a refusal for \(bad)") } catch let e as APIError { #expect(e.code == "bad_media_id") }477 }478 #expect(t.requests.count == before)479480 t.enqueue(json: #"{"status":"available","mime":"image/png","kind":"image","bytes":10}"#) // test/nft-api.test.ts `?info=1`481 let info = try await api.mediaInfo(id: id)482 #expect(info.isAvailable && info.bytes == 10 && t.last?.path == "/api/v1/nfts/media/\(id)" && t.last?.query == ["info": "1"])483 t.enqueue(json: #"{"status":"media_blocked","code":"scheme_not_allowed"}"#)484 let refused = try await api.mediaInfo(id: id)485 #expect(!refused.isAvailable && refused.code == "scheme_not_allowed" && refused.mime == nil)486 }487488 @Test func marketReadRoutesAndFloorEstimate() async throws {489 let (client, t, _) = MockTransport.client(); let api = NFTAPI(client)490 t.enqueue(json: try NFTT.fixture("nft-market-providers.json"))491 _ = try await api.marketProviders()492 #expect(t.last?.method == "GET" && t.last?.path == "/api/v1/nfts/market/providers")493494 t.enqueue(json: try NFTT.fixture("nft-market.json"))495 _ = try await api.market(key: Self.key)496 #expect(t.last?.path == "/api/v1/nfts/market" && t.last?.query == ["key": Self.key])497 t.enqueue(json: try NFTT.fixture("nft-market.json"))498 _ = try await api.market(key: Self.key, refresh: true)499 #expect(t.last?.query == ["key": Self.key, "refresh": "1"])500501 let orders = #"{"key":"k","kind":"listings","sources":[],"rates":{},"asOf":"2026-11-17T15:00:00.000Z","actions":[]}"#502 t.enqueue(json: orders)503 _ = try await api.marketListings(key: Self.key, provider: "opensea", cursor: "abc=")504 #expect(t.last?.method == "GET" && t.last?.path == "/api/v1/nfts/market/listings" && t.last?.query == ["key": Self.key, "provider": "opensea", "cursor": "abc="])505 t.enqueue(json: orders)506 _ = try await api.marketOffers(key: Self.key)507 #expect(t.last?.path == "/api/v1/nfts/market/offers" && t.last?.query == ["key": Self.key])508509 let events = #"{"key":"k","sources":[],"rates":{},"asOf":"2026-11-17T15:00:00.000Z"}"#510 t.enqueue(json: events)511 _ = try await api.marketActivity(key: Self.key)512 #expect(t.last?.path == "/api/v1/nfts/market/activity" && t.last?.query == ["key": Self.key])513 t.enqueue(json: events)514 _ = try await api.marketActivity(key: Self.key, NFTMarketEventQuery(provider: "opensea", cursor: "c1", types: [.sale, .acceptOffer], after: Date(timeIntervalSince1970: 1_793_000_000), before: Date(timeIntervalSince1970: 1_794_000_000), limit: 50))515 #expect(t.last?.query == ["key": Self.key, "provider": "opensea", "cursor": "c1", "type": "sale,accept-offer", "after": "2026-10-26T07:33:20.000Z", "before": "2026-11-06T21:20:00.000Z", "limit": "50"])516517 t.enqueue(json: try NFTT.fixture("nft-market-collection.json"))518 _ = try await api.marketCollection(key: "evm:ethereum:0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d")519 #expect(t.last?.path == "/api/v1/nfts/market/collection" && t.last?.query == ["key": "evm:ethereum:0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d"])520521 t.enqueue(json: #"{"key":"k","computed":false,"reason":"no_collection","sources":[]}"#)522 _ = try await api.traitFrequency(key: Self.key)523 #expect(t.last?.path == "/api/v1/nfts/market/traits" && t.last?.query == ["key": Self.key])524525 t.enqueue(json: try NFTT.fixture("nft-valuation.json"))526 _ = try await api.floorEstimate()527 #expect(t.last?.method == "GET" && t.last?.path == "/api/v1/nfts/valuation")528 t.enqueue(json: #"{"enabled":false}"#)529 #expect(try await api.setFloorEstimate(enabled: false).enabled == false)530 #expect(t.last?.method == "POST" && t.last?.path == "/api/v1/nfts/valuation" && t.last?.body == ["enabled": false] && t.last?.headers["X-SPW-CSRF"] == "1")531 }532}533534// MARK: - passkey-approved operations535536@Suite struct NFTApprovalTests {537 @Test func prepareChecksBindsAndApprovesThroughTheNFTRoute() async throws {538 let (client, t, _) = MockTransport.client(); let api = NFTAPI(client), auth = StubAuthenticator()539 let v = try NFTT.vector("erc721", in: "SPW-NFT-INTENT-v1.json"), key = APIClient.newIdempotencyKey()540 t.enqueue(json: try NFTT.text(NFTT.prepareAnswer(intent: v.object, hashHex: v.hashHex)))541 // the owner typed the destination in lower case: the server answers the EIP-55 form of the same 20 bytes542 let a = try await api.prepareTransfer(NFTT.request(for: v.object, to: " " + v.object["to"]!.stringValue!.lowercased() + " "), idempotencyKey: key, now: NFTT.now)543 let r = try #require(t.last)544 #expect(r.method == "POST" && r.path == "/api/v1/nfts/transfer/prepare" && r.headers["Idempotency-Key"] == key && r.headers["X-SPW-CSRF"] == "1")545 #expect(r.body == ["key": .string(NFTT.key(of: v.object)), "to": .string(v.object["to"]!.stringValue!.lowercased()), "quantity": "1"]) // strict body: exactly these keys546 #expect(a.approval.digest.hex == v.hashHex && a.intent.tokenId == "8520" && a.review?.warnings == ["contract_recipient"] && !a.replayed && a.transfer.state == .pendingApproval)547548 var done = NFTT.prepareAnswer(intent: v.object, hashHex: v.hashHex)["proposal"]!549 done = NFTT.setting(NFTT.setting(done, ["state"], "broadcast"), ["txid"], "0xaaa")550 t.enqueue(json: try NFTT.text(done))551 let sent = try await api.approveTransfer(a, with: auth, now: NFTT.now)552 let p = try #require(t.last)553 #expect(p.method == "POST" && p.path == "/api/v1/nfts/transfer/\(a.intent.proposalId)/approve") // the NFT route, not /transfers/proposals/…/approve554 #expect(p.body?.objectValue?.keys.sorted() == ["assertion"] && p.body?["assertion"]?["type"]?.stringValue == "public-key" && p.body?["assertion"]?["response"]?["signature"]?.stringValue == Data([4, 5, 6]).base64URL)555 #expect(auth.asked.count == 1 && auth.asked[0].challengeData?.hex == v.hashHex && sent.state == .broadcast && !sent.state.isSuccess && sent.proposal.txid == "0xaaa")556557 // past the approval window nothing is asked of the passkey558 await #expect(throws: ApprovalError.expired) { _ = try await api.approveTransfer(a, with: auth, now: Date(timeIntervalSince1970: 1_794_000_121)) }559 #expect(auth.asked.count == 1 && t.requests.count == 2)560 }561562 @Test func everyStandardOfTheVectorsPassesTheChecksOfItsOwnRequest() throws {563 for v in try CanonicalVector.load("SPW-NFT-INTENT-v1.json") {564 let i = try NFTIntent(served: v.object)565 try NFTAPI.check(intent: i, against: NFTT.request(for: v.object), now: Date(timeIntervalSince1970: TimeInterval(i.expiresAt - 1)))566 }567 }568569 @Test func anIntentThatIsNotTheRequestIsRefusedBeforeAnyPasskeyPrompt() async throws {570 let v = try NFTT.vector("erc721", in: "SPW-NFT-INTENT-v1.json"), base = v.object, asked = NFTT.request(for: base)571 let other = "0x90F79bf6EB2c4f870365E785982E1f101E93b906"572 // the served intent differs from what was asked; its challenge is honestly its own hash, so only the comparison can catch it573 let cases: [(String, [String], JSONValue)] = [574 ("destination", ["to"], .string(other)), ("token id", ["tokenId"], "8521"), ("contract", ["asset"], .string(other)), ("network", ["network"], "base"),575 ("standard", ["standard"], "erc1155"), ("quantity", ["quantity"], "2"), ("source", ["from"], .string(other)),576 ]577 for (what, path, value) in cases {578 var forged = NFTT.setting(base, path, value)579 if path == ["asset"] { forged = NFTT.setting(forged, ["program"], value) }580 let hash = try NFTIntent(served: forged).approvalDigest().hex581 let (client, t, _) = MockTransport.client()582 t.enqueue(json: try NFTT.text(NFTT.prepareAnswer(intent: forged, hashHex: hash)))583 await #expect(throws: ApprovalError.inconsistent(what), "\(what)") { _ = try await NFTAPI(client).prepareTransfer(asked, idempotencyKey: "0123456789abcdef", now: NFTT.now) }584 }585 // ERC-1155 asked for 3 units, 30 served586 let multi = try NFTT.vector("erc1155-quantity-5-large-token-id", in: "SPW-NFT-INTENT-v1.json").object587 #expect(throws: ApprovalError.inconsistent("quantity")) { try NFTAPI.check(intent: NFTIntent(served: NFTT.setting(multi, ["quantity"], "30")), against: NFTT.request(for: multi, quantity: "3"), now: NFTT.now) }588 // a program that is not the contract, a destination equal to the source, an EVM intent for a Solana key, a mint that is not the one asked589 #expect(throws: ApprovalError.inconsistent("program")) { try NFTAPI.check(intent: NFTIntent(served: NFTT.setting(base, ["program"], .string(other))), against: asked, now: NFTT.now) }590 #expect(throws: ApprovalError.inconsistent("destination is the source")) {591 try NFTAPI.check(intent: NFTIntent(served: NFTT.setting(base, ["to"], base["from"]!)), against: NFTT.request(for: base, to: base["from"]!.stringValue!), now: NFTT.now)592 }593 let sol = try NFTT.vector("solana-metaplex-core-in-collection", in: "SPW-NFT-INTENT-v1.json").object, solNow = Date(timeIntervalSince1970: TimeInterval(sol["expiresAt"]!.intValue! - 1))594 try NFTAPI.check(intent: NFTIntent(served: sol), against: NFTT.request(for: sol), now: solNow)595 #expect(throws: ApprovalError.inconsistent("mint")) { try NFTAPI.check(intent: NFTIntent(served: sol), against: NFTT.request(for: sol, key: "sol:solana:62Q9eeDY3eM8A5CnprBGYMPShdBjAzdpBdr71QHsS8dS"), now: solNow) }596 #expect(throws: ApprovalError.inconsistent("standard")) { try NFTAPI.check(intent: NFTIntent(served: sol), against: NFTT.request(for: sol, standard: .metaplexPNFT), now: solNow) }597 #expect(throws: ApprovalError.inconsistent("destination")) { try NFTAPI.check(intent: NFTIntent(served: sol), against: NFTT.request(for: sol, to: sol["to"]!.stringValue!.lowercased()), now: solNow) } // base58 is case-sensitive598 #expect(throws: ApprovalError.self) { try NFTAPI.check(intent: NFTIntent(served: base), against: NFTT.request(for: base, key: "sol:solana:" + sol["asset"]!.stringValue!), now: NFTT.now) }599 #expect(throws: ApprovalError.expired) { try NFTAPI.check(intent: NFTIntent(served: base), against: asked, now: Date(timeIntervalSince1970: 1_794_000_120)) }600 }601602 @Test func aRequestThatCannotBeATransferNeverLeavesTheDevice() async throws {603 let (client, t, _) = MockTransport.client(); let api = NFTAPI(client)604 let evm = "evm:ethereum:0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d/8520", to = "0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC"605 let bad = [606 NFTTransferRequest(key: evm, standard: .erc721, to: to, quantity: "2"), NFTTransferRequest(key: evm, standard: .erc1155, to: to, quantity: "0"), NFTTransferRequest(key: evm, standard: .erc1155, to: to, quantity: "01"),607 NFTTransferRequest(key: evm, standard: .metaplexCore, to: to), NFTTransferRequest(key: "sol:solana:CMhGwGHMbVaBmxebfU3t5eViSf6FKHnvFCBNiA1D659j", standard: .erc721, to: to),608 NFTTransferRequest(key: "not a key", standard: .erc721, to: to), NFTTransferRequest(key: "evm:ethereum:0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d", standard: .erc721, to: to),609 NFTTransferRequest(key: "btc:bitcoin:abcdefi0", standard: .erc721, to: to),610 ]611 for r in bad { await #expect(throws: ApprovalError.self) { _ = try await api.prepareTransfer(r, idempotencyKey: "0123456789abcdef", now: NFTT.now) } }612 #expect(t.requests.isEmpty)613 }614615 @Test func aChallengeThatIsNotTheHashOfTheIntentIsRefused() async throws {616 let v = try NFTT.vector("erc721", in: "SPW-NFT-INTENT-v1.json")617 var wrong = Data(hex: v.hashHex)!; wrong[0] ^= 0x80618 let (client, t, _) = MockTransport.client(); let api = NFTAPI(client)619 // options carry another challenge620 t.enqueue(json: try NFTT.text(NFTT.prepareAnswer(intent: v.object, hashHex: v.hashHex, challengeHex: wrong.hex)))621 await #expect(throws: ApprovalError.challengeMismatch) { _ = try await api.prepareTransfer(NFTT.request(for: v.object), idempotencyKey: "0123456789abcdef", now: NFTT.now) }622 // the proposal's stored hash is not the hash of the intent served623 t.enqueue(json: try NFTT.text(NFTT.prepareAnswer(intent: v.object, hashHex: wrong.hex, challengeHex: v.hashHex)))624 await #expect(throws: ApprovalError.challengeMismatch) { _ = try await api.prepareTransfer(NFTT.request(for: v.object), idempotencyKey: "0123456789abcdef", now: NFTT.now) }625 // another relying party626 var foreign = NFTT.prepareAnswer(intent: v.object, hashHex: v.hashHex); foreign = NFTT.setting(foreign, ["options", "rpId"], "evil.example")627 t.enqueue(json: try NFTT.text(foreign))628 await #expect(throws: ApprovalError.wrongRelyingParty("evil.example")) { _ = try await api.prepareTransfer(NFTT.request(for: v.object), idempotencyKey: "0123456789abcdef", now: NFTT.now) }629 // user verification not required630 t.enqueue(json: try NFTT.text(NFTT.setting(NFTT.prepareAnswer(intent: v.object, hashHex: v.hashHex), ["options", "userVerification"], "preferred")))631 await #expect(throws: ApprovalError.userVerificationNotRequired) { _ = try await api.prepareTransfer(NFTT.request(for: v.object), idempotencyKey: "0123456789abcdef", now: NFTT.now) }632 // a replayed proposal that can no longer be approved carries no challenge633 t.enqueue(json: try NFTT.text(NFTT.setting(NFTT.setting(NFTT.prepareAnswer(intent: v.object, hashHex: v.hashHex), ["options"], .null), ["replayed"], true)))634 await #expect(throws: ApprovalError.expired) { _ = try await api.prepareTransfer(NFTT.request(for: v.object), idempotencyKey: "0123456789abcdef", now: NFTT.now) }635 }636637 @Test func aReviewOrProposalThatDoesNotDescribeTheIntentIsRefused() async throws {638 let v = try NFTT.vector("erc721", in: "SPW-NFT-INTENT-v1.json"), ok = NFTT.prepareAnswer(intent: v.object, hashHex: v.hashHex)639 let cases: [([String], JSONValue, String)] = [640 (["review", "to"], "0x90F79bf6EB2c4f870365E785982E1f101E93b906", "review: addresses"), (["review", "tokenId"], "1", "review: asset"), (["review", "quantity"], "5", "review: quantity"),641 (["review", "fee", "max"], "1", "review: fee ceiling"), (["review", "method"], "setApprovalForAll(address,bool)", "review: standard"), (["review", "network"], "base", "review: network"),642 (["review", "key"], "evm:ethereum:0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d/1", "review: asset key"), (["review", "program"], "0x90F79bf6EB2c4f870365E785982E1f101E93b906", "review: program"),643 (["proposal", "id"], "7a1c1f0e-8f5f-4b1e-9c56-000000000999", "proposal id"), (["proposal", "kind"], "transfer", "proposal kind"), (["proposal", "amount"], "2", "proposal: asset"),644 (["proposal", "to"], "0x90F79bf6EB2c4f870365E785982E1f101E93b906", "proposal: destination"), (["proposal", "maxFee"], "9", "proposal: fee ceiling"), (["proposal", "nft", "warnings"], [], "review"),645 ]646 for (path, value, what) in cases {647 let (client, t, _) = MockTransport.client()648 t.enqueue(json: try NFTT.text(NFTT.setting(ok, path, value)))649 await #expect(throws: ApprovalError.inconsistent(what), "\(path.joined(separator: "."))") { _ = try await NFTAPI(client).prepareTransfer(NFTT.request(for: v.object), idempotencyKey: "0123456789abcdef", now: NFTT.now) }650 }651 // an intent with a field this version does not know does not decode: nothing to approve652 let (client, t, _) = MockTransport.client()653 t.enqueue(json: try NFTT.text(NFTT.setting(ok, ["intent", "data"], "0xa22cb465")))654 do { _ = try await NFTAPI(client).prepareTransfer(NFTT.request(for: v.object), idempotencyKey: "0123456789abcdef", now: NFTT.now); Issue.record("expected a refusal") }655 catch let e as APIError { #expect(e.code == "decoding" && e.message.contains("unknown field")) }656 }657658 @Test func serverRefusalsKeepTheirStableCodeAndFacts() async throws {659 let (client, t, _) = MockTransport.client(); let api = NFTAPI(client)660 let v = try NFTT.vector("erc721", in: "SPW-NFT-INTENT-v1.json")661 // transfer.ts `blocked()`: nft_transfer_<code>, 422, data.code + the facts662 t.enqueue(status: 422, json: #"{"error":"nft_transfer_pnft_locked","message":"this programmable NFT is LOCKED","data":{"code":"pnft_locked","blockedBy":["pnft_locked"],"standard":"metaplex-pnft"}}"#)663 do { _ = try await api.prepareTransfer(NFTT.request(for: v.object), idempotencyKey: "0123456789abcdef", now: NFTT.now); Issue.record("expected 422") }664 catch let e as APIError { #expect(e.status == 422 && e.code == "nft_transfer_pnft_locked" && e.data?["blockedBy"]?[0]?.stringValue == "pnft_locked") }665 t.enqueue(status: 503, json: #"{"error":"nft_transfer_signer_too_old","message":"the signer does not support NFT transfers yet (its version predates them)","data":{"code":"signer_too_old"}}"#)666 do { _ = try await api.prepareTransfer(NFTT.request(for: v.object), idempotencyKey: "0123456789abcdef", now: NFTT.now); Issue.record("expected 503") }667 catch let e as APIError { #expect(e.status == 503 && e.code == "nft_transfer_signer_too_old") }668 }669670 @Test func transferReadsVerdictAndReject() async throws {671 let (client, t, _) = MockTransport.client(); let api = NFTAPI(client)672 let v = try NFTT.vector("erc721", in: "SPW-NFT-INTENT-v1.json"), view = NFTT.prepareAnswer(intent: v.object, hashHex: v.hashHex)["proposal"]!, id = v.object["proposalId"]!.stringValue!673 t.enqueue(json: try NFTT.text(NFTT.setting(view, ["state"], "not_broadcast")))674 let one = try await api.transfer(id: id)675 #expect(t.last?.method == "GET" && t.last?.path == "/api/v1/nfts/transfer/\(id)" && one.state == .notBroadcast && !one.state.isSuccess)676 t.enqueue(json: try NFTT.text(["items": [view]]))677 #expect(try await api.transfers().count == 1)678 #expect(t.last?.path == "/api/v1/nfts/transfers" && t.last?.query.isEmpty == true)679 t.enqueue(json: #"{"items":[]}"#)680 _ = try await api.transfers(key: NFTT.key(of: v.object), limit: 50)681 #expect(t.last?.query == ["key": NFTT.key(of: v.object), "limit": "50"])682 t.enqueue(json: #"{"transferable":true,"blockedBy":[],"warnings":[],"standard":"erc721","route":"safeTransferFrom(address,address,uint256)","signer":{"reachable":false},"broadcast":true}"#)683 _ = try await api.transferVerdict(key: NFTT.key(of: v.object))684 #expect(t.last?.method == "GET" && t.last?.path == "/api/v1/nfts/transfer/verdict" && t.last?.query == ["key": NFTT.key(of: v.object)])685 t.enqueue(json: try NFTT.text(NFTT.setting(view, ["state"], "rejected")))686 #expect(try await api.rejectTransfer(id: id).state == .rejected)687 #expect(t.last?.method == "POST" && t.last?.path == "/api/v1/transfers/proposals/\(id)/reject") // the shared route: the backend has no NFT reject route688 }689690 @Test func allowListChangeIsCheckedBoundAndSentBackUntouched() async throws {691 let (client, t, _) = MockTransport.client(); let api = NFTAPI(client), auth = StubAuthenticator()692 let v = try NFTT.vector("add-evm", in: "SPW-NFT-ALLOW-v1.json"), i = try NFTAllowIntent(served: v.object), now = Date(timeIntervalSince1970: TimeInterval(i.expiresAt - 1))693 t.enqueue(json: #"{"allowlistOnly":false,"entries":[],"supported":true}"#)694 _ = try await api.allowList()695 #expect(t.last?.method == "GET" && t.last?.path == "/api/v1/nfts/allow")696697 let req = NFTAllowRequest(network: i.network, address: i.address.lowercased(), action: .add)698 t.enqueue(json: try NFTT.text(["intent": v.object, "options": NFTT.options(v.hashHex)]))699 let a = try await api.prepareAllowChange(req, now: now)700 #expect(t.last?.method == "POST" && t.last?.path == "/api/v1/nfts/allow/prepare" && t.last?.body == ["network": .string(i.network), "address": .string(i.address.lowercased()), "action": "add"])701 #expect(a.approval.digest.hex == v.hashHex)702703 t.enqueue(json: #"{"network":"\#(i.network)","address":"\#(i.address)","action":"add","entries":1,"hash":"\#(v.hashHex)"}"#)704 let r = try await api.approveAllowChange(a, with: auth, now: now)705 #expect(t.last?.method == "POST" && t.last?.path == "/api/v1/nfts/allow/approve" && t.last?.body?["intent"] == v.object && t.last?.body?["assertion"]?["id"]?.stringValue == Data("cred".utf8).base64URL)706 #expect(r.entries == 1 && r.hash == v.hashHex && auth.asked[0].challengeData?.hex == v.hashHex)707708 // intent ≠ request: another address, another action, another network; and a challenge that is not its hash709 for (bad, what) in [(NFTAllowRequest(network: i.network, address: "0x90F79bf6EB2c4f870365E785982E1f101E93b906", action: .add), "address"), (NFTAllowRequest(network: i.network, address: i.address, action: .remove), "action"),710 (NFTAllowRequest(network: "base", address: i.address, action: .add), "network")] {711 t.enqueue(json: try NFTT.text(["intent": v.object, "options": NFTT.options(v.hashHex)]))712 await #expect(throws: ApprovalError.inconsistent(what)) { _ = try await api.prepareAllowChange(bad, now: now) }713 }714 let other = try NFTT.vector("remove-evm", in: "SPW-NFT-ALLOW-v1.json")715 t.enqueue(json: try NFTT.text(["intent": v.object, "options": NFTT.options(other.hashHex)]))716 await #expect(throws: ApprovalError.challengeMismatch) { _ = try await api.prepareAllowChange(req, now: now) }717 t.enqueue(json: try NFTT.text(["intent": v.object, "options": NFTT.options(v.hashHex)]))718 await #expect(throws: ApprovalError.expired) { _ = try await api.prepareAllowChange(req, now: Date(timeIntervalSince1970: TimeInterval(i.expiresAt))) }719 await #expect(throws: ApprovalError.expired) { _ = try await api.approveAllowChange(a, with: auth, now: Date(timeIntervalSince1970: TimeInterval(i.expiresAt))) }720 #expect(auth.asked.count == 1)721 }722723 @Test func outpointLockChangeIsCheckedBoundAndSentBackUntouched() async throws {724 let (client, t, _) = MockTransport.client(); let api = NFTAPI(client), auth = StubAuthenticator()725 let v = try NFTT.vector("lock-three-ord-order-kept", in: "SPW-UTXO-LOCKS-v1.json"), i = try UTXOLockIntent(served: v.object), now = Date(timeIntervalSince1970: TimeInterval(i.expiresAt - 1))726 t.enqueue(json: try NFTT.fixture("nft-utxo-locks.json"))727 _ = try await api.utxoLocks(network: "bitcoin")728 #expect(t.last?.method == "GET" && t.last?.path == "/api/v1/utxo-locks" && t.last?.query == ["network": "bitcoin"])729730 let keys = i.outpoints.map(\.key), req = UTXOLockRequest(network: i.network, action: i.action, reason: i.reason, outpoints: keys + [keys[0]]) // a duplicate is removed by the server, order kept731 t.enqueue(json: try NFTT.text(["intent": v.object, "options": NFTT.options(v.hashHex), "hash": .string(v.hashHex)]))732 let a = try await api.prepareUTXOLocks(req, now: now)733 #expect(t.last?.method == "POST" && t.last?.path == "/api/v1/utxo-locks/prepare")734 #expect(t.last?.body == ["network": .string(i.network), "action": .string(i.action.rawValue), "reason": .string(i.reason.rawValue), "outpoints": .array((keys + [keys[0]]).map(JSONValue.string))])735736 t.enqueue(json: #"{"network":"bitcoin","action":"lock","changed":3,"locked":4,"hash":"\#(v.hashHex)"}"#)737 let r = try await api.approveUTXOLocks(a, with: auth, now: now)738 #expect(t.last?.method == "POST" && t.last?.path == "/api/v1/utxo-locks/approve" && t.last?.body?["intent"] == v.object && t.last?.body?.objectValue?.keys.sorted() == ["assertion", "intent"])739 #expect(r.changed == 3 && r.locked == 4 && auth.asked[0].challengeData?.hex == v.hashHex)740741 // intent ≠ request: one outpoint more than asked, another order, unlock instead of lock, another reason, another network742 let bad: [(UTXOLockRequest, String)] = [743 (UTXOLockRequest(network: i.network, action: i.action, reason: i.reason, outpoints: Array(keys.dropLast())), "outpoints"), (UTXOLockRequest(network: i.network, action: i.action, reason: i.reason, outpoints: keys.reversed()), "outpoints"),744 (UTXOLockRequest(network: i.network, action: .unlock, reason: i.reason, outpoints: keys), "action"), (UTXOLockRequest(network: i.network, action: i.action, reason: .owner, outpoints: keys), "reason"),745 (UTXOLockRequest(network: "litecoin", action: i.action, reason: i.reason, outpoints: keys), "network"), (UTXOLockRequest(network: i.network, action: i.action, reason: i.reason, outpoints: ["nonsense"]), "outpoints"),746 ]747 for (b, what) in bad {748 t.enqueue(json: try NFTT.text(["intent": v.object, "options": NFTT.options(v.hashHex), "hash": .string(v.hashHex)]))749 await #expect(throws: ApprovalError.inconsistent(what), "\(what)") { _ = try await api.prepareUTXOLocks(b, now: now) }750 }751 // the `hash` field or the challenge is not the hash of the intent served752 let other = try NFTT.vector("lock-one-owner", in: "SPW-UTXO-LOCKS-v1.json")753 t.enqueue(json: try NFTT.text(["intent": v.object, "options": NFTT.options(v.hashHex), "hash": .string(other.hashHex)]))754 await #expect(throws: ApprovalError.challengeMismatch) { _ = try await api.prepareUTXOLocks(req, now: now) }755 t.enqueue(json: try NFTT.text(["intent": v.object, "options": NFTT.options(other.hashHex), "hash": .string(v.hashHex)]))756 await #expect(throws: ApprovalError.challengeMismatch) { _ = try await api.prepareUTXOLocks(req, now: now) }757758 t.enqueue(json: #"{"ok":true}"#)759 #expect(try await api.reviewUTXO(network: "bitcoin", outpoint: keys[0], ordinary: true).ok)760 #expect(t.last?.method == "POST" && t.last?.path == "/api/v1/utxo-locks/review" && t.last?.body == ["network": "bitcoin", "outpoint": .string(keys[0]), "ordinary": true])761 }762}763