agentwallet-mcp 1.12.4 → 1.12.6

package/README.md

@@ -43,7 +43,7 @@ Use `AGENTWALLET_KEYFILE=/path/to/key` instead if you would rather keep the key
 
 `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.
 
-`AGENTWALLET_MAX_TX_TOKEN` is the equivalent ceiling for ERC-20 movement, in human units of the token. **Set this one too if you hold stablecoins.** The native cap cannot see a token transfer: an ERC-20 send carries `value = 0` with the amount in the calldata, so `AGENTWALLET_MAX_TX_NATIVE` alone leaves a USDC balance uncapped. `AGENTWALLET_MAX_TX_TOKEN` covers `transfer`, `transferFrom`, `approve`, `increaseAllowance` and Permit2 `approve`, the approvals because an unbounded allowance is a drain waiting to happen. Any other calldata sent to a token contract or to Permit2 is refused while the cap is set, because the guard cannot price it; set `AGENTWALLET_ALLOW_UNKNOWN_TOKEN_CALLS=1` to allow such calls deliberately. Calls to other contracts (routers, bridges) pass, since they can only pull what an approval already allowed. Decimals are resolved locally from the trusted registry, then the token's own `decimals()`; a token that resolves neither way is evaluated at 0 decimals, the only value that cannot fail open.
+`AGENTWALLET_MAX_TX_TOKEN` is the equivalent ceiling for ERC-20 movement, in human units of the token. **Set this one too if you hold stablecoins.** The native cap cannot see a token transfer: an ERC-20 send carries `value = 0` with the amount in the calldata, so `AGENTWALLET_MAX_TX_NATIVE` alone leaves a USDC balance uncapped. `AGENTWALLET_MAX_TX_TOKEN` covers `transfer`, `transferFrom`, `approve`, `increaseAllowance`, Permit2 `approve`, and `deposit()` / `withdraw(uint256)` on the chain's own wrapped-native contract (so `wrap_eth` and `unwrap_eth` keep working under the cap), the approvals because an unbounded allowance is a drain waiting to happen. Any other calldata sent to a token contract or to Permit2 is refused while the cap is set, because the guard cannot price it; set `AGENTWALLET_ALLOW_UNKNOWN_TOKEN_CALLS=1` to allow such calls deliberately. Calls to other contracts (routers, bridges) pass, since they can only pull what an approval already allowed; a contract counts as "other" only when it demonstrably declines `decimals()`, so an absurd or malformed answer, or an RPC that cannot be reached, refuses rather than allows. Decimals are resolved locally from the trusted registry, then the token's own `decimals()`; a token that resolves neither way is evaluated at 0 decimals, the only value that cannot fail open.
 
 ### Solana local signing
 

package/build/index.js

@@ -16,6 +16,7 @@ import { assertPublicUrl, safeFetch } from './ssrf-guard.js';
 import { deriveX402Payment, isWithinCap, lookupTrustedDecimals, assertDeclaredDecimals, nativeDecimals, SOLANA_CHAIN_IDS, } from './x402-payment.js';
 import { isLocalMode, getLocalAddress, localWalletRecord, localSend, localNativeBalance, localTokenBalance, localSignMessage, resolveRpcUrl, } from './local-wallet.js';
 import { localSignAuthorization, localEthCall, localGetCode, localSignPermit2Upto } from './local-wallet.js';
+import { WRAPPED_NATIVE } from './wrapped-native.js';
 import { buildUptoAuthorization, uptoPayload, permit2AllowanceCalldata, permit2ApproveCalldata, decodeUint, PERMIT2_ADDRESS, } from './x402-permit2.js';
 import { assessTokenRisk } from './token-risk.js';
 import { isLegacyAgentWalletAccept, requiredAmount, buildAuthorization, buildPaymentPayload, buildPaymentPayloadRaw, paymentHeaderFor, parsePaymentRequired, parseSettlement, pickOption, knownTokenDomain, parseEip7702Delegation, erc1271ProbeCalldata, classifyErc1271Probe, } from './x402-eip3009.js';
@@ -467,82 +468,82 @@ 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.12.4',
+    version: '1.12.6',
 }, {
-    instructions: `AgentWallet gives AI agents their own blockchain wallets. Private keys are encrypted server-side and never exposed — agents sign and broadcast transactions without ever touching raw keys.
-
-## Getting Started
-1. Call list_wallets to see existing wallets, or create_wallet to make a new one.
-2. Fund the wallet by sending tokens to its address from an external source.
-3. Use transfer (native tokens) or transfer_token (ERC-20/SPL tokens) to send funds.
-
-## Supported Chains
-- **EVM chains:** Ethereum (1), Base (8453), Arbitrum (42161), Optimism (10), Polygon (137), Avalanche (43114), BSC (56), Zora (7777777), PulseChain (369)
-- **Solana:** Mainnet (900), Devnet (901)
-- Call get_chains for the full list with native tokens and stablecoin contract addresses.
-
-## EVM vs Solana
-- **Addresses:** EVM uses 0x-prefixed hex (42 chars). Solana uses Base58 (32-44 chars).
-- **Native tokens:** EVM = ETH/POL/BNB/etc (18 decimals, wei). Solana = SOL (9 decimals, lamports).
-- **Token standards:** EVM uses ERC-20. Solana uses SPL tokens.
-- **EVM-only tools:** approve_token, get_allowance, wrap_eth, unwrap_eth, call_contract, get_token_info. These do not work on Solana.
-- **Works on both:** create_wallet, transfer, transfer_token, send_transaction, sign_transaction, get_balance, get_token_balance.
-
-## Common Workflows
-
-### Send native tokens (ETH, SOL, etc.)
-Use the transfer tool with a human-readable amount (e.g. "0.1" ETH). It auto-converts to wei/lamports.
-
-### Send ERC-20 or SPL tokens
-Use transfer_token. You need: wallet_id, token contract address, recipient, amount, chain_id, and decimals (6 for USDC, 18 for most ERC-20s). Call get_chains to find stablecoin addresses.
-
-### Interact with DeFi (EVM only)
-1. Check allowance with get_allowance.
-2. If needed, call approve_token to let the DeFi contract spend your tokens.
-3. Use send_transaction with the contract's calldata to execute the interaction.
-
-### Wrap/unwrap native tokens (EVM only)
-Use wrap_eth to convert ETH → WETH (required by many DeFi protocols). Use unwrap_eth to convert back.
-
-### Read on-chain data (EVM only)
-Use call_contract for gas-free read-only calls (eth_call). Provide ABI-encoded calldata.
-
-## x402 Payments — Paying for Resources
-The pay_x402 tool handles the full x402 payment flow automatically:
-1. Fetches the URL.
-2. If the server returns HTTP 402, parses the payment requirements.
-3. Pays on-chain using your wallet.
-4. Retries the request with proof of payment.
-Always set max_payment to prevent overspending (e.g. "1.00" for max 1 USDC).
-
-## x402 Paywalls — Accepting Payments
-Create paywalls to charge other agents for accessing your resources:
-1. create_paywall — set price, token, chain, and the resource URL to protect.
-2. Share the access URL. Clients that pay on-chain get the resource; others get HTTP 402.
-3. list_paywalls and get_paywall_payments to track revenue.
-4. get_x402_revenue for aggregate stats across all paywalls.
-
-## Wallet Security
-- Use pause_wallet to immediately freeze a wallet if compromised. No transactions can be signed while paused.
-- Use unpause_wallet to resume operations.
-- Use delete_wallet to permanently disable a wallet.
-- Wallets have server-enforced spending limits.
-
-## Tool Selection Guide
-| Goal | Tool |
-|------|------|
-| Send ETH/SOL/native tokens | transfer |
-| Send USDC/ERC-20/SPL tokens | transfer_token |
-| Check native balance | get_balance |
-| Check token balance | get_token_balance |
-| Look up token details | get_token_info (EVM only) |
-| Approve DeFi spending | approve_token (EVM only) |
-| Check approval amount | get_allowance (EVM only) |
-| Read smart contract | call_contract (EVM only) |
-| Custom transaction | send_transaction |
-| Sign without broadcasting | sign_transaction |
-| Pay for x402 resource | pay_x402 |
-| Charge for your resource | create_paywall |
+    instructions: `AgentWallet gives AI agents their own blockchain wallets. Private keys are encrypted server-side and never exposed — agents sign and broadcast transactions without ever touching raw keys.
+
+## Getting Started
+1. Call list_wallets to see existing wallets, or create_wallet to make a new one.
+2. Fund the wallet by sending tokens to its address from an external source.
+3. Use transfer (native tokens) or transfer_token (ERC-20/SPL tokens) to send funds.
+
+## Supported Chains
+- **EVM chains:** Ethereum (1), Base (8453), Arbitrum (42161), Optimism (10), Polygon (137), Avalanche (43114), BSC (56), Zora (7777777), PulseChain (369)
+- **Solana:** Mainnet (900), Devnet (901)
+- Call get_chains for the full list with native tokens and stablecoin contract addresses.
+
+## EVM vs Solana
+- **Addresses:** EVM uses 0x-prefixed hex (42 chars). Solana uses Base58 (32-44 chars).
+- **Native tokens:** EVM = ETH/POL/BNB/etc (18 decimals, wei). Solana = SOL (9 decimals, lamports).
+- **Token standards:** EVM uses ERC-20. Solana uses SPL tokens.
+- **EVM-only tools:** approve_token, get_allowance, wrap_eth, unwrap_eth, call_contract, get_token_info. These do not work on Solana.
+- **Works on both:** create_wallet, transfer, transfer_token, send_transaction, sign_transaction, get_balance, get_token_balance.
+
+## Common Workflows
+
+### Send native tokens (ETH, SOL, etc.)
+Use the transfer tool with a human-readable amount (e.g. "0.1" ETH). It auto-converts to wei/lamports.
+
+### Send ERC-20 or SPL tokens
+Use transfer_token. You need: wallet_id, token contract address, recipient, amount, chain_id, and decimals (6 for USDC, 18 for most ERC-20s). Call get_chains to find stablecoin addresses.
+
+### Interact with DeFi (EVM only)
+1. Check allowance with get_allowance.
+2. If needed, call approve_token to let the DeFi contract spend your tokens.
+3. Use send_transaction with the contract's calldata to execute the interaction.
+
+### Wrap/unwrap native tokens (EVM only)
+Use wrap_eth to convert ETH → WETH (required by many DeFi protocols). Use unwrap_eth to convert back.
+
+### Read on-chain data (EVM only)
+Use call_contract for gas-free read-only calls (eth_call). Provide ABI-encoded calldata.
+
+## x402 Payments — Paying for Resources
+The pay_x402 tool handles the full x402 payment flow automatically:
+1. Fetches the URL.
+2. If the server returns HTTP 402, parses the payment requirements.
+3. Pays on-chain using your wallet.
+4. Retries the request with proof of payment.
+Always set max_payment to prevent overspending (e.g. "1.00" for max 1 USDC).
+
+## x402 Paywalls — Accepting Payments
+Create paywalls to charge other agents for accessing your resources:
+1. create_paywall — set price, token, chain, and the resource URL to protect.
+2. Share the access URL. Clients that pay on-chain get the resource; others get HTTP 402.
+3. list_paywalls and get_paywall_payments to track revenue.
+4. get_x402_revenue for aggregate stats across all paywalls.
+
+## Wallet Security
+- Use pause_wallet to immediately freeze a wallet if compromised. No transactions can be signed while paused.
+- Use unpause_wallet to resume operations.
+- Use delete_wallet to permanently disable a wallet.
+- Wallets have server-enforced spending limits.
+
+## Tool Selection Guide
+| Goal | Tool |
+|------|------|
+| Send ETH/SOL/native tokens | transfer |
+| Send USDC/ERC-20/SPL tokens | transfer_token |
+| Check native balance | get_balance |
+| Check token balance | get_token_balance |
+| Look up token details | get_token_info (EVM only) |
+| Approve DeFi spending | approve_token (EVM only) |
+| Check approval amount | get_allowance (EVM only) |
+| Read smart contract | call_contract (EVM only) |
+| Custom transaction | send_transaction |
+| Sign without broadcasting | sign_transaction |
+| Pay for x402 resource | pay_x402 |
+| Charge for your resource | create_paywall |
 | Check usage/billing | get_usage |`,
 });
 // ─── Tool: create_wallet ─────────────────────────────────────────
