agent-economy-wallet

/// Create a StreamSession PDA on L1 before delegation.pub fn initialize_session(    ctx: Context<InitializeSession>,    session_id: [u8; 16],    rate_per_tick: u64,    interval_ms: u64,) -> Result<()> {    require!(interval_ms >= 500, StreamError::IntervalTooFast);    require!(rate_per_tick > 0, StreamError::InvalidRate);     let session = &mut ctx.accounts.session;    session.session_id = session_id;    session.buyer = ctx.accounts.payer.key();    session.merchant = ctx.accounts.merchant.key();    session.rate_per_tick = rate_per_tick;    session.interval_ms = interval_ms;    session.tick_count = 0;    session.total_paid = 0;    session.status = SessionStatus::Active;    session.started_at = Clock::get()?.unix_timestamp;    session.bump = ctx.bumps.session;     msg!(        "Stream session initialized: buyer={}, merchant={}, rate={}/{}ms",

1. Line 20 require!(interval_ms >= 500, StreamError::IntervalTooFast);: An explicit validation that aborts the instruction with an error.
2. Line 32 session.started_at = Clock::get()?.unix_timestamp;: Reads on-chain time from the Clock sysvar.
3. Line 33 session.bump = ctx.bumps.session;: Uses the bump seed, the extra byte that pushes the derived address off the ed25519 curve.
4. Line 35 msg!(: Logs to the program log, which is visible in explorers and the test output.

    account.total_payments = 0;    account.total_volume_lamports = 0;    account.unique_buyers = 0;    account.last_payment_ts = 0;    account.bump = ctx.bumps.merchant_account;     msg!(        "Merchant reputation initialized: {}",        ctx.accounts.merchant.key()    );    Ok(())} /// Record a payment to a merchant./// Called by the buyer after a successful x402 payment./// Updates total payment count, volume, and timestamp.////// The unique_buyers counter is incremented every 5 payments as/// a simple heuristic — a production version would track exact/// unique buyers via a bitmap or separate PDA.pub fn record_payment(ctx: Context<RecordPayment>, amount: u64) -> Result<()> {    let account = &mut ctx.accounts.merchant_account;     account.total_payments = account.total_payments.checked_add(1).unwrap();

1. Line 17 account.bump = ctx.bumps.merchant_account;: Uses the bump seed, the extra byte that pushes the derived address off the ed25519 curve.
2. Line 19 msg!(: Logs to the program log, which is visible in explorers and the test output.
3. Line 27 /// Called by the buyer after a successful x402 payment.: Uses x402, an HTTP 402 pattern where an agent pays per request with an on-chain payment.
4. Line 36 account.total_payments = account.total_payments.checked_add(1).unwrap();: Uses checked arithmetic so overflow fails instead of wrapping.

import { registerGetBalanceTool } from "./wallet/get-balance.js";// close-wallet is intentionally NOT registered here.// Wallet closure is a destructive, irreversible operation and must only be// initiated by a human via the CLI. Agents must never be able to close wallets.import { registerGetAuditLogsTool } from "./wallet/get-audit-logs.js";import { registerGetStatusTool } from "./wallet/get-status.js";import { registerGetPolicyTool } from "./wallet/get-policy.js";import { registerSendSolTool } from "./transfers/send-sol.js";import { registerSendTokenTool } from "./transfers/send-token.js";import { registerWriteMemoTool } from "./transfers/write-memo.js";import { registerMintTokenTool } from "./tokens/mint-token.js"; // payments/import { registerPayX402Tool } from "./payments/pay-x402.js";import { registerProbeX402Tool } from "./payments/probe-x402.js"; // merchant/import { registerFetchPricesTool } from "./merchant/fetch-prices.js";import { registerAnalyzeTokenSecurityTool } from "./merchant/analyze-token-security.js";import { registerMonitorNetworkOracleTool } from "./merchant/monitor-network-oracle.js"; // discovery/ — buyer agent tools for finding and evaluating merchantsimport { registerDiscoverRegistryTool } from "./discovery/discover-registry.js";import { registerReadManifestTool } from "./discovery/read-manifest.js";

1. Line 23 import { registerMintTokenTool } from "./tokens/mint-token.js";: Mints new tokens. The mint authority must sign.
2. Line 26 import { registerPayX402Tool } from "./payments/pay-x402.js";: Uses x402, an HTTP 402 pattern where an agent pays per request with an on-chain payment.

        fetchOptions.body = body;      }       // Sign callback — signs via WalletService which enforces policies      const signTx = async (tx: Transaction): Promise<Transaction> => {        // We need to sign the transaction with the wallet's keypair.        // The WalletService.signAndSendTransaction sends immediately, but        // for x402 we only need a signature (the facilitator submits).        // We unlock the keypair through KeyManager and sign locally.        const keypair = keyManager.unlockWallet(wallet_id);         // Policy check via a lightweight limits check        const violation = services.policyEngine.checkLimits(wallet_id, 0);        if (violation) {          throw new Error(`Policy violation: ${violation}`);        }         // Every Solana transaction needs a recent blockhash before it can be        // signed.  The x402 client builds the transaction without one (it has        // no RPC access), so we must hydrate it here before calling partialSign.        if (!tx.recentBlockhash) {          const { blockhash } = await services.connection.getLatestBlockhash();          tx.recentBlockhash = blockhash;        }

1. Line 92 // for x402 we only need a signature (the facilitator submits).: Uses x402, an HTTP 402 pattern where an agent pays per request with an on-chain payment.
2. Line 106 const { blockhash } = await services.connection.getLatestBlockhash();: Fetches a recent blockhash. Transactions expire if it gets too old.