# Vector files > Every vector file @integraledger/lcp ships, and what it fixes. Source: https://lcp.integraledger.com/reference/vectors This page is generated from the package by `node scripts/docs-reference.mjs`, and CI checks that it matches. The package ships 63 vector files in `vectors/`. Each file's `about` states what it covers and where its expected values come from; it is quoted here as it is. The [Vectors](https://lcp.integraledger.com/concepts/vectors) page explains how to run them. | File | About | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [`a2a-legal-context.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/a2a-legal-context.json) | Vectors for the a2a entry point of @integraledger/lcp, the LCP A2A extension. Every expected value is fixed by the extension and its URI list, with H and L as in ack-payment-request.json. A value \{"$repeat": \[s, n]} in args stands for the string s repeated n times. | | [`ack-payment-request.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/ack-payment-request.json) | Vectors for the ack/payment-request pairing: the ack entry point of @integraledger/lcp. Every expected value is fixed by the pairing, with H, L and the JWS conventions of card.json: H = SHA-256("abc") (FIPS 180-2), L = [https://atr.seller.example/](https://atr.seller.example/), and each token base64url(JSON(header)).base64url(JSON(payload)).base64url(r\|\|s), JSON compact with members in the order written. T and the plant's token were built from that recipe with GNU coreutils basenc; their ES256 signatures verify over those signing inputs (cryptography 41.0.7). read verifies no signature. A token whose third segment is c2ln carries no signature at all. | | [`acp-checkout.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/acp-checkout.json) | Vectors for the acp/checkout/delegated and acp/checkout/undelegated pairings: the acp entry point of @integraledger/lcp. Every expected value is fixed by the pairing. A is a 287-byte ATR, H = SHA-256(A) (GNU coreutils sha256sum and openssl dgst -sha256 agree), L = [https://atr.seller.example/](https://atr.seller.example/), S0 a checkout session, and otherH ucp.json's H. A value \{"$repeat": \[s, n]} in args stands for the string s repeated n times. | | [`ap2-checkout-mandate.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/ap2-checkout-mandate.json) | Vectors for the ap2/checkout-mandate pairing and the SD-JWT reader it uses (the ap2 entry point of @integraledger/lcp). SHA-256 values were computed with GNU coreutils 9.4 sha256sum and basenc and agree with OpenSSL 3.0.13. The tests build J, D and M from the fixed strings; 'built' holds the same strings as written by Python 3's base64 and hashlib, for other languages. V6's token is AP2's published closed Checkout Mandate, docs/ap2/checkout\_mandate.md line 328 at commit e1ea56db of google-agentic-commerce/AP2, pinned by its SHA-256. The 'implementation' rows fix refusals that neither AP2 nor RFC 9901 names, and reader cases from RFC 9901 sections 4 and 7.1; their tokens were built with Python 3's base64 and hashlib. | | [`buyer.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/buyer.json) | The buyer gate's rows for the x402/exact/eip155/eip3009 pairing. A is a 138-byte ATR that the gate never parses; C is A with byte 124 changed from 0x30 to 0x31; D is the V5 document of x402-exact-eip155-eip3009.json advertising hash(A). The payer is the published Anvil key, account eip155:84532:0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266, and now is 1790000000. SHA-256 values were computed with GNU coreutils sha256sum and agree with openssl dgst -sha256; B6's digest and signature with viem 2.56.7 and eth-account 0.14.0. Bodies are hex. A row whose input names a stub describes the stub's behaviour. | | [`card.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/card.json) | Vectors for the card entry point of @integraledger/lcp: Visa TAP, Mastercard Verifiable Intent and the plain card checkout. H is SHA-256("abc") from FIPS 180-2 and E is SHA-256 of the empty string. The TAP signatures are RFC 9421 Ed25519 under RFC 9421's test-key-ed25519. The VI strings are built from a recipe (compact JSON, members in the order written) with fixed ES256 signatures, which verify under USER (L2i, L2a) and AGENT (L3b); every digest was checked with Python 3.12.3 hashlib. | | [`core-vectors.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/core-vectors.json) | Core vectors for assemble, hash and hashEquals. Expected values were computed 2026-09-25 with sha256sum, openssl dgst -sha256, Python 3 json and Node v24.21.0 JSON.stringify. Content bytes are given as hex so that they are exact. | | [`decoder-caps.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/decoder-caps.json) | Decoder caps. XRPL: STObject and STArray fields nest at most 64 levels inside a transaction (an object or array field one level below its container, an array's member object one level below the array), and a blob holds at most 2048 fields and array members; the blobs were written by ripple-binary-codec 2.11.0's encode, each a Payment whose depth is by construction. msgpack: arrays and maps nest at most 32 levels, the outermost container being level 1, every declared length is at most the bytes left, and the bytes are exactly one value; each row is hand-written from the msgpack specification's formats. ScVal: vectors and maps nest at most 64 levels within one ScVal, the outermost container being level 1, and one envelope or ScVal holds at most 1536 vector elements and map entries; each ScVal is hand-written XDR (RFC 4506). Authorized invocations nest at most 64 levels, the root invocation being level 1. The envelopes are x402-exact-stellar.json V2's signed envelope with a second authorization entry, under the source account's credentials, added by @stellar/stellar-sdk 17.1.0's XDR types. 'accept' says whether the caps admit the input. | | [`discovery.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/discovery.json) | The discovery document (LCP §2): what emit writes and what parse reads or refuses. 'bytes' is UTF-8 text; 'bytesHex' is used where the bytes are not valid UTF-8 text. The LCP §2.7 examples are cut from LCP §2.7 byte for byte. Expected emitted bytes were written by Python's json.dumps with separators (',', ':') over members in LCP §2.4-§2.5's table order; digests with hashlib.sha256, agreeing with GNU coreutils sha256sum 9.4. The ETag is '"' + the digest's hex + '"'. 'inputRepeat' sets that member of 'input' to 'char' repeated 'count' times. 'padTo' is the bytes '\{"terms":"[https://seller.example/t.md","x-pad](https://seller.example/t.md","x-pad)":"' + 'a' repeated + '"}', exactly that many bytes long. | | [`mpp-challenge.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/mpp-challenge.json) | Vectors for MPP's challenge pieces in the mpp entry point of @integraledger/lcp, shared by every MPP pairing. H is SHA-256("abc") from FIPS 180-2. C\_E and C\_T are fixed challenges; their request values are JSON, base64url without padding. Expected values were computed with eth-account 0.14.0, eth-abi 6.0.0, eth-utils 6.0.0 and pyrlp 5.0.0 on Python 3.12.3, viem 2.56.8 and GNU coreutils 9.4. MV9's field values are MPP's own example (draft-httpauth-payment-01 at 08e7dd87, lines 1427-1430). | | [`mpp-charge-card.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/mpp-charge-card.json) | Vectors for mpp/charge/card. H is SHA-256("abc"); fixed.MV1 is the MPP challenge id derived from H. The request is the M1 request, its JSON written in the order given here and encoded as base64url without padding. The issued digest is SHA-256 of the sorted JSON (printf of the sorted JSON piped to sha256sum). The proves text is the pairing's record, opening with the agreement transaction's sentence. | | [`mpp-charge-evm-authorization.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/mpp-charge-evm-authorization.json) | Vectors for mpp/charge/evm/authorization. Expected values were computed with eth-account 0.14.0, eth-abi 6.0.0, eth-utils 6.0.0 and pyrlp 5.0.0 on Python 3.12.3, viem 2.56.8 and GNU coreutils 9.4. Where a value is truncated, the row holds its prefix and suffix. The payer key is the published Anvil development key #0; the Permit2 spender is Anvil account 1. C\_E and C\_T are mpp-challenge.json's fixed challenges. | | [`mpp-charge-evm-hash.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/mpp-charge-evm-hash.json) | Vectors for mpp/charge/evm/hash. Expected values were computed with eth-account 0.14.0, eth-abi 6.0.0, eth-utils 6.0.0 and pyrlp 5.0.0 on Python 3.12.3, viem 2.56.8 and GNU coreutils 9.4. Where a value is truncated, the row holds its prefix and suffix. The payer key is the published Anvil development key #0; the Permit2 spender is Anvil account 1. C\_E and C\_T are mpp-challenge.json's fixed challenges. | | [`mpp-charge-evm-permit2.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/mpp-charge-evm-permit2.json) | Vectors for mpp/charge/evm/permit2, single and batch. Expected values were computed with eth-account 0.14.0, eth-abi 6.0.0, eth-utils 6.0.0 and pyrlp 5.0.0 on Python 3.12.3, viem 2.56.8 and GNU coreutils 9.4. Where a value is truncated, the row holds its prefix and suffix. The payer key is the published Anvil development key #0; the Permit2 spender is Anvil account 1. C\_E and C\_T are mpp-challenge.json's fixed challenges. | | [`mpp-charge-evm-transaction.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/mpp-charge-evm-transaction.json) | Vectors for mpp/charge/evm/transaction. Expected values were computed with eth-account 0.14.0, eth-abi 6.0.0, eth-utils 6.0.0 and pyrlp 5.0.0 on Python 3.12.3, viem 2.56.8 and GNU coreutils 9.4. Where a value is truncated, the row holds its prefix and suffix. The payer key is the published Anvil development key #0; the Permit2 spender is Anvil account 1. C\_E and C\_T are mpp-challenge.json's fixed challenges. | | [`mpp-charge-hedera.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/mpp-charge-hedera.json) | Vectors for the mpp/charge/hedera pairing of @integraledger/lcp's hedera entry point. The attribution memos were computed with pycryptodome 3.23.0's keccak and the bodies with hiero-sdk-python 0.2.10's generated protobufs (protobuf 7.36.2, deterministic) and cryptography's Ed25519 on Python 3.12.3, 2026-09-25; the seed is not recorded. The request follows MPP's Hedera draft (git blob 414b52a85a): the payer's debit of amount, the recipient's remainder and each split, in currency. | | [`mpp-charge-lightning.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/mpp-charge-lightning.json) | Vectors for the mpp/charge/lightning pairing: the lightning entry point of @integraledger/lcp. H is SHA-256("abc") from FIPS 180-2. L2 has p = x402's payment hash, s, h = H, x = 300 and features 8 and 14; it was made by an encoder that reproduced BOLT11's published h example byte for byte (@scure/base, @noble/curves and @noble/hashes 2.4.0) and decoded by light-bolt11-decoder 3.2.0 and bolt11 1.4.1. A challenge's request is given decoded; it is sent as base64url (no padding) of its JCS form. The issued digest is GNU coreutils sha256sum over the sorted JSON without the invoice; Python's json.dumps(sort\_keys=True, separators=(",",":")) agrees. | | [`mpp-charge-nearintents.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/mpp-charge-nearintents.json) | Vectors for mpp/charge/nearintents, on MPP's own example request (draft-nearintents-charge-01, blob 6a389faa6b) without its externalId. The placed request is computed with Python 3 json and base64url. | | [`mpp-charge-solana.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/mpp-charge-solana.json) | Vectors for mpp/charge/solana. Fixtures are seeds 01 and 02, devnet USDC, x402's payTo and blockhash, and x402-exact-solana.json's V2 and V3 wires. The placed request is computed with Python 3 json.dumps(sort\_keys=True, separators=(',',':')) and base64url without padding. Exactly one memo whose data parses as an LCP string, equal to the carrier; other memos are not read. | | [`mpp-charge-stellar.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/mpp-charge-stellar.json) | Vectors for mpp/charge/stellar. Fixtures are seller seed 04, payer seed 05, an asset of 06×32, and x402-exact-stellar.json's V1 muxed address, V2 preimage hash and V3 envelope. The placed request is computed with Python 3 json and base64url. | | [`mpp-charge-stripe.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/mpp-charge-stripe.json) | Vectors for mpp/charge/stripe, on MPP's own example request (draft-stripe-charge-00). Stripe metadata allows up to 50 keys, key names up to 40 characters and values up to 500; the legal\_context key has no square brackets. The refusal rows apply those bounds. | | [`mpp-charge-tempo-memo.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/mpp-charge-tempo-memo.json) | Vectors for mpp/charge/tempo/memo and the tempo entry point's memo pieces. Expected values were computed with eth-account 0.14.0, eth-abi 6.0.0, eth-utils 6.0.0 and pyrlp 5.0.0 on Python 3.12.3, viem 2.56.8 and GNU coreutils 9.4. Where a value is truncated, the row holds its prefix and suffix. The payer key is the published Anvil development key #0; the Permit2 spender is Anvil account 1. C\_E and C\_T are mpp-challenge.json's fixed challenges. | | [`mpp-charge-tempo-push.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/mpp-charge-tempo-push.json) | Vectors for mpp/charge/tempo/push. Expected values were computed with eth-account 0.14.0, eth-abi 6.0.0, eth-utils 6.0.0 and pyrlp 5.0.0 on Python 3.12.3, viem 2.56.8 and GNU coreutils 9.4. Where a value is truncated, the row holds its prefix and suffix. The payer key is the published Anvil development key #0; the Permit2 spender is Anvil account 1. C\_E and C\_T are mpp-challenge.json's fixed challenges. The log layout (from, to and memo as topics 1-3, the amount as data word 0) is that of a live TransferWithMemo on Tempo Moderato. | | [`mpp-charge-usdc-evm.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/mpp-charge-usdc-evm.json) | Vectors for mpp/charge/usdc/evm. Expected values were computed with canonicalize 5.1.0, viem 2.56.8 and js-sha3 on Node, and json.dumps(sort\_keys=True, separators=(',',':')) with eth-utils keccak on Python 3.12.3. A.1 is the usdc draft's example (draft-usdc-charge-00, blob ec7fc1868b, lines 1035-1090), whose request parameter is copied verbatim. Truncated values hold their prefix and suffix. The payer key is the published Anvil development key #0. | | [`mpp-charge-usdc-gateway.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/mpp-charge-usdc-gateway.json) | Vectors for mpp/charge/usdc/gateway. Expected values were computed with canonicalize 5.1.0 and viem keccak256, canonicalize and js-sha3, and Python json.dumps with eth-utils keccak, which agreed. The TransferSpec runs from Arc Testnet (domain 26) to Base Sepolia (domain 6), the testnet wallet and minter of gateway-api-testnet.circle.com /v1/info, each address left-padded to 32 bytes. The payer key is the published Anvil development key #0; the signature is made at test time and is not verified by bound. | | [`mpp-charge-usdc-solana.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/mpp-charge-usdc-solana.json) | Vectors for mpp/charge/usdc/solana: the Solana charge with method usdc, its details read from methodDetails.solana, whose network is required (draft-usdc-charge-00, Solana profile). The request, the wire and the expected reference are mpp-charge-solana.json's, so the expected values are that file's. The usdc profile rule is the draft's: methodDetails.type names exactly one profile details object. | | [`mpp-charge-usdc-stacks.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/mpp-charge-usdc-stacks.json) | Vectors for mpp/charge/usdc/stacks. R\_S is the usdc draft's A.3 request (draft-usdc-charge-00, blob ec7fc1868b) without description, externalId, feePayer and feePayerAddress. The transaction is built at test time with @stacks/transactions 7.6.0 from these inputs, signed by the private key whose scalar is 1 (compressed); its length, bytes and txid were computed with stacks.js txid(), noble sha512\_256, Python hashlib and OpenSSL, which agreed. The fixture transaction L's argument hexes are those of that transaction (Clarity serialization: uint, the sender and recipient standard principals, (some H)); block 9021832 at tenure 256356 is a Stacks mainnet block. The reference's nonce is a decimal string (references are JSON). Integers in L are decimal strings, read as bigints. M4's wireHex is that transaction's bytes, whose SHA-512/256 is the txid, for buyer-side tests without the SDK. | | [`mpp-charge-xrpl.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/mpp-charge-xrpl.json) | Vectors for mpp/charge/xrpl. Fixtures are payer r3sN…6dTC, destination rpjf…EyN, and x402-exact-xrpl.json's V2 x402 blob, V3 MPP blob and the plant's memo blob. The placed request is computed with Python 3 json and base64url. | | [`mpp-session-evm.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/mpp-session-evm.json) | Vectors for mpp/session/evm. Expected values were computed with eth-abi 6.0.0, eth-account 0.14.0, eth-hash 0.8.0 and pyrlp 5.0.0 on Python 3.12.3, viem 2.56.8 and its ox 0.14.45 on Node 24.21.0, and GNU coreutils 9.4. Where a value is truncated, the row holds its prefix and suffix. The payer key is the published Anvil development key #0. The session request's amount is a price per unit and enters no expected value. | | [`mpp-session-hedera-solana-xrpl.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/mpp-session-hedera-solana-xrpl.json) | Vectors for mpp/session/hedera, mpp/session/solana and mpp/session/xrpl. Where a value is shortened, the row holds its prefix and suffix. HS4's receipts are live testnet reads from testnet.hashio.io (eth\_getTransactionReceipt) at 2026-09-25T09:02Z. The placed challenges are computed with Python 3 json and base64url. | | [`mpp-session-lightning.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/mpp-session-lightning.json) | Vectors for the mpp/session/lightning pairing: the lightning entry point of @integraledger/lcp. The session challenge carries L2 (the mpp/charge/lightning vectors' invoice, h = H) as its depositInvoice and x402's payment hash as paymentHash, both at the top level of request as MPP's Lightning session draft places them. The rows follow the session draft's request members and actions (draft-lightning-session-00, blob 3bdcfd0184); no published session vector exists. The return invoice is BOLT11's published example "Please make a donation of any amount" (lightning/bolts 11-payment-encoding.md, blob ffd29a0909), which has no amount, as the session draft requires (draft-lightning-session-00, blob 3bdcfd0184: "returnInvoice: REQUIRED. BOLT11 invoice with no encoded amount"); light-bolt11-decoder 3.2.0 and bolt11 1.4.1 decode it with no amount. Only the open action is the session's payment; topUp, bearer and close are later actions in the session, with the draft's payload members. | | [`mpp-session-tempo.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/mpp-session-tempo.json) | Vectors for mpp/session/tempo and the tempo entry point's channel pieces. Expected values were computed with eth-abi 6.0.0, eth-account 0.14.0, eth-hash 0.8.0 and pyrlp 5.0.0 on Python 3.12.3, viem 2.56.8 and its ox 0.14.45 on Node 24.21.0, and GNU coreutils 9.4. Where a value is truncated, the row holds its prefix and suffix. The payer key is the published Anvil development key #0. L1 is a live v2 open on Tempo Moderato (eip155:42431), transaction 0x274c152568833e92246fdb8a01271e4af32c60edd2e561a53dcac3346865e1d1, read with eth\_getRawTransactionByHash and eth\_getTransactionReceipt from [https://rpc.moderato.tempo.xyz](https://rpc.moderato.tempo.xyz) on 2026-09-25 at 08:01Z; the receipt keeps status, block and logs. | | [`mpp-subscription-stripe.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/mpp-subscription-stripe.json) | Vectors for mpp/subscription/stripe: the same carrier as the Stripe charge, under intent subscription. No subscription request is published, so the rows state relations (the carrier's value, the issued digest unchanged by the carrier, and an emptied metadata object removed with it), not digests. | | [`mpp-subscription-tempo.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/mpp-subscription-tempo.json) | Vectors for mpp/subscription/tempo and the tempo entry point's key authorizations. Expected values were computed with eth-abi 6.0.0, eth-account 0.14.0, eth-hash 0.8.0 and pyrlp 5.0.0 on Python 3.12.3, viem 2.56.8 and its ox 0.14.45 on Node 24.21.0, and GNU coreutils 9.4. Where a value is truncated, the row holds its prefix and suffix. The payer key is the published Anvil development key #0. L2 is a live key authorization on Tempo Moderato (eip155:42431), transaction 0x6c1cdc57bf5a4a98961b7897cac3212636eea551540ab3b32038c45f9d3d8d1c, read with eth\_getRawTransactionByHash and eth\_getTransactionReceipt from [https://rpc.moderato.tempo.xyz](https://rpc.moderato.tempo.xyz) on 2026-09-25 at 08:01Z; the receipt keeps status, block and logs. | | [`sd-jwt.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/sd-jwt.json) | Rows for the SD-JWT reader (src/sd-jwt.ts). C4 is RFC 9901's published disclosures and digests (sections 4.2.3 and 4.2.4.2). C6 and C7 are Verifiable Intent presentations built with Python 3 as compact JSON with fixed ES256 signatures. The reader applies RFC 9901 section 7.1 with one allowance: a digest in \_sd that does not name a three-element disclosure is ignored there. The reader's refusal codes are the caller's; these rows name the reason: malformed, sd-alg-unsupported, unreferenced or too-large. | | [`ucp.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/ucp.json) | Vectors for the ucp/checkout/\{ap2-mandate,unsigned} and ucp/booking/\{ap2-mandate,unsigned} pairings (the ucp entry point of @integraledger/lcp). SHA-256 values were computed with GNU coreutils sha256sum and basenc and agree with OpenSSL. The tests build J, D and M from the fixed strings, J from V2's checkout written compactly in member order; 'built' holds the same strings as written by Python 3's base64, hashlib and json. V5 uses ap2-checkout-mandate.json's V6 token. The 'implementation' rows fix refusals that UCP does not name; their inputs were built with Python 3. | | [`x402-auth-capture-eip155-eip3009.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/x402-auth-capture-eip155-eip3009.json) | Vectors for x402/auth-capture/eip155/eip3009 on the commerce-payments escrow v1.1. H is SHA-256("abc") (FIPS 180-2); the payer is the published Anvil development key #0; now is 1790000000. Values are written in full, or as their prefix and suffix where truncated. Refusal codes the specification leaves to the implementation are marked implementationCode. captureAuthorizer F is Anvil account 2, receiverAuthorizer R Anvil account 3, feeRecipient Anvil account 4; policy zero. | | [`x402-auth-capture-eip155-permit2.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/x402-auth-capture-eip155-permit2.json) | Vectors for x402/auth-capture/eip155/permit2 on the commerce-payments escrow v1.1. H is SHA-256("abc") (FIPS 180-2); the payer is the published Anvil development key #0; now is 1790000000. Values are written in full, or as their prefix and suffix where truncated. Refusal codes the specification leaves to the implementation are marked implementationCode. | | [`x402-batch-settlement.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/x402-batch-settlement.json) | Vectors for the x402 batch-settlement pairings (the x402-batch-settlement entry point of @integraledger/lcp). H is SHA-256("abc") and H' SHA-256("abd"); EVM keys are the published Anvil development accounts 0, 1 and 3; the EVM values were computed with eth-account 0.14.0, eth-abi 6.0.0, eth-utils 6.0.0 and viem 2.56.8 and read them on Base Sepolia; the SVM values with solders 0.26.0, PyNaCl 1.6.2 and @noble/curves 2.4.0. The SVM fixtures (ES4's top\_up, request\_close and nonce-memo wires, ES5's landed wire, the no-channel transaction) were built with solders 0.26.0 on Python 3.11; the same script reproduces ES1, ES2, ES3 and ES5's txid. | | [`x402-exact-algorand.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/x402-exact-algorand.json) | Vectors for the x402/exact/algorand pairing of @integraledger/lcp's avm entry point. H is SHA-256("abc") from FIPS 180-2. The values were computed with py-algorand-sdk 2.12.0 and PyNaCl 1.6.2 on Python 3.12.3, with hashlib's sha512\_256 as a second path, 2026-09-25; the seeds are not recorded here. Rounds are decimal strings. | | [`x402-exact-aptos.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/x402-exact-aptos.json) | Vectors for the x402/exact/aptos pairing: the aptos entry point of @integraledger/lcp. H is SHA-256("abc") from FIPS 180-2. The committed answer is Aptos mainnet transaction 0xde08191e…ef48ceb5 (version 7351075186) read over REST from api.mainnet.aptoslabs.com on 2026-09-25, trimmed to the members the reader returns. Fixture F's RawTransaction is built with @aptos-labs/ts-sdk 7.3.0 from that answer (max\_gas\_amount 15000, gas\_unit\_price 100, chain 1); its SHA-256 is Python's hashlib. idDigest is Python's hashlib.sha256 over json.dumps(sort\_keys=True, separators=(',',':')) of the normal form. Other answers are the real one with the named member changed. Ledger times are microseconds. | | [`x402-exact-cardano.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/x402-exact-cardano.json) | Vectors for the x402/exact/cardano pairing: the cardano entry point of @integraledger/lcp. H is SHA-256("abc") from FIPS 180-2. V1 is cbor2 5.7.1's encoding of the auxiliary data (pycardano 0.19.2's AuxiliaryData(AlonzoMetadata(...)).to\_cbor() is equal). V2 and V4 are built with pycardano 0.19.2 on Python 3.11; the one vkey witness is from a key generated when the fixture was built, which does not change the body or the id. V3 is Cardano preprod transaction 628eca29…c73ef4be, its CBOR read through Koios /tx\_cbor on 2026-09-25. Every Blake2b-256 is Python's hashlib.blake2b(digest\_size=32) over the item's bytes as located by cbor2's decoder. | | [`x402-exact-casper.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/x402-exact-casper.json) | Vectors for the x402/exact/casper pairing: the casper entry point of @integraledger/lcp. H is SHA-256("abc") from FIPS 180-2; the option, payee and payer are x402's Casper example; the EIP-712 values were computed with @casper-ecosystem/casper-eip-712 1.2.1 and, separately, viem 2.56.8 over CEP-3009's formula by hand, on Node 24.21.0; every SHA-256 with GNU coreutils sha256sum. The public key and signature are placeholders of the tagged widths: bound verifies no signature. Byte strings are hex; uint256 values are decimal strings; a call's blockHeight is a decimal string. | | [`x402-exact-ccd.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/x402-exact-ccd.json) | Vectors for the x402/exact/ccd pairing: the ccd entry point of @integraledger/lcp. H is SHA-256("abc") from FIPS 180-2. The accounts are version byte 01 plus SHA-256 of a label, base58check-encoded with bs58check; x402's example addresses fail base58check. D1 was produced by cborg 6.1.2; D2 was hand-assembled to the steward's PLT encoder; the digests are GNU coreutils sha256sum. D3's CCD signedTransaction is the output of @concordium/web-sdk 12.0.2's Transaction.toJSONString for Transaction.transfer(payee, 1000000 microCCD, memo D1) with sender payer, nonce 7, expiry 1790000060 and sponsor with one signature, signed by Transaction.sign with buildBasicAccountSigner of the seed 0x00…01; its memo is DataBlob.toJSON, a 2-byte big-endian length then the bytes, and the refusal rows' memos are DataBlob.toJSON of their bytes. D3's PLT signedTransaction is the output of the same SDK's Transaction.toJSONString for Transaction.tokenUpdate(createTokenUpdatePayload(EURR, \{transfer: \{amount: TokenAmount.create(5000000, 6), recipient: CborAccountAddress.fromBase58(payee), memo: CborMemo.fromString(H's LCP string)}})) with the same sender, nonce, expiry, sponsor and seed; its operations are Cbor.toJSON, plain hex with no length, and its recipient is the SDK's tag-40307 map with the coin info (key 1, tag 40305 \{1: 919}) beside the address (key 3). bound verifies no signature. Byte strings are hex; amounts are decimal strings. A memo carries H only as ccdMemo(H) exactly: LCP's string form with lowercase hex, as one CBOR text string under RFC 8949 §4.1's preferred serialization (cborg 6.1.2's strict decode refuses the non-preferred head), so bound, status and recover read it alike. A map with a repeated key is malformed (RFC 8949 §5.6; cborg 6.1.2 with rejectDuplicateMapKeys refuses the repeated memo). | | [`x402-exact-eip155-eip3009.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/x402-exact-eip155-eip3009.json) | Vectors for the x402/exact/eip155/eip3009 pairing: the x402 and evm entry points of @integraledger/lcp. H is SHA-256("abc") from FIPS 180-2; O is the x402 specification's example option (section 5.2.1); the payer is the published Anvil development key. The EIP-712 values were computed with eth-account 0.14.0, eth-abi 6.0.0 and eth-utils 6.0.0 on Python 3.12.3; every SHA-256 with GNU coreutils sha256sum. Byte strings are hex; uint256 values are decimal strings. | | [`x402-exact-eip155-erc7710-salt.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/x402-exact-eip155-erc7710-salt.json) | Vectors for x402/exact/eip155/erc7710-salt, MetaMask's DelegationManager v1.3.0. H is SHA-256("abc") (FIPS 180-2); the payer is the published Anvil development key #0; now is 1790000000. Values are written in full, or as their prefix and suffix where truncated. Refusal codes the specification leaves to the implementation are marked implementationCode. The leaf L's caveat is arbitrary: bound never reads caveats. | | [`x402-exact-eip155-erc7710.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/x402-exact-eip155-erc7710.json) | Vectors for x402/exact/eip155/erc7710, the unsigned level. H is SHA-256("abc") (FIPS 180-2); the payer is the published Anvil development key #0; now is 1790000000. Values are written in full, or as their prefix and suffix where truncated. Refusal codes the specification leaves to the implementation are marked implementationCode. | | [`x402-exact-eip155-permit2.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/x402-exact-eip155-permit2.json) | Vectors for x402/exact/eip155/permit2. H is SHA-256("abc") (FIPS 180-2); the payer is the published Anvil development key #0; now is 1790000000. Values are written in full, or as their prefix and suffix where truncated. Refusal codes the specification leaves to the implementation are marked implementationCode. | | [`x402-exact-hedera-transfer-executor.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/x402-exact-hedera-transfer-executor.json) | Vectors for the x402/exact/hedera/transfer-executor pairing, from x402's own example at 8228bd6d. idDigest is printf '%s' '0.0.5001,0.0.4001,100000000' \| sha256sum, and Python hashlib printed the same. | | [`x402-exact-hedera.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/x402-exact-hedera.json) | Vectors for the x402/exact/hedera pairing of @integraledger/lcp's hedera entry point. H is SHA-256("abc") from FIPS 180-2. The bytes were computed with hiero-sdk-python 0.2.10's generated protobufs and protobuf 7.36.2 (SerializeToString(deterministic=True)) and cryptography's Ed25519 on Python 3.12.3, 2026-09-25; the signing seed is not recorded here. Byte strings are hex unless named base64. | | [`x402-exact-lnbtc-invoice-named.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/x402-exact-lnbtc-invoice-named.json) | Vectors for the x402/exact/lnbtc/invoice-named pairing: the lightning entry point of @integraledger/lcp. N has p = x402's payment hash, h = x402's request hash, x = 300 and no m; it was made by the encoder that reproduced BOLT11's L1 and decoded by light-bolt11-decoder 3.2.0 and bolt11 1.4.1. O\_N is x402's lnbtc example with N as its invoice. A\_N is the core's bytes for the id, the x402 slot \{accepts: \[O\_N], request} with members in that order, and no party slots; Python wrote them and Node's JSON.stringify(JSON.parse(bytes)) returns them unchanged. Digests are GNU coreutils sha256sum. | | [`x402-exact-lnbtc.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/x402-exact-lnbtc.json) | Vectors for the x402/exact/lnbtc pairing: the lightning entry point of @integraledger/lcp. H is SHA-256("abc") from FIPS 180-2. L1 is BOLT11's published example 'Now send $24 for an entire list of things (hashed)'. L4 was made by an encoder that reproduced L1 byte for byte (@scure/base, @noble/curves and @noble/hashes 2.4.0) and decoded by light-bolt11-decoder 3.2.0 and bolt11 1.4.1. The option is x402's lnbtc example with L4 as its invoice. Digests are GNU coreutils sha256sum over sorted JSON. The payee is the public key of x402's test-only key 1. | | [`x402-exact-near.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/x402-exact-near.json) | Vectors for the x402/exact/near pairing: the near entry point of @integraledger/lcp. H is SHA-256("abc") from FIPS 180-2. The payer's key is the Ed25519 seed 01 repeated 32 times and its implicit account. The option is x402's NEAR example. Expected values were computed with (borsh-construct 0.1.0, hashlib and PyNaCl 1.6.2, with @near-js/transactions 2.5.1 as a cross-check). Negative signed delegate actions are V1's with one part changed and a zero signature. Nonces and heights are decimal strings. | | [`x402-exact-polkadot-lcp-assets-remark.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/x402-exact-polkadot-lcp-assets-remark.json) | Vectors for the x402/exact/polkadot/lcp-assets-remark pairing of @integraledger/lcp's polkadot entry point. H is SHA-256("abc"). V1 is a real extrinsic read live (block 21,053,708, index 3); V2's call was printed by @polkadot/api 16.5.6 and equals a hand encoding in Python; V3's extrinsic was accepted by TaggedTransactionQueue\_validate\_transaction on Polkadot Asset Hub (Invalid(Payment): signature and extensions accepted, the account unfunded); every BLAKE2b-256 is b2sum -l 256 (GNU coreutils 9.4). Reader fixtures take Sidecar's answer shapes; heights are decimal strings. | | [`x402-exact-solana.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/x402-exact-solana.json) | Vectors for the x402/exact/solana pairing: the svm and x402/exact/solana entry points of @integraledger/lcp. Expected values: H is SHA-256("abc") from FIPS 180-2; keys from Ed25519 seeds 01x32 and 02x32; x402's example payTo and blockhash; devnet USDC, computed with solders 0.26.0 on Python 3.12.3. The transaction fixtures (V3's variants, V4's landed wire, the plant) were built with solders 0.26.0 on Python 3.11 from the same seeds; the same script reproduces the V2 wire and V4 txid. Byte strings are hex unless named base64. | | [`x402-exact-starknet.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/x402-exact-starknet.json) | Vectors for the x402/exact/starknet pairing: the starknet entry point of @integraledger/lcp. H is SHA-256("abc") from FIPS 180-2. The option and the payer are x402's Starknet example (scheme\_exact\_starknet.md at 0cb1a1f0). Expected values were computed with starknet 10.8.0 and @noble/hashes 2.4.0 on Node, Python 3.12.3 and GNU coreutils; the type hashes are SNIP-9's published values. Trace fixtures model starknet\_traceTransaction's execute\_invocation. | | [`x402-exact-stellar.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/x402-exact-stellar.json) | Vectors for the x402/exact/stellar pairing: the stellar and x402/exact/stellar entry points of @integraledger/lcp. The fixed inputs are H = SHA-256("abc") from FIPS 180-2, the seller from Ed25519 seed 04x32, the payer from 05x32 and the asset the contract strkey of 06x32, on testnet; the expected values were computed with stellar-sdk 13.0.0 on Python 3.12.3. The fixtures described without being printed (the unsigned simulated envelope, V4's plain-G envelope, the plant) were built with stellar-sdk 13.0.0 on Python 3.11 from V3's envelope; the same script reproduces V2's preimage digest and signature. The payer signs the authorization entry's rootInvocation, not the operation (CAP-46: the credentials' signature covers the HashIDPreimage of the network id, nonce, expiration and invocation; x402 scheme\_exact\_stellar: argument 1 (to) MUST equal payTo, and the rootInvocation MUST NOT contain subInvocations), so the payment is read from that invocation and the operation must invoke exactly it. V4's rows with a differing operation or signed invocation, and V4build, were built with @stellar/stellar-sdk 17.1.0 (its XDR codec, and authorizeEntry for the payer's signature, nonce 1, expiration 1000) from V2's simulated envelope; the same builder reproduces V3's envelope and V4's plain-G envelope byte for byte. V4's encoding rows follow RFC 4648 (section 3.3: characters outside the base alphabet are rejected; section 3.5: non-zero padding bits are rejected; section 4: the encoding is padded to a multiple of 4) and the XDR decoder of @stellar/stellar-sdk 17.1.0, which refuses bytes after the envelope. | | [`x402-exact-sui.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/x402-exact-sui.json) | Vectors for the x402/exact/sui pairing: the sui entry point of @integraledger/lcp. H is SHA-256("abc") from FIPS 180-2. V1 is Sui testnet transaction EV7D7z9gjzjrAQSKWSW8S1iLGdk8aEVPjn3zLA1aUSLE, its transactionBcs read over GraphQL (graphql.testnet.sui.io) on 2026-09-25. V2 and V3 are recipe R, built with @mysten/sui 2.31.3. Every digest is Python 3's hashlib.blake2b(b"TransactionData::" + bytes, digest\_size=32), then base58. O is a test option: the option's values are not read by the pairing beyond its filter. | | [`x402-exact-tron-lcp-trc20-memo.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/x402-exact-tron-lcp-trc20-memo.json) | Vectors for the x402/exact/tron/lcp-trc20-memo pairing: the tron entry point of @integraledger/lcp. H is SHA-256("abc") from FIPS 180-2. V1 is mainnet transaction 40662c9c…, read live from a Solidity node. V2's inputs are the published Anvil development key, USDT-TRC20, the payee bytes of x402's example option under 0x41, and solidified block 86542765. The signature was made with coincurve 21.0.0 (RFC 6979) and recovers to the payer; base58check with base58 2.1.1; the Transfer topic with pycryptodome 3.23.0 keccak; every SHA-256 with hashlib. Negative transactions are V2 with fields changed, written by hand from Tron.proto's field numbers. Byte strings are lowercase hex; int64 values are decimal strings. | | [`x402-exact-tvm.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/x402-exact-tvm.json) | Vectors for the x402/exact/tvm pairing: the tvm entry point of @integraledger/lcp. H is SHA-256("abc") from FIPS 180-2. The expected cell hashes, BoC and signature prefixes were computed with pytoniq-core 0.2.0 and PyNaCl 1.6.2. The payer's key is the Ed25519 seed 01 repeated 32 times. Negative settlement BoCs are V2's request with one part changed. Status fixtures model TON Center v3 answers; inBody is a BoC in hex. | | [`x402-exact-xrpl.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/x402-exact-xrpl.json) | Vectors for the x402/exact/xrpl pairing: the xrpl and x402/exact/xrpl entry points of @integraledger/lcp. Expected values: H is SHA-256("abc") from FIPS 180-2; payer from Ed25519 entropy 01x16, destination from 02x16; 1 000 000 drops, Fee 12, Sequence 7, LastLedgerSequence 1000, computed with xrpl-py 4.1.0 on Python 3.12.3, GNU coreutils 9.4 and OpenSSL 3.0.13. The plant's blob was built with xrpl-py 4.1.0 on Python 3.11; the same script reproduces V2's and V3's blobs and hashes. | | [`x402-upto-eip155-permit2.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/x402-upto-eip155-permit2.json) | Vectors for x402/upto/eip155/permit2. H is SHA-256("abc") (FIPS 180-2); the payer is the published Anvil development key #0; now is 1790000000. Values are written in full, or as their prefix and suffix where truncated. Refusal codes the specification leaves to the implementation are marked implementationCode. The upto facilitator F is Anvil account 2. | | [`x402-upto-solana.json`](https://github.com/IntegraLedger/integra-protocol/blob/main/lcp/vectors/x402-upto-solana.json) | Vectors for the x402/upto/solana pairing (the x402-upto-solana entry point of @integraledger/lcp). Expected values use x402-exact-solana.json's fixed inputs (receiverAuthorizer from seed 03x32; nonce 7; openSlot 341000000; amount 10000; withdrawDelay 3600), computed with solders 0.26.0, PyNaCl 1.6.2 and @noble/curves 2.4.0. The fixtures (EU5's landed wire, the no-channel transaction, the plants' wires) were built with solders 0.26.0 on Python 3.11; the same script reproduces EU1, EU3 and EU5's txid. The no-channel message's digest, d4e6becc...1c47, is recorded here in full. |