agentwallet-mcp 1.12.3 → 1.12.4

package/README.md

@@ -259,6 +259,8 @@ pay_x402(
 
 **Token domains.** The EIP-712 domain comes from the endpoint's `extra.name` / `extra.version`, then a short registry of USDC deployments, then the token contract's own `name()` / `version()`. If none of those answer, the payment is refused rather than signed with a guessed domain.
 
+**Delegated payers.** If the paying address is an EIP-7702 delegated account, `pay_x402` reports it in `payer_delegation` (the delegate and whether it answers ERC-1271). A delegate without ERC-1271 is declined by facilitators that check account code before recovering the signer, and the reason they return reads like a signature fault; the warning names the real cause. Pay from a plain EOA for reliable settlement.
+
 ## x402 Acceptance
 
 AgentWallet also lets you **accept** x402 payments. Create a paywall, point it at any resource, and get a public URL that charges agents automatically:

package/build/index.js

@@ -15,10 +15,10 @@ import { z } from 'zod';
 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, localSignPermit2Upto } from './local-wallet.js';
+import { localSignAuthorization, localEthCall, localGetCode, localSignPermit2Upto } from './local-wallet.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, } from './x402-eip3009.js';
+import { isLegacyAgentWalletAccept, requiredAmount, buildAuthorization, buildPaymentPayload, buildPaymentPayloadRaw, paymentHeaderFor, parsePaymentRequired, parseSettlement, pickOption, knownTokenDomain, parseEip7702Delegation, erc1271ProbeCalldata, classifyErc1271Probe, } from './x402-eip3009.js';
 import { isSolanaLocalMode, getSolanaAddress, solanaWalletRecord, localSolBalance, localSplBalance, localSolTransfer, localSplTransfer, resolveSolanaRpc, } from './local-solana.js';
 /** True when either chain family is running non-custodially. */
 function anyLocalMode() {
@@ -128,6 +128,12 @@ async function routeLocally(path, method, body) {
             return NOT_HANDLED;
         return localEthCall(localChainId(body, qs), String(body?.to || ''), String(body?.data || '0x'));
     }
+    // POST /eth-get-code  (read-only; the payer's account code, checked for an EIP-7702 delegation before an x402 authorization)
+    if (method === 'POST' && rawPath === '/eth-get-code') {
+        if (!isLocalMode())
+            return NOT_HANDLED;
+        return localGetCode(localChainId(body, qs), String(body?.address || ''));
+    }
     // GET /wallets/{id}/balance
     if (method === 'GET' && /^\/wallets\/[^/]*\/balance$/.test(rawPath)) {
         const chainId = localChainId(body, qs);
@@ -461,7 +467,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.12.3',
+    version: '1.12.4',
 }, {
     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.
 
@@ -994,6 +1000,39 @@ async function payerAddress(walletId) {
         throw new Error(`x402: could not resolve the EVM address of wallet ${walletId} (got "${a}").`);
     return a;
 }
+/**
+ * Best-effort look at the payer's account code. An EIP-7702 delegated EOA whose delegate
+ * does not implement ERC-1271 is declined by facilitators that check code before recovering
+ * the signer, with an error that reads like a signature fault (issue #9). Nothing is refused
+ * here: the authorization costs nothing to sign and other facilitators accept it. The result
+ * carries the warning so the agent can explain a signature-shaped rejection. A lookup failure
+ * (a hosted server without the route, RPC trouble) reports nothing rather than blocking the payment.
+ */
+async function payerDelegation(chainId, payer) {
+    try {
+        const r = (await api('/eth-get-code', 'POST', { chain_id: chainId, address: payer }, { 'X-AGW-SKIP-X402': 'true' }));
+        const delegate = parseEip7702Delegation(r?.code);
+        if (!delegate)
+            return null;
+        let erc1271 = 'unknown';
+        try {
+            const probe = (await api('/eth-call', 'POST', { chain_id: chainId, to: payer, data: erc1271ProbeCalldata() }, { 'X-AGW-SKIP-X402': 'true' }));
+            erc1271 = classifyErc1271Probe(probe?.result);
+        }
+        catch {
+            erc1271 = 'unknown';
+        }
+        const warning = erc1271 === 'no'
+            ? `Payer ${payer} is an EIP-7702 delegated account (delegate ${delegate}) and the delegate does not answer ERC-1271 isValidSignature. ` +
+                `Facilitators that check account code before recovering the signer decline this authorization with a signature error. ` +
+                `Pay from a plain EOA, or clear the delegation, for reliable x402 settlement.`
+            : `Payer ${payer} is an EIP-7702 delegated account (delegate ${delegate}); a facilitator may verify the authorization through ERC-1271 on the delegate.`;
+        return { delegate, erc1271, warning };
+    }
+    catch {
+        return null;
+    }
+}
 async function ethCallHex(chainId, to, data) {
     const r = (await api('/eth-call', 'POST', { chain_id: chainId, to, data }, { 'X-AGW-SKIP-X402': 'true' }));
     return String(r?.result || '');
@@ -1225,8 +1264,10 @@ server.tool('pay_x402', 'Handle an x402 payment flow. Fetches a URL, and if the
     let uptoAuth = null;
     let payer = null;
     let permit2ApprovalTx = null;
+    let payerDelegationInfo = null;
     if (isUpto) {
         payer = await payerAddress(wallet_id);
+        payerDelegationInfo = await payerDelegation(chainId, payer);
         const allowance = decodeUint(await ethCallHex(chainId, tokenAddress, permit2AllowanceCalldata(payer)));
         if (allowance < BigInt(rawAmount)) {
             if (process.env.AGENTWALLET_PERMIT2_AUTO_APPROVE === '1') {
@@ -1253,6 +1294,7 @@ server.tool('pay_x402', 'Handle an x402 payment flow. Fetches a URL, and if the
     }
     else if (standardExact) {
         payer = await payerAddress(wallet_id);
+        payerDelegationInfo = await payerDelegation(chainId, payer);
         const domain = await resolveTokenDomain(chainId, tokenAddress, option.extra);
         authorization = buildAuthorization(payer, option);
         const signature = await signAuthorization(wallet_id, chainId, tokenAddress, domain, authorization, approvalUsed);
@@ -1306,6 +1348,8 @@ server.tool('pay_x402', 'Handle an x402 payment flow. Fetches a URL, and if the
     if (retryRes.status === 402) {
         const again = parsePaymentRequired(n => retryRes.headers.get(n), retryParsed);
         retryError = String(again?.error || retryParsed?.error || 'Payment was not accepted (no reason given).');
+        if (payerDelegationInfo && /signature/i.test(retryError))
+            retryError += ` Likely cause: ${payerDelegationInfo.warning}`;
     }
     return jsonResponse({
         status: retryRes.status,
@@ -1326,6 +1370,7 @@ server.tool('pay_x402', 'Handle an x402 payment flow. Fetches a URL, and if the
         chain_id: chainId,
         pay_to: option.payTo,
         payer,
+        payer_delegation: payerDelegationInfo,
         tx_hash: txHash ?? settlement?.transaction ?? null,
         settlement,
         authorization: authorization ? { nonce: authorization.nonce, valid_before: authorization.validBefore }

package/build/local-wallet.d.ts

@@ -108,6 +108,10 @@ export declare function localSignAuthorization(chainId: number, asset: Address,
 export declare function localEthCall(chainId: number, to: Address, data: Hex): Promise<{
     result: string;
 }>;
+/** Read-only eth_getCode against the local RPC, same shape as the hosted /eth-get-code route. */
+export declare function localGetCode(chainId: number, address: Address): Promise<{
+    code: string;
+}>;
 /** x402 "upto": sign a Permit2 max-authorization in-process. The maximum goes through the token cap like a transfer would. */
 export declare function localSignPermit2Upto(chainId: number, auth: UptoPermit2Authorization): Promise<{
     signature: `0x${string}`;

package/build/local-wallet.js

@@ -380,6 +380,12 @@ export async function localEthCall(chainId, to, data) {
     const r = await client.call({ to, data });
     return { result: r.data ?? '0x' };
 }
+/** Read-only eth_getCode against the local RPC, same shape as the hosted /eth-get-code route. */
+export async function localGetCode(chainId, address) {
+    const client = createPublicClient({ transport: http(resolveRpcUrl(chainId)) });
+    const code = await client.getCode({ address });
+    return { code: code ?? '0x' };
+}
 /** x402 "upto": sign a Permit2 max-authorization in-process. The maximum goes through the token cap like a transfer would. */
 export async function localSignPermit2Upto(chainId, auth) {
     const token = auth.permitted.token;

package/build/x402-eip3009.d.ts

@@ -169,3 +169,22 @@ export declare function pickOption(accepts: X402Requirement[], resolveChainId: (
     chainId: number | null;
     reason?: string;
 };
+/**
+ * An EIP-7702 delegated EOA has code 0xef0100 || delegate (23 bytes). A facilitator that
+ * checks account code before recovering the signer treats such a payer as a contract
+ * wallet and calls ERC-1271 isValidSignature on it; a delegate that does not implement
+ * it answers with empty data, and the payment is declined with a signature-shaped error
+ * that has nothing to do with the signature (issue #9: a well-known test key that
+ * sweeper bots had delegated on Base mainnet).
+ */
+export declare function parseEip7702Delegation(code: string | null | undefined): string | null;
+export declare const ERC1271_MAGIC = "0x1626ba7e";
+/** Calldata for isValidSignature(bytes32, bytes) with a placeholder hash and a 65-byte placeholder signature. */
+export declare function erc1271ProbeCalldata(): `0x${string}`;
+export type Erc1271Support = 'yes' | 'no' | 'unknown';
+/**
+ * Classify an isValidSignature probe. Empty return data means the account has no such
+ * function (the failure shape from issue #9); a 4-byte word means the interface exists,
+ * whatever it thought of the placeholder signature; a revert or transport failure is unknown.
+ */
+export declare function classifyErc1271Probe(result: string | null | undefined, failed?: boolean): Erc1271Support;

package/build/x402-eip3009.js

@@ -205,3 +205,40 @@ export function pickOption(accepts, resolveChainId, preferChain) {
         option = payable.find(a => resolveChainId(a.network) === preferChain) ?? option;
     return { option, chainId: resolveChainId(option.network) };
 }
+// ─── Payer account shape (EIP-7702) ──────────────────────────────
+/**
+ * An EIP-7702 delegated EOA has code 0xef0100 || delegate (23 bytes). A facilitator that
+ * checks account code before recovering the signer treats such a payer as a contract
+ * wallet and calls ERC-1271 isValidSignature on it; a delegate that does not implement
+ * it answers with empty data, and the payment is declined with a signature-shaped error
+ * that has nothing to do with the signature (issue #9: a well-known test key that
+ * sweeper bots had delegated on Base mainnet).
+ */
+export function parseEip7702Delegation(code) {
+    const m = /^0xef0100([0-9a-f]{40})$/.exec(String(code || '').toLowerCase());
+    return m ? `0x${m[1]}` : null;
+}
+export const ERC1271_MAGIC = '0x1626ba7e';
+/** Calldata for isValidSignature(bytes32, bytes) with a placeholder hash and a 65-byte placeholder signature. */
+export function erc1271ProbeCalldata() {
+    const hash = '11'.repeat(32);
+    const offset = (64).toString(16).padStart(64, '0');
+    const length = (65).toString(16).padStart(64, '0');
+    const sig = 'aa'.repeat(65).padEnd(192, '0');
+    return `${ERC1271_MAGIC}${hash}${offset}${length}${sig}`;
+}
+/**
+ * Classify an isValidSignature probe. Empty return data means the account has no such
+ * function (the failure shape from issue #9); a 4-byte word means the interface exists,
+ * whatever it thought of the placeholder signature; a revert or transport failure is unknown.
+ */
+export function classifyErc1271Probe(result, failed = false) {
+    if (failed)
+        return 'unknown';
+    const r = String(result || '').toLowerCase();
+    if (r === '' || r === '0x')
+        return 'no';
+    if (/^0x[0-9a-f]{8}0{56}$/.test(r))
+        return 'yes';
+    return 'unknown';
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "agentwallet-mcp",
   "mcpName": "io.github.hifriendbot/agentwallet",
-  "version": "1.12.3",
+  "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",