agentwallet-mcp 1.13.10 → 1.13.11

package/README.md

@@ -39,7 +39,7 @@ Run `wallet_mode` at any time and the server will tell you which one you are in,
 
 Use `AGENTWALLET_KEYFILE=/path/to/key` instead if you would rather keep the key out of your shell config (one or the other: the server refuses to start when both are set). The key is read once, never written to disk, never logged, and never included in an error message.
 
-`AGENTWALLET_RPC_<chainId>` (or `AGENTWALLET_RPC_URL` for all chains) points at an endpoint you trust. Without it a public RPC is used, and a public RPC can see which addresses you ask about.
+`AGENTWALLET_RPC_<chainId>` (or `AGENTWALLET_RPC_URL` for all chains) points at an endpoint you trust (https; plain http only on localhost). Without it a public RPC is used, and a public RPC can see which addresses you ask about. Decimals for a token outside the registry come from that RPC and are accepted only up to 18; pin anything else with `AGENTWALLET_TOKEN_DECIMALS`.
 
 `AGENTWALLET_MAX_TX_NATIVE` is a per-transaction ceiling in native units (ETH, MATIC and so on). In hosted mode the server enforces limits; in local mode there is no server, so these guards are the only ones there are. Set them.
 
@@ -330,6 +330,7 @@ Which guards apply depends on who holds the key.
 **Local mode** (you hold the key): there is no server in the signing path, so the server-side limits and pause above cannot see or stop a locally signed transaction, and nobody (including us) can freeze a local wallet. Your protection is the per-transaction caps enforced inside your own process before anything is signed. Set them before you fund the wallet; an unset cap means no limit.
 
 - `AGENTWALLET_MAX_TX_NATIVE`: ceiling per transaction in native units (ETH, MATIC, and so on)
+- `AGENTWALLET_MAX_FEE_NATIVE`: the most one transaction may burn in fees, gas x max fee per gas, in native units (default `0.01`). The value cap alone did not bound fees: a node answering an absurd tip or gas estimate could take the whole balance as priority fee on a cap-compliant transfer. Caller-supplied `gas_limit` / `max_fee` / `priority_fee` are honoured and then bounded by this cap
 - `AGENTWALLET_MAX_TX_TOKEN`: ceiling per ERC-20 transfer or approval, in human units of the token
 - `AGENTWALLET_ALLOW_UNKNOWN_TOKEN_CALLS`: set to `1` to let calldata the token cap cannot price reach a token contract or Permit2 (refused by default while the cap is set)
 - `AGENTWALLET_TOKEN_DECIMALS`: pin decimals for tokens outside the registry (`8453:0x<token>=6,<mint>=9`); a pin is used for amounts and caps instead of asking the RPC

package/build/index.js

@@ -119,7 +119,12 @@ async function routeLocally(path, method, body) {
             throw new Error(`Local mode expects an EVM address, got "${to}".`);
         }
         const hasData = data && data !== '0x';