@@ -866,17 +867,6 @@ server.tool('get_allowance', 'Check how many ERC-20 tokens a spender is approved
     });
 });
 // ─── WETH / Wrapped Native Token addresses ──────────────────────
-const WRAPPED_NATIVE = {
-    1: { address: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2', symbol: 'WETH' },
-    8453: { address: '0x4200000000000000000000000000000000000006', symbol: 'WETH' },
-    42161: { address: '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1', symbol: 'WETH' },
-    10: { address: '0x4200000000000000000000000000000000000006', symbol: 'WETH' },
-    137: { address: '0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270', symbol: 'WPOL' },
-    56: { address: '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c', symbol: 'WBNB' },
-    43114: { address: '0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7', symbol: 'WAVAX' },
-    7777777: { address: '0x4200000000000000000000000000000000000006', symbol: 'WETH' },
-    369: { address: '0xA1077a294dDE1B09bB078844df40758a5D0f9a27', symbol: 'WPLS' },
-};
 // ─── Tool: wrap_eth ─────────────────────────────────────────────
 server.tool('wrap_eth', 'Wrap native tokens (ETH, AVAX, BNB, POL, PLS) into their wrapped ERC-20 version (WETH, WAVAX, etc.). ' +
     'Required for most DeFi protocols that use ERC-20 tokens instead of raw native tokens. ' +

package/build/local-wallet.js

@@ -15,9 +15,10 @@
  * on the custodial path and say so explicitly rather than silently downgrading.
  */
 import { readFileSync } from 'node:fs';
-import { createPublicClient, createWalletClient, http, encodeFunctionData, parseAbi, formatUnits, } from 'viem';
+import { createPublicClient, createWalletClient, http, encodeFunctionData, parseAbi, formatUnits, BaseError, ContractFunctionZeroDataError, ContractFunctionRevertedError, ExecutionRevertedError, AbiDecodingDataSizeTooSmallError, AbiDecodingDataSizeInvalidError, } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 import { lookupTrustedDecimals } from './x402-payment.js';
+import { wrappedNativeAddress } from './wrapped-native.js';
 import { typedDataFor } from './x402-eip3009.js';
 import { uptoTypedData } from './x402-permit2.js';
 /* ── Key loading ─────────────────────────────────────────────────── */
@@ -195,8 +196,7 @@ export async function localTokenBalance(chainId, token) {
 const decimalsCache = new Map();
 /**
  * Decimals for `token`: the trusted registry, then the contract's own
- * decimals() (cached on success). Null when the address does not answer like
- * an ERC-20 at all, which is how the guard tells a token from a router.
+ * decimals() (cached on success). See DecimalsProbe for the other outcomes.
  */
 async function probeTokenDecimals(chainId, token) {
     const known = lookupTrustedDecimals(chainId, token);
@@ -206,28 +206,47 @@ async function probeTokenDecimals(chainId, token) {
     const cached = decimalsCache.get(key);
     if (typeof cached === 'number')
         return cached;
+    let onChain;
     try {
         const { pub } = clients(chainId);
-        const onChain = await pub.readContract({
+        onChain = await pub.readContract({
             address: token,
             abi: ERC20_ABI,
             functionName: 'decimals',
         });
-        const d = Number(onChain);
-        // 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) {
-            decimalsCache.set(key, d);
-            return d;
-        }
     }
-    catch {
-        // Unreachable RPC, non-standard token, not a token at all.
+    catch (err) {
+        // viem wraps every readContract failure in ContractFunctionExecutionError;
+        // the cause says whether the contract itself declined (revert, empty
+        // return: not an ERC-20) or the answer never arrived (RPC down, timeout,
+        // malformed response). Only the first is evidence of anything.
+        const declined = err instanceof BaseError && err.walk((e) => e instanceof ContractFunctionZeroDataError
+            || e instanceof ContractFunctionRevertedError
+            || e instanceof ExecutionRevertedError // nodes that report a revert as -32000 rather than 3
+        ) !== null;
+        if (declined)
+            return 'not-a-token';
+        // A decode failure on non-empty data means the contract answered
+        // decimals() with something that is not a uint8: a token, just a broken one.
+        const decodeFailed = err instanceof BaseError && err.walk((e) => e instanceof AbiDecodingDataSizeTooSmallError || e instanceof AbiDecodingDataSizeInvalidError) !== null;
+        return decodeFailed ? 'unusable' : 'unreachable';
     }
-    return null;
+    const d = Number(onChain);
+    // 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) {
+        decimalsCache.set(key, d);
+        return d;
+    }
+    return 'unusable';
 }
+/**
+ * Decimals to price a known transfer or approval at. Anything short of a
+ * usable answer is evaluated at 0, the only value that cannot fail open.
+ */
 async function resolveTokenDecimals(chainId, token) {
-    return (await probeTokenDecimals(chainId, token)) ?? 0;
+    const probe = await probeTokenDecimals(chainId, token);
+    return typeof probe === 'number' ? probe : 0;
 }
 /** Canonical Permit2, the same address on every EVM chain it is deployed to. */
 const PERMIT2 = '0x000000000022d473030f116ddee9f6b43ac78ba3';
@@ -237,6 +256,11 @@ const CAP_LAYOUTS = {
     '095ea7b3': { amountIndex: 1, what: 'approval' }, // approve(address,uint256)
     '39509351': { amountIndex: 1, what: 'allowance increase' }, // increaseAllowance(address,uint256)
     '87517c45': { amountIndex: 2, tokenIndex: 0, what: 'Permit2 approval' }, // Permit2.approve(address,address,uint160,uint48)
+    // WETH9 calls, priced only when `to` is the chain's own wrapped-native
+    // contract (wrappedNativeOnly). deposit() carries its amount as msg.value,
+    // not in calldata, hence amountIndex -1; withdraw(uint256) has it at word 0.
+    d0e30db0: { amountIndex: -1, what: 'wrap of native into the wrapped token', wrappedNativeOnly: true }, // deposit()
+    '2e1a7d4d': { amountIndex: 0, what: 'unwrap of the wrapped token', wrappedNativeOnly: true }, // withdraw(uint256)
 };
 /**
  * The selector table used to be an allowlist that returned early for anything
@@ -247,8 +271,15 @@ const CAP_LAYOUTS = {
  * refused, because any state change there can move funds. Calls to other
  * contracts (routers, bridges) still pass: they can only pull what an approval
  * already allowed, and approvals are what this guard bounds.
+ *
+ * Reported privately 2026-09-27: that refusal also caught our own wrap_eth and
+ * unwrap_eth, whose WETH deposit() / withdraw(uint256) calldata was unpriced,
+ * so both tools died the moment the cap was set and the only way back was
+ * AGENTWALLET_ALLOW_UNKNOWN_TOKEN_CALLS=1, which weakens the guard for every
+ * call. Now both are priced, but only on the chain's own wrapped-native
+ * contract; the same selectors on any other token stay refused.
  */
-async function assertWithinTokenCap(chainId, to, data) {
+async function assertWithinTokenCap(chainId, to, data, valueWei = 0n) {
     const cap = (process.env.AGENTWALLET_MAX_TX_TOKEN || '').trim();
     if (!cap)
         return;
@@ -259,24 +290,40 @@ async function assertWithinTokenCap(chainId, to, data) {
     const selector = hex.slice(0, 8).toLowerCase();
     const isPermit2 = to.toLowerCase() === PERMIT2;
     const layout = CAP_LAYOUTS[selector];
-    const priced = layout && (layout.tokenIndex === undefined || isPermit2);
+    const isWrappedNative = to.toLowerCase() === wrappedNativeAddress(chainId);
+    const priced = layout
+        && (layout.tokenIndex === undefined || isPermit2)
+        && (!layout.wrappedNativeOnly || isWrappedNative);
     if (!priced) {
         if (process.env.AGENTWALLET_ALLOW_UNKNOWN_TOKEN_CALLS === '1')
             return;
-        const looksLikeToken = isPermit2 || (await probeTokenDecimals(chainId, to)) !== null;
-        if (looksLikeToken) {
-            throw new Error(`Blocked by local guard: calldata selector 0x${selector} sent to ` +
-                `${isPermit2 ? 'Permit2' : 'a token contract'} is not one AGENTWALLET_MAX_TX_TOKEN can price, ` +
-                `so it is refused rather than let through uncapped. Use transfer, transferFrom, approve, ` +
-                `increaseAllowance or Permit2 approve, or set AGENTWALLET_ALLOW_UNKNOWN_TOKEN_CALLS=1 to allow it deliberately.`);
+        // Only a contract that demonstrably declines decimals() is let through.
+        // "Answered nonsense" and "could not ask" both refuse: the first is a
+        // token with a broken or hostile decimals(), the second is no evidence at
+        // all, and this guard does not allow on no evidence (2026-09-26 report).
+        const probe = isPermit2 ? 'unusable' : await probeTokenDecimals(chainId, to);
+        if (probe !== 'not-a-token') {
+            const why = probe === 'unreachable'
+                ? `the RPC for chain ${chainId} could not be reached to classify the target, so the guard cannot tell a token from a router`
+                : `the target is ${isPermit2 ? 'Permit2' : 'a token contract'} and this calldata is not one AGENTWALLET_MAX_TX_TOKEN can price`;
+            throw new Error(`Blocked by local guard: calldata selector 0x${selector} refused rather than let through uncapped: ${why}. ` +
+                `Use transfer, transferFrom, approve, increaseAllowance, Permit2 approve, ` +
+                `or deposit/withdraw on the chain's wrapped-native contract, ` +
+                `or set AGENTWALLET_ALLOW_UNKNOWN_TOKEN_CALLS=1 to allow it deliberately.`);
         }
         return; // an ordinary contract call; it can only pull what an approval already allowed
     }
     const wordAt = (i) => hex.slice(8 + i * 64, 8 + (i + 1) * 64);
-    const word = wordAt(layout.amountIndex);
-    if (word.length !== 64)
-        return; // malformed; leave it to the node to reject
-    const amount = BigInt('0x' + word);
+    let amount;
+    if (layout.amountIndex < 0) {
+        amount = valueWei; // deposit(): what gets wrapped is the native value sent along
+    }
+    else {
+        const word = wordAt(layout.amountIndex);
+        if (word.length !== 64)
+            return; // malformed; leave it to the node to reject
+        amount = BigInt('0x' + word);
+    }
     let token = to;
     if (layout.tokenIndex !== undefined) {
         const tw = wordAt(layout.tokenIndex);
@@ -284,7 +331,9 @@ async function assertWithinTokenCap(chainId, to, data) {
             return;
         token = ('0x' + tw.slice(24));
     }
-    const decimals = await resolveTokenDecimals(chainId, token);
+    // Every wrapped native in the table is a WETH9 clone with 18 decimals, the
+    // same figure wrap_eth and unwrap_eth encode with; no RPC needed to price it.
+    const decimals = layout.wrappedNativeOnly ? 18 : await resolveTokenDecimals(chainId, token);
     const [whole, frac = ''] = cap.split('.');
     const capRaw = BigInt(whole + frac.padEnd(decimals, '0').slice(0, decimals));
     if (amount > capRaw) {
@@ -296,7 +345,7 @@ async function assertWithinTokenCap(chainId, to, data) {
 export async function localSend(chainId, to, valueWei, data) {
     assertWithinNativeCap(valueWei);
     if (data && data.length >= 10)
-        await assertWithinTokenCap(chainId, to, data);
+        await assertWithinTokenCap(chainId, to, data, valueWei);
     const { wallet } = clients(chainId);
     const hash = await wallet.sendTransaction({
         to,

package/build/wrapped-native.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Wrapped-native (WETH9-style) token per EVM chain. Shared by the wrap_eth and
+ * unwrap_eth tools and by the local token cap, which prices deposit() and
+ * withdraw(uint256) only when they are aimed at this exact contract.
+ */
+export declare const WRAPPED_NATIVE: Record<number, {
+    address: string;
+    symbol: string;
+}>;
+/** Lowercased wrapped-native address for `chainId`, or undefined when none is configured. */
+export declare function wrappedNativeAddress(chainId: number): string | undefined;

package/build/wrapped-native.js

@@ -0,0 +1,20 @@
+/**
+ * Wrapped-native (WETH9-style) token per EVM chain. Shared by the wrap_eth and
+ * unwrap_eth tools and by the local token cap, which prices deposit() and
+ * withdraw(uint256) only when they are aimed at this exact contract.
+ */
+export const WRAPPED_NATIVE = {
+    1: { address: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2', symbol: 'WETH' },
+    8453: { address: '0x4200000000000000000000000000000000000006', symbol: 'WETH' },
+    42161: { address: '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1', symbol: 'WETH' },
+    10: { address: '0x4200000000000000000000000000000000000006', symbol: 'WETH' },
+    137: { address: '0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270', symbol: 'WPOL' },
+    56: { address: '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c', symbol: 'WBNB' },
+    43114: { address: '0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7', symbol: 'WAVAX' },
+    7777777: { address: '0x4200000000000000000000000000000000000006', symbol: 'WETH' },
+    369: { address: '0xA1077a294dDE1B09bB078844df40758a5D0f9a27', symbol: 'WPLS' },
+};
+/** Lowercased wrapped-native address for `chainId`, or undefined when none is configured. */
+export function wrappedNativeAddress(chainId) {
+    return WRAPPED_NATIVE[chainId]?.address.toLowerCase();
+}

package/package.json

@@ -1,69 +1,69 @@
-{
-  "name": "agentwallet-mcp",
-  "mcpName": "io.github.hifriendbot/agentwallet",
-  "version": "1.12.4",
-  "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",
-  "bin": {
-    "agentwallet-mcp": "build/index.js"
-  },
-  "files": [
-    "build",
-    "README.md",
-    "LICENSE"
-  ],
-  "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/local-mode.test.mjs && node test/ssrf-guard.test.mjs",
-    "prepublishOnly": "npm run build"
-  },
-  "keywords": [
-    "mcp",
-    "model-context-protocol",
-    "wallet",
-    "ai-agent",
-    "blockchain",
-    "evm",
-    "ethereum",
-    "base",
-    "arbitrum",
-    "optimism",
-    "polygon",
-    "avalanche",
-    "bsc",
-    "zora",
-    "pulsechain",
-    "solana",
-    "spl-token",
-    "erc20",
-    "token-transfer",
-    "transaction-signing",
-    "x402",
-    "http-402",
-    "agent-payments",
-    "agentwallet",
-    "self-custody",
-    "non-custodial",
-    "local-signing"
-  ],
-  "author": "HiFriendbot (https://hifriendbot.com)",
-  "license": "MIT",
-  "homepage": "https://hifriendbot.com/wallet/",
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.11.4",
-    "@solana/web3.js": "^1.98.4",
-    "bs58": "^6.0.0",
-    "undici": "^8.9.0",
-    "viem": "^2.55.10",
-    "zod": "^3.24.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "typescript": "^5.3.0"
-  }
-}
+{
+  "name": "agentwallet-mcp",
+  "mcpName": "io.github.hifriendbot/agentwallet",
+  "version": "1.12.6",
+  "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",
+  "bin": {
+    "agentwallet-mcp": "build/index.js"
+  },
+  "files": [
+    "build",
+    "README.md",
+    "LICENSE"
+  ],
+  "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",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "wallet",
+    "ai-agent",
+    "blockchain",
+    "evm",
+    "ethereum",
+    "base",
+    "arbitrum",
+    "optimism",
+    "polygon",
+    "avalanche",
+    "bsc",
+    "zora",
+    "pulsechain",
+    "solana",
+    "spl-token",
+    "erc20",
+    "token-transfer",
+    "transaction-signing",
+    "x402",
+    "http-402",
+    "agent-payments",
+    "agentwallet",
+    "self-custody",
+    "non-custodial",
+    "local-signing"
+  ],
+  "author": "HiFriendbot (https://hifriendbot.com)",
+  "license": "MIT",
+  "homepage": "https://hifriendbot.com/wallet/",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.11.4",
+    "@solana/web3.js": "^1.98.4",
+    "bs58": "^6.0.0",
+    "undici": "^8.9.0",
+    "viem": "^2.55.10",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.3.0"
+  }
+}