agentic_commerce

        init,        payer = payer,        space = 8 + Order::INIT_SPACE,        seeds = [b"order", order_id.as_ref()],        bump    )]    pub order: Box<Account<'info, Order>>,    /// The escrow vault. Its owner, the order account, is what gets quoted as    /// the x402 `payTo`, so a buyer can derive and check it from the order id.    #[account(        init_if_needed,        payer = payer,        associated_token::mint = mint,        associated_token::authority = order    )]    pub vault: Box<Account<'info, TokenAccount>>,    #[account(address = config.mint @ TesseraError::MintMismatch)]    pub mint: Box<Account<'info, Mint>>,    /// CHECK: recorded as the buyer; does not sign.    pub buyer: UncheckedAccount<'info>,    /// The merchant agrees to every order opened in its name.    pub merchant: Signer<'info>,    #[account(mut, seeds = [b"agent", buyer.key().as_ref()], bump = buyer_agent.bump)]    pub buyer_agent: Box<Account<'info, Agent>>,

1. Line 985 init,: Creates and pays for a new account. Space and payer must be specified.
2. Line 988 seeds = [b"order", order_id.as_ref()],: Declares the PDA seeds. Anchor re-derives the address and rejects the account if it doesn't match.
3. Line 989 bump: Uses the bump seed, the extra byte that pushes the derived address off the ed25519 curve.
4. Line 993 /// the x402 `payTo`, so a buyer can derive and check it from the order id.: Uses x402, an HTTP 402 pattern where an agent pays per request with an on-chain payment.
5. Line 995 init_if_needed,: Creates the account only if it doesn't exist. Watch for re-initialisation bugs.
6. Line 1006 pub merchant: Signer<'info>,: Requires this account to have signed the transaction.

    try {      localStorage.setItem(KEY, hex);    } catch {      // not persisted; the wallet lasts until the tab closes    }  }  return createKeyPairSignerFromPrivateKeyBytes(fromHex(hex));} /** Send with plain HTTP: preflight, then poll the signature. */export async function sendWith(payer: TransactionSigner, instructions: Instruction[]): Promise<string> {  const { value: latest } = await readRpc.getLatestBlockhash({ commitment: 'confirmed' }).send();  const message = pipe(    createTransactionMessage({ version: 0 }),    (m) => setTransactionMessageFeePayerSigner(payer, m),    (m) => setTransactionMessageLifetimeUsingBlockhash(latest, m),    (m) => appendTransactionMessageInstructions(instructions, m),  );  const signed = await signTransactionMessageWithSigners(message);  const signature = getSignatureFromTransaction(signed);  const wire = getBase64EncodedWireTransaction(signed);  await readRpc.sendTransaction(wire, { encoding: 'base64', preflightCommitment: 'confirmed' }).send();  const started = Date.now();  for (;;) {

1. Line 48 const { value: latest } = await readRpc.getLatestBlockhash({ commitment: 'confirmed' }).se: Fetches a recent blockhash. Transactions expire if it gets too old.
2. Line 58 await readRpc.sendTransaction(wire, { encoding: 'base64', preflightCommitment: 'confirmed': Submits the signed transaction to the cluster.

 * The x402 payment is one token transfer of the order's amount into the * order's vault, authorised by `buyer`, and `buyer` really signed it. Checked * here, not left to the facilitator: a facilitator that says "success" for a * payment that did not fund this order must not make us deliver it. */async function paysThisOrder(payment: PaymentPayload, terms: EscrowTerms): Promise<boolean> {  try {    const buyer = terms.buyer;    const tx = decodeTransactionFromPayload(payment.payload as { transaction: string });    if (getTokenPayerFromTransaction(tx) !== buyer) return false;    const signature = tx.signatures[buyer];    if (!signature || !(await verifySignature(await getPublicKeyFromAddress(buyer), signature, tx.messageBytes))) return false;     const msg = getCompiledTransactionMessageDecoder().decode(tx.messageBytes);    // the payment scheme signs legacy or v0 messages with no lookup tables    if (msg.version === 1 || (msg.version === 0 && msg.addressTableLookups?.length)) return false;    const keys = msg.staticAccounts;    const tokenIxs = msg.instructions.filter((ix) => keys[ix.programAddressIndex] === TOKEN_PROGRAM_ADDRESS);    if (tokenIxs.length !== 1) return false;    const ix = tokenIxs[0]!;    const data = ix.data;    // TransferChecked: [12, amount u64 LE, decimals]; accounts source, mint, destination, authority    if (!data || data.length !== 10 || data[0] !== 12) return false;    const amount = new DataView(data.buffer, data.byteOffset, data.byteLength).getBigUint64(1, true);

1. Line 169 * The x402 payment is one token transfer of the order's amount into the: Uses x402, an HTTP 402 pattern where an agent pays per request with an on-chain payment.
2. Line 190 // TransferChecked: [12, amount u64 LE, decimals]; accounts source, mint, destination, aut: A checked token transfer, which also verifies the mint and decimals.

 * send with preflight, then poll the signature. No websocket per client, * which is what public endpoints rate-limit hardest. */export function clientForSigner(kp: KeyPairSigner, cluster: Cluster = DEVNET) {  const transport = transportFor(cluster);  const rpc = createSolanaRpcFromTransport(transport);  // A blockhash is good for about a minute; reuse it for a few seconds on shared endpoints.  const reuseMs = cluster.budgetPer10s ? 4000 : 0;   async function sendTransaction(instructions: Instruction[]): Promise<{ context: { signature: string } }> {    let latest = blockhashes.get(transport);    if (!latest || Date.now() - latest.at > reuseMs) {      const { value } = await rpc.getLatestBlockhash({ commitment: 'confirmed' }).send();      latest = { at: Date.now(), value };      blockhashes.set(transport, latest);    }    const message = pipe(      createTransactionMessage({ version: 0 }),      (m) => setTransactionMessageFeePayerSigner(kp, m),      (m) => setTransactionMessageLifetimeUsingBlockhash(latest!.value as never, m),      (m) => appendTransactionMessageInstructions([getSetComputeUnitLimitInstruction({ units: 400_000 }), ...instructions], m),    );    const signed = await signTransactionMessageWithSigners(message);    const signature = getSignatureFromTransaction(signed);

1. Line 286 async function sendTransaction(instructions: Instruction[]): Promise<{ context: { signatur: Submits the signed transaction to the cluster.
2. Line 289 const { value } = await rpc.getLatestBlockhash({ commitment: 'confirmed' }).send();: Fetches a recent blockhash. Transactions expire if it gets too old.