-        return localSend(chainId, to, value, hasData ? data : undefined);
+        const fees = {
+            ...(body?.gas_limit ? { gas: String(body.gas_limit) } : {}),
+            ...(body?.max_fee ? { maxFeePerGas: String(body.max_fee) } : {}),
+            ...(body?.priority_fee ? { maxPriorityFeePerGas: String(body.priority_fee) } : {}),
+        };
+        return localSend(chainId, to, value, hasData ? data : undefined, fees);
     }
     // POST /wallets/{id}/x402/authorize  (x402 "exact": EIP-3009 authorization, signed here, broadcast by nobody)
     if (method === 'POST' && /^\/wallets\/[^/]*\/x402\/authorize$/.test(rawPath)) {
@@ -603,7 +608,7 @@ async function verifiedDecimals(chainId, token, given) {
 /** Cap variables are read at send time; a typo must fail at startup, not after funding. */
 function validateGuardEnv() {
     parseDecimalPins(process.env.AGENTWALLET_TOKEN_DECIMALS); // throws on a malformed pin
-    for (const name of ['AGENTWALLET_MAX_TX_NATIVE', 'AGENTWALLET_MAX_TX_TOKEN', 'AGENTWALLET_MAX_TX_SOL', 'AGENTWALLET_MAX_AUTOPAY']) {
+    for (const name of ['AGENTWALLET_MAX_TX_NATIVE', 'AGENTWALLET_MAX_TX_TOKEN', 'AGENTWALLET_MAX_TX_SOL', 'AGENTWALLET_MAX_AUTOPAY', 'AGENTWALLET_MAX_FEE_NATIVE']) {
         const raw = process.env[name];
         const v = (raw || '').trim();
         // Set but blank is a typo, not "no cap": refuse to start rather than run uncapped.
@@ -654,7 +659,7 @@ function validateGuardEnv() {
         throw new Error(`Unknown environment variable ${k}. AgentWallet refuses to start on an unrecognised AGENTWALLET_* name so that a misspelled cap cannot run uncapped. Known names: ${[...KNOWN_ENV].join(', ')}, AGENTWALLET_RPC_<chainId>, AGENTWALLET_SOLANA_RPC_<chainId>.`);
     }
 }
-const KNOWN_ENV = new Set(["AGENTWALLET_ALLOW_UNKNOWN_TOKEN_CALLS", "AGENTWALLET_API_URL", "AGENTWALLET_APPROVALS", "AGENTWALLET_AUTOPAY_ASSETS", "AGENTWALLET_CHAIN_ID", "AGENTWALLET_DASHBOARD_URL", "AGENTWALLET_KEYFILE", "AGENTWALLET_LEGACY_PAYWALL_ORIGINS", "AGENTWALLET_MAX_AUTOPAY", "AGENTWALLET_MAX_AUTOPAY_PER_HOUR", "AGENTWALLET_MAX_TX_NATIVE", "AGENTWALLET_MAX_TX_SOL", "AGENTWALLET_MAX_TX_TOKEN", "AGENTWALLET_PASS", "AGENTWALLET_PERMIT2_AUTO_APPROVE", "AGENTWALLET_PRIVATE_KEY", "AGENTWALLET_RPC_URL", "AGENTWALLET_SOLANA_KEY", "AGENTWALLET_SOLANA_KEYFILE", "AGENTWALLET_SOLANA_RPC", "AGENTWALLET_TOKEN_DECIMALS", "AGENTWALLET_TOKEN_RISK", "AGENTWALLET_USER", "AGENTWALLET_WALLET_ID", "AGENTWALLET_X402_MAX_TIMEOUT"]);
+const KNOWN_ENV = new Set(["AGENTWALLET_ALLOW_UNKNOWN_TOKEN_CALLS", "AGENTWALLET_API_URL", "AGENTWALLET_APPROVALS", "AGENTWALLET_AUTOPAY_ASSETS", "AGENTWALLET_CHAIN_ID", "AGENTWALLET_DASHBOARD_URL", "AGENTWALLET_KEYFILE", "AGENTWALLET_LEGACY_PAYWALL_ORIGINS", "AGENTWALLET_MAX_AUTOPAY", "AGENTWALLET_MAX_AUTOPAY_PER_HOUR", "AGENTWALLET_MAX_FEE_NATIVE", "AGENTWALLET_MAX_TX_NATIVE", "AGENTWALLET_MAX_TX_SOL", "AGENTWALLET_MAX_TX_TOKEN", "AGENTWALLET_PASS", "AGENTWALLET_PERMIT2_AUTO_APPROVE", "AGENTWALLET_PRIVATE_KEY", "AGENTWALLET_RPC_URL", "AGENTWALLET_SOLANA_KEY", "AGENTWALLET_SOLANA_KEYFILE", "AGENTWALLET_SOLANA_RPC", "AGENTWALLET_TOKEN_DECIMALS", "AGENTWALLET_TOKEN_RISK", "AGENTWALLET_USER", "AGENTWALLET_WALLET_ID", "AGENTWALLET_X402_MAX_TIMEOUT"]);
 /**
  * Register a tool whose arguments are strict: an unknown key (max_payemnt for
  * max_payment) is an error that names it, not a silently dropped guard. The
@@ -742,7 +747,7 @@ function resolveChainId(network) {
 const AddressSchema = z.string().regex(/^(0x[a-fA-F0-9]{40}|[1-9A-HJ-NP-Za-km-z]{32,44})$/, 'Must be a 0x-prefixed 40-hex EVM address or a base58 Solana address');
 const server = new McpServer({
     name: 'agentwallet',
-    version: '1.13.10',
+    version: '1.13.11',
 }, {
     instructions: `AgentWallet gives AI agents their own blockchain wallets. ${anyLocalMode()
         ? 'This server runs in LOCAL (self-custody) mode: the operator supplied the key, signing happens in this process, and the only spend guards are the environment caps (AGENTWALLET_MAX_TX_NATIVE / _TOKEN / _SOL per transaction, AGENTWALLET_MAX_AUTOPAY and AGENTWALLET_AUTOPAY_ASSETS for x402, AGENTWALLET_X402_MAX_TIMEOUT for authorization windows). There is no server-side pause, daily limit or approval email; pause_wallet, unpause_wallet and delete_wallet are refused.'
@@ -2115,6 +2120,7 @@ tool('wallet_mode', 'Report whether this server is signing locally (self-custody
             address: getLocalAddress(),
             rpc_endpoint: redactUrl(rpc),
             per_tx_cap_native: (process.env.AGENTWALLET_MAX_TX_NATIVE || '').trim() || 'not set',
+            per_tx_fee_cap_native: (process.env.AGENTWALLET_MAX_FEE_NATIVE || '').trim() || '0.01 (default)',
         };
     }
     else {

package/build/local-wallet.d.ts

@@ -49,14 +49,15 @@ export declare function localNativeBalance(chainId: number): Promise<{
     mode: string;
 }>;
 export declare function localTokenBalance(chainId: number, token: Address): Promise<{
+    mode: string;
+    warning?: string | undefined;
     address: `0x${string}`;
     chain_id: number;
     token: `0x${string}`;
     symbol: string;
-    decimals: number;
+    decimals: number | null;
     balance_raw: string;
-    balance: string;
-    mode: string;
+    balance: string | null;
 }>;
 export interface LocalSendResult {
     tx_hash: string;
@@ -66,6 +67,9 @@ export interface LocalSendResult {
     chain_id: number;
     mode: 'local';
     signed_locally: true;
+    gas?: string;
+    max_fee_per_gas?: string;
+    worst_case_fee?: string;
 }
 /**
  * What a decimals() probe learned about an address. The four outcomes are
@@ -89,7 +93,20 @@ type DecimalsProbe = number | 'unusable' | 'not-a-token' | 'unreachable';
 /** An eth_call failure is a revert only when the node says so; every other failure is "could not ask". */
 export declare function classifyDecimalsError(err: unknown): DecimalsProbe;
 export declare function permit2AddressFor(chainId: number): string;
-export declare function localSend(chainId: number, to: Address, valueWei: bigint, data?: Hex): Promise<LocalSendResult>;
+/** Caller-chosen gas parameters (wei / gas units as decimal strings); honoured, then bounded by the fee cap. */
+export interface FeeOverrides {
+    gas?: string;
+    maxFeePerGas?: string;
+    maxPriorityFeePerGas?: string;
+}
+/**
+ * The most a transaction may burn in fees: gas x maxFeePerGas, in native units.
+ * Without it a node that answered a 47,000 gwei tip or a 30M gas estimate took
+ * the whole balance as fees on a cap-compliant 0.001 ETH transfer (round 4).
+ * Default 0.01; AGENTWALLET_MAX_FEE_NATIVE raises or lowers it.
+ */
+export declare function feeCapWei(): bigint;
+export declare function localSend(chainId: number, to: Address, valueWei: bigint, data?: Hex, fees?: FeeOverrides): Promise<LocalSendResult>;
 /** ERC-20 transfer, encoded locally. */
 export declare function localTransferToken(chainId: number, token: Address, to: Address, rawAmount: string): Promise<LocalSendResult>;
 /** ERC-20 approve, encoded locally. */

package/build/local-wallet.js

@@ -15,7 +15,7 @@
  * on the custodial path and say so explicitly rather than silently downgrading.
  */
 import { readFileSync, statSync } from 'node:fs';
-import { createPublicClient, createWalletClient, http, encodeFunctionData, parseAbi, formatUnits, } from 'viem';
+import { createPublicClient, createWalletClient, http, encodeFunctionData, parseAbi, formatUnits, keccak256, } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 import { nonceManager } from 'viem/nonce';
 import { lookupTrustedDecimals, maxAuthWindowSeconds } from './x402-payment.js';
@@ -109,16 +109,31 @@ const DEFAULT_RPC = {
 export function resolveRpcUrl(chainId) {
     const perChain = (process.env[`AGENTWALLET_RPC_${chainId}`] || '').trim();
     if (perChain)
-        return perChain;
+        return assertRpcScheme(perChain, `AGENTWALLET_RPC_${chainId}`);
     const generic = (process.env.AGENTWALLET_RPC_URL || '').trim();
     if (generic)
-        return generic;
+        return assertRpcScheme(generic, 'AGENTWALLET_RPC_URL');
     const fallback = DEFAULT_RPC[chainId];
     if (fallback)
         return fallback;
     throw new Error(`No RPC endpoint for chain ${chainId} in local mode. ` +
         `Set AGENTWALLET_RPC_${chainId} to an endpoint you trust.`);
 }
+/** An RPC over plain http to anything but loopback is the hostile-node model in full; refused like the API URL is. */
+function assertRpcScheme(url, name) {
+    let u;
+    try {
+        u = new URL(url);
+    }
+    catch {
+        throw new Error(`${name} is not a URL: "${url}".`);
+    }
+    const loopback = u.hostname === 'localhost' || u.hostname === '127.0.0.1' || u.hostname === '[::1]';
+    if (u.protocol !== 'https:' && !(u.protocol === 'http:' && loopback)) {
+        throw new Error(`${name} must be https (got ${u.protocol}//${u.host}); plain http is allowed only for localhost.`);
+    }
+    return url;
+}
 /**
  * Chain ids each RPC URL has been seen to serve, so an operator pointing
  * AGENTWALLET_RPC_URL at one node for every chain, or mistyping a per-chain
@@ -187,16 +202,21 @@ const ERC20_ABI = parseAbi([
 export async function localTokenBalance(chainId, token) {
     const { pub } = clients(chainId);
     const address = getLocalAddress();
-    const [raw, decimals, symbol] = await Promise.all([
+    const [raw, decimalsRaw, symbol] = await Promise.all([
         pub.readContract({ address: token, abi: ERC20_ABI, functionName: 'balanceOf', args: [address] }),
-        pub.readContract({ address: token, abi: ERC20_ABI, functionName: 'decimals' }).catch(() => 18),
+        pub.readContract({ address: token, abi: ERC20_ABI, functionName: 'decimals' }).catch(() => null),
         pub.readContract({ address: token, abi: ERC20_ABI, functionName: 'symbol' }).catch(() => ''),
     ]);
+    // A decimals() of 2^20 handed to viem's formatUnits held the whole server for
+    // minutes (quadratic trailing-zero trim, round 4): only 0..36 is formatted.
+    const d = Number(decimalsRaw);
+    const safe = Number.isInteger(d) && d >= 0 && d <= 36 ? d : null;
     return {
         address, chain_id: chainId, token, symbol,
-        decimals: Number(decimals),
+        decimals: safe,
         balance_raw: raw.toString(),
-        balance: formatUnits(raw, Number(decimals)),
+        balance: safe === null ? null : formatUnits(raw, safe),
+        ...(safe === null ? { warning: 'the token reported decimals outside 0..36 (or none); only the raw balance is shown' } : {}),
         mode: 'local',
     };
 }
@@ -261,8 +281,11 @@ async function probeTokenDecimals(chainId, token) {
         return 'unusable'; // answered, but not one uint8 word
     const d = Number(BigInt(result));
     // Reject nonsense rather than trusting it; an out-of-range value would
-    // widen the ceiling exactly like the old assumption did.
-    if (Number.isInteger(d) && d >= 0 && d <= 36) {
+    // widen the ceiling exactly like the old assumption did. Above 18 the RPC is
+    // the only witness and a lie there scales the cap by 10^18 (a node saying 36
+    // for mainnet WETH, round 4): such tokens must be pinned with
+    // AGENTWALLET_TOKEN_DECIMALS.
+    if (Number.isInteger(d) && d >= 0 && d <= 18) {
         decimalsCache.set(key, d);
         return d;
     }
@@ -435,7 +458,25 @@ async function assertWithinTokenCap(chainId, to, data, valueWei = 0n) {
         }
     }
 }
-export async function localSend(chainId, to, valueWei, data) {
+function parseUint(v, what) {
+    if (!/^\d{1,40}$/.test(v))
+        throw new Error(`${what} must be a non-negative integer string, got "${v}".`);
+    return BigInt(v);
+}
+/**
+ * The most a transaction may burn in fees: gas x maxFeePerGas, in native units.
+ * Without it a node that answered a 47,000 gwei tip or a 30M gas estimate took
+ * the whole balance as fees on a cap-compliant 0.001 ETH transfer (round 4).
+ * Default 0.01; AGENTWALLET_MAX_FEE_NATIVE raises or lowers it.
+ */
+export function feeCapWei() {
+    const raw = (process.env.AGENTWALLET_MAX_FEE_NATIVE || '0.01').trim();
+    if (!/^\d+(\.\d+)?$/.test(raw))
+        throw new Error(`AGENTWALLET_MAX_FEE_NATIVE must be a decimal number, got "${raw}".`);
+    const [whole, frac = ''] = raw.split('.');
+    return BigInt(whole + frac.padEnd(18, '0').slice(0, 18));
+}
+export async function localSend(chainId, to, valueWei, data, fees) {
     assertWithinNativeCap(valueWei);
     if (data && data !== '0x') {
         if (!/^0x([0-9a-fA-F]{2})*$/.test(data))
@@ -443,20 +484,73 @@ export async function localSend(chainId, to, valueWei, data) {
         await assertWithinTokenCap(chainId, to, data, valueWei);
     }
     await assertRpcServesChain(chainId);
-    const { wallet } = clients(chainId);
-    const hash = await wallet.sendTransaction({
-        to,
-        value: valueWei,
-        ...(data ? { data } : {}),
+    const { pub, wallet } = clients(chainId);
+    const account = getLocalAccount();
+    const base = { account, to, value: valueWei, ...(data ? { data } : {}) };
+    // Gas: the caller's figure when given (it used to be read and dropped,
+    // round 4), otherwise the node's estimate.
+    const gas = fees?.gas ? parseUint(fees.gas, 'gas_limit') : await pub.estimateGas(base);
+    // Fees: the caller's figures when given, otherwise the node's; either way the
+    // worst case gas x maxFeePerGas must fit the fee cap before anything is signed.
+    let maxFeePerGas;
+    let maxPriorityFeePerGas;
+    let gasPrice;
+    if (fees?.maxFeePerGas) {
+        maxFeePerGas = parseUint(fees.maxFeePerGas, 'max_fee');
+        maxPriorityFeePerGas = fees.maxPriorityFeePerGas ? parseUint(fees.maxPriorityFeePerGas, 'priority_fee') : maxFeePerGas;
+    }
+    else {
+        try {
+            const est = await pub.estimateFeesPerGas();
+            maxFeePerGas = est.maxFeePerGas;
+            maxPriorityFeePerGas = fees?.maxPriorityFeePerGas ? parseUint(fees.maxPriorityFeePerGas, 'priority_fee') : est.maxPriorityFeePerGas;
+        }
+        catch {
+            gasPrice = (await pub.estimateFeesPerGas({ type: 'legacy' })).gasPrice; // a chain without EIP-1559
+        }
+    }
+    if (maxFeePerGas !== undefined && maxPriorityFeePerGas !== undefined && maxPriorityFeePerGas > maxFeePerGas)
+        maxPriorityFeePerGas = maxFeePerGas;
+    const perGas = maxFeePerGas ?? gasPrice ?? 0n;
+    const worst = gas * perGas;
+    const feeCap = feeCapWei();
+    if (worst > feeCap) {
+        throw new Error(`Blocked by local guard: the transaction could burn up to ${formatUnits(worst, 18)} native in fees (gas ${gas} x ${formatUnits(perGas, 9)} gwei), ` +
+            `above AGENTWALLET_MAX_FEE_NATIVE (${formatUnits(feeCap, 18)}). A node answering an absurd fee or gas estimate is the usual cause; ` +
+            `pass gas_limit / max_fee / priority_fee explicitly, or the operator can raise the cap.`);
+    }
+    // Sign here, hash here, then hand the bytes to the node: the hash reported is
+    // the one computed from the signed transaction, never the node's answer.
+    const address = getLocalAddress();
+    const nonce = await account.nonceManager.consume({ address, chainId, client: pub });
+    const request = await wallet.prepareTransactionRequest({
+        ...base, gas, nonce, chainId,
+        ...(gasPrice !== undefined ? { type: 'legacy', gasPrice } : { type: 'eip1559', maxFeePerGas: maxFeePerGas, maxPriorityFeePerGas: maxPriorityFeePerGas }),
     });
+    const signed = await wallet.signTransaction(request);
+    const localHash = keccak256(signed);
+    let reported;
+    try {
+        reported = await pub.sendRawTransaction({ serializedTransaction: signed });
+    }
+    catch (e) {
+        account.nonceManager.reset({ address, chainId });
+        throw new Error(`Broadcast of transaction ${localHash} (nonce ${nonce}) failed: ${e.message.split('\n')[0]}. The transaction is signed and MAY be live if the node forwarded it before answering; check the hash on an explorer before retrying.`);
+    }
+    if (reported.toLowerCase() !== localHash.toLowerCase()) {
+        throw new Error(`Transaction ${localHash} (nonce ${nonce}) was BROADCAST, but the node answered with a different hash (${String(reported).slice(0, 80)}), so it cannot be trusted about its fate. Verify ${localHash} on an explorer before retrying.`);
+    }
     return {
-        tx_hash: hash,
-        from: getLocalAddress(),
+        tx_hash: localHash,
+        from: address,
         to,
         value: valueWei.toString(),
         chain_id: chainId,
         mode: 'local',
         signed_locally: true,
+        gas: gas.toString(),
+        max_fee_per_gas: (maxFeePerGas ?? gasPrice ?? 0n).toString(),
+        worst_case_fee: formatUnits(worst, 18),
     };
 }
 /** ERC-20 transfer, encoded locally. */

package/build/x402-payment.d.ts

@@ -1,19 +1,3 @@
-/**
- * Pure helpers for x402 auto-pay amount/token derivation.
- *
- * Isolated from the server bootstrap in index.ts so the funds-sensitive amount
- * math can be unit-tested without starting the MCP server.
- *
- * SECURITY INVARIANT: token decimals must NEVER come from the 402 response.
- * A resource server controls `asset`, `payTo`, `maxAmountRequired` AND
- * `requiredDecimals`. If the cap is scaled using server-declared decimals, the
- * server can inflate the cap arbitrarily: declaring 18 decimals for 6-decimal
- * USDC turns a "1 USDC" cap into 10^18 base units, so a request for
- * 1,000,000,000,000 units (1,000,000 USDC) passes a 1 USDC cap. Reported by
- * ARC Security Research, 2026-08-02, against 1.10.1. Decimals are now resolved
- * from a trusted source and the declared value is only ever used to detect a
- * mismatch and refuse.
- */
 export interface X402AcceptLike {
     maxAmountRequired: string;
     requiredDecimals?: number;

package/build/x402-payment.js

@@ -14,6 +14,7 @@
  * from a trusted source and the declared value is only ever used to detect a
  * mismatch and refuse.
  */
+import { wrappedNativeAddress } from './wrapped-native.js';
 /**
  * Decimals for assets that x402 endpoints actually settle in, keyed by
  * chain id then lowercased contract address (or SPL mint on Solana).
@@ -283,6 +284,11 @@ export function lookupTrustedDecimals(chainId, token) {
     const pinned = pinnedDecimals(chainId, token);
     if (pinned !== null)
         return pinned;
+    // Every chain's wrapped native coin is 18 decimals (WETH9 clones; the local
+    // guard asserts it). The registry carried WETH for Base only, so mainnet WETH
+    // was priced by the RPC, which could say 36 (2026-10-04 round 4).
+    if (wrappedNativeAddress(chainId)?.toLowerCase() === token.toLowerCase())
+        return 18;
     const spl = TRUSTED_SPL_DECIMALS[token];
     if (typeof spl === 'number')
         return spl;

package/package.json

@@ -2,7 +2,7 @@
   "name": "agentwallet-mcp",
   "mcpName": "io.github.hifriendbot/agentwallet",
   "repository": { "type": "git", "url": "https://github.com/hifriendbot/agentwallet-mcp" },
-  "version": "1.13.10",
+  "version": "1.13.11",
   "description": "MCP server for AgentWallet: self-custody local signing on EVM and Solana, or hosted wallets. Sign, broadcast, pay x402 invoices, and accept x402 payments.",
   "type": "module",
   "main": "build/index.js",
@@ -17,7 +17,7 @@
   "scripts": {
     "build": "tsc",
     "start": "node build/index.js",
-    "test": "node test/x402-payment.test.mjs && node test/eip3009.test.mjs && node test/permit2-risk.test.mjs && node test/token-cap.test.mjs && node test/spl-cap.test.mjs && node test/unknown-decimals-cap.test.mjs && node test/decimals-range-cap.test.mjs && node test/local-mode.test.mjs && node test/ssrf-guard.test.mjs && node test/x402-policy.test.mjs && node test/local-guard-shape.test.mjs && node test/allowance-total-cap.test.mjs && node test/autopay-scheme.test.mjs && node test/spl-recipient-guard.test.mjs && node test/approval-binding.test.mjs && node test/ata-rent-size.test.mjs && node test/final-url-guard.test.mjs && node test/audit-1135.test.mjs && node test/local-no-autopay.test.mjs && node test/audit-1136.test.mjs && node test/delete-confirm.test.mjs && node test/audit-1138.test.mjs && node test/audit-1139.test.mjs && node test/audit-11310.test.mjs",
+    "test": "node test/x402-payment.test.mjs && node test/eip3009.test.mjs && node test/permit2-risk.test.mjs && node test/token-cap.test.mjs && node test/spl-cap.test.mjs && node test/unknown-decimals-cap.test.mjs && node test/decimals-range-cap.test.mjs && node test/local-mode.test.mjs && node test/ssrf-guard.test.mjs && node test/x402-policy.test.mjs && node test/local-guard-shape.test.mjs && node test/allowance-total-cap.test.mjs && node test/autopay-scheme.test.mjs && node test/spl-recipient-guard.test.mjs && node test/approval-binding.test.mjs && node test/ata-rent-size.test.mjs && node test/final-url-guard.test.mjs && node test/audit-1135.test.mjs && node test/local-no-autopay.test.mjs && node test/audit-1136.test.mjs && node test/delete-confirm.test.mjs && node test/audit-1138.test.mjs && node test/audit-1139.test.mjs && node test/audit-11310.test.mjs && node test/audit-11311.test.mjs",
     "prepublishOnly": "npm run build"
   },
   "keywords": [