@jaw.id/cli 0.1.25 → 0.2.0

package/dist/mcp/handlers/rpc.js

@@ -4,6 +4,7 @@ import * as crypto from 'crypto';
 import * as path from 'path';
 import * as os from 'os';
 import WebSocket from 'ws';
+import { encodeFunctionData, maxUint256, erc20Abi } from 'viem';
 
 // src/mcp/tools.ts
 var rpcMethodSchema = {
@@ -13,15 +14,69 @@ var rpcMethodSchema = {
   params: z.any().optional().describe(
     "Method parameters \u2014 structure varies by method. Read the jaw://api-reference/{method} resource for the expected format."
   ),
-  chainId: z.number().optional().describe("Target chain ID (overrides default). E.g., 1 for Ethereum, 8453 for Base, 84532 for Base Sepolia"),
+  chainId: z.number().int().positive().optional().describe("Target chain ID (overrides default). E.g., 1 for Ethereum, 8453 for Base, 84532 for Base Sepolia"),
   session: z.boolean().optional().describe(
-    "Sign with the local session key instead of opening the browser (requires `jaw session setup`; check jaw_session_status first). Supported methods only: eth_requestAccounts, eth_accounts, wallet_sendCalls, wallet_getCallsStatus, personal_sign, eth_signTypedData_v4. Defaults to the JAW_SESSION env var."
+    "Sign with the local session key instead of opening the browser (requires `jaw session setup`; check jaw_session_status first). Supported methods only: eth_requestAccounts, eth_accounts, wallet_sendCalls, wallet_getCallsStatus. personal_sign and eth_signTypedData_v4 are browser only: a signature made by the session key never passes the spend caps or the ledger. Defaults to the JAW_SESSION env var."
   )
 };
 ({
   key: z.enum(["apiKey", "defaultChain", "keysUrl", "ens", "relayUrl", "sessionExpiry"]).describe("Config key"),
   value: z.string().describe("Config value")
 });
+var httpUrl = z.string().url().refine(
+  (u) => {
+    try {
+      const p = new URL(u).protocol;
+      return p === "http:" || p === "https:";
+    } catch {
+      return false;
+    }
+  },
+  { message: "url must be http(s) \u2014 other schemes (file:, data:, javascript:, ftp:) are not fetched" }
+);
+({
+  url: httpUrl.describe("Resource URL to fetch (http/https only). If it answers HTTP 402 (x402), pay and retry."),
+  method: z.string().optional().describe("HTTP method (default GET)."),
+  headers: z.record(z.string()).optional().describe("Extra request headers."),
+  body: z.string().optional().describe("Request body (for POST/PUT/etc.)."),
+  maxAmount: z.string().optional().describe(
+    "Hard ceiling for THIS call, in the asset base units (e.g. 6-decimals for USDC). If the 402 asks for more, the payment is refused, not made."
+  ),
+  asset: z.string().optional().describe("Require a specific asset contract address."),
+  network: z.string().optional().describe("Require a specific CAIP-2 network, e.g. eip155:8453 (Base).")
+});
+({
+  query: z.string().max(400).optional().describe(
+    'Keyword or natural-language search over the x402 Bazaar catalog of paid services (e.g. "ens resolver", "weather api", "token price"). Required unless `payTo` is set.'
+  ),
+  network: z.string().optional().describe("CAIP-2 network to prefer when picking the price to show, e.g. eip155:8453 (Base, default)."),
+  maxUsdPrice: z.string().optional().describe("Only return services priced at or below this many USD per call."),
+  curatedOnly: z.boolean().optional().describe("Only return Coinbase-curated (health-probed) services."),
+  limit: z.number().int().min(1).max(20).optional().describe("Maximum results to return (1-20, default 10)."),
+  payTo: z.string().optional().describe(
+    "Instead of searching, list every service registered by this seller address (0x\u2026). Takes precedence over `query` if both are given."
+  )
+});
+({
+  limit: z.number().optional().describe("Return only the most recent N ledger entries (default: all).")
+});
+({
+  network: z.string().optional().describe("CAIP-2 network to check the USDC balance on, e.g. eip155:8453 (Base) or eip155:84532 (Base Sepolia).")
+});
+
+// src/lib/errors.ts
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/lib/terminal.ts
+var INVISIBLE_AND_BIDI = /[\u200B-\u200F\u2028\u2029\u202A-\u202E\u2066-\u2069\uFEFF]/g;
+var BLOCK_CONTROLS = /[\u0000-\u0008\u000B-\u001F\u007F-\u009F]/g;
+var REPLACEMENT = "\uFFFD";
+function sanitizeBlock(value) {
+  const text = typeof value === "string" ? value : String(value);
+  return text.replace(BLOCK_CONTROLS, REPLACEMENT).replace(INVISIBLE_AND_BIDI, REPLACEMENT);
+}
 
 // src/mcp/helpers.ts
 function mcpError(err) {
@@ -30,17 +85,20 @@ function mcpError(err) {
     content: [
       {
         type: "text",
-        text: `Error: ${err instanceof Error ? err.message : String(err)}`
+        text: `Error: ${sanitizeBlock(errorMessage(err))}`
       }
     ]
   };
 }
+function encode(value) {
+  return sanitizeBlock(JSON.stringify(value));
+}
 function mcpResult(data) {
   return {
     content: [
       {
         type: "text",
-        text: JSON.stringify(data)
+        text: encode(data)
       }
     ]
   };
@@ -52,7 +110,9 @@ var PATHS = {
   session: path.join(JAW_DIR, "session.json"),
   relay: path.join(JAW_DIR, "relay.json"),
   keystore: path.join(JAW_DIR, "keystore.json"),
-  sessionConfig: path.join(JAW_DIR, "session-config.json")
+  sessionConfig: path.join(JAW_DIR, "session-config.json"),
+  x402Log: path.join(JAW_DIR, "x402-log.jsonl"),
+  paymentLock: path.join(JAW_DIR, "x402-payment.lock")
 };
 
 // src/lib/validation.ts
@@ -174,7 +234,18 @@ function bufferToBase64(buf) {
 }
 
 // src/lib/ws-bridge.ts
+function buildInitPayload(config) {
+  return {
+    type: "init",
+    apiKey: config.apiKey,
+    chainId: config.chainId,
+    ens: config.ens,
+    paymasterUrl: config.paymasterUrl,
+    ...config.paymasterUrl && config.paymasterContext ? { paymasterContext: config.paymasterContext } : {}
+  };
+}
 var DEFAULT_TIMEOUT_MS = 12e4;
+var DEFAULT_CONNECT_TIMEOUT_MS = 3e4;
 var MAX_MESSAGE_BYTES = 5 * 1024 * 1024;
 var BROWSER_REOPEN_COOLDOWN_MS = 5e3;
 var MAX_RECONNECT_ATTEMPTS = 3;
@@ -183,6 +254,7 @@ var WSBridge = class {
   relayUrl;
   session;
   timeout;
+  connectTimeout;
   config;
   privateKeyHex;
   publicKeyHex;
@@ -204,6 +276,7 @@ var WSBridge = class {
     this.relayUrl = options.relayUrl;
     this.session = options.session;
     this.timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
+    this.connectTimeout = options.connectTimeout ?? DEFAULT_CONNECT_TIMEOUT_MS;
     this.config = options.config;
     this.privateKeyHex = options.privateKeyHex;
     this.publicKeyHex = options.publicKeyHex;
@@ -232,17 +305,16 @@ var WSBridge = class {
       let expectingKeyExchange = !this.peerPublicKeyHex;
       const timer = setTimeout(() => {
         ws.close();
-        reject(new Error("Browser did not connect in time.\nRun `jaw disconnect` then try again."));
-      }, 3e4);
+        reject(
+          new Error(
+            `Browser did not connect within ${Math.round(this.connectTimeout / 1e3)}s.
+Run \`jaw disconnect\` then try again, or raise JAW_BRIDGE_TIMEOUT_MS.`
+          )
+        );
+      }, this.connectTimeout);
       const sendEncryptedInit = async () => {
         if (!this.sharedSecret) return;
-        const envelope = await encryptMessage(this.sharedSecret, {
-          type: "init",
-          apiKey: this.config.apiKey,
-          chainId: this.config.chainId,
-          ens: this.config.ens,
-          paymasterUrl: this.config.paymasterUrl
-        });
+        const envelope = await encryptMessage(this.sharedSecret, buildInitPayload(this.config));
         this.sendRaw(ws, JSON.stringify({ type: "encrypted", ...envelope }));
       };
       const waitForReady = () => {
@@ -520,6 +592,10 @@ var DEFAULT_KEYS_URL = "https://keys.jaw.id";
 var DEFAULT_RELAY_URL = "wss://relay.jaw.id";
 async function getBridge(options) {
   const config = loadConfig();
+  const envTimeout = Number(process.env["JAW_BRIDGE_TIMEOUT_MS"]);
+  const fromEnv = Number.isFinite(envTimeout) && envTimeout > 0 ? envTimeout : void 0;
+  const timeout = options.timeout ?? fromEnv;
+  const connectTimeout = options.connectTimeout ?? fromEnv;
   const keysUrl = options.keysUrl ?? config.keysUrl ?? DEFAULT_KEYS_URL;
   const relayUrl = options.relayUrl ?? config.relayUrl ?? DEFAULT_RELAY_URL;
   const chainId = options.chainId ?? config.defaultChain ?? 1;
@@ -532,7 +608,7 @@ async function getBridge(options) {
   let relaySession = loadRelaySession();
   if (relaySession && relaySession.relayUrl === relayUrl && relaySession.peerPublicKey) {
     try {
-      return await connectBridge(relaySession, options, chainId, keysUrl, relayUrl, false);
+      return await connectBridge({ ...options, timeout }, relaySession, chainId, keysUrl, relayUrl, false);
     } catch {
       deleteRelaySession();
       relaySession = null;
@@ -542,7 +618,7 @@ async function getBridge(options) {
   }
   const session = await createNewSession(relayUrl);
   saveRelaySession(session);
-  return await connectBridge(session, options, chainId, keysUrl, relayUrl, true);
+  return await connectBridge({ ...options, timeout, connectTimeout }, session, chainId, keysUrl, relayUrl, true);
 }
 async function createNewSession(relayUrl) {
   const kp = await generateKeyPair();
@@ -557,17 +633,20 @@ async function createNewSession(relayUrl) {
     startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-async function connectBridge(relaySession, options, chainId, keysUrl, relayUrl, openBrowser) {
+async function connectBridge(options, relaySession, chainId, keysUrl, relayUrl, openBrowser) {
   const config = loadConfig();
+  const paymaster = config.paymasters?.[chainId];
   const bridge = new WSBridge({
     relayUrl,
     session: relaySession.session,
     timeout: options.timeout,
+    connectTimeout: options.connectTimeout,
     config: {
       apiKey: options.apiKey,
       chainId,
       ens: options.ens ?? config.ens,
-      paymasterUrl: options.paymasterUrl ?? config.paymasters?.[chainId]?.url
+      paymasterUrl: paymaster?.url,
+      paymasterContext: paymaster?.context
     },
     privateKeyHex: relaySession.privateKey,
     publicKeyHex: relaySession.publicKey,
@@ -577,6 +656,12 @@ async function connectBridge(relaySession, options, chainId, keysUrl, relayUrl,
     // onBrowserNeeded — only open a browser for new sessions
     openBrowser ? async () => {
       const bridgeUrl = buildBridgeUrl(keysUrl, relaySession.session, relayUrl, relaySession.publicKey);
+      if (process.env["JAW_NO_BROWSER"]) {
+        process.stderr.write(`Open this URL to approve:
+${bridgeUrl}
+`);
+        return;
+      }
       const { default: open } = await import('open');
       await open(bridgeUrl);
     } : void 0,
@@ -608,6 +693,9 @@ function loadSessionKey() {
   }
   return parsed.privateKey;
 }
+function isLegacySession(config) {
+  return config.mode !== "eip7702";
+}
 function loadSessionConfig() {
   if (!fs.existsSync(PATHS.sessionConfig)) {
     throw new Error("No session configured. Run `jaw session setup` first.");
@@ -619,21 +707,94 @@ function loadSessionConfig() {
     throw new Error(`Session config at ${PATHS.sessionConfig} is corrupted. Run \`jaw session setup\` to recreate it.`);
   }
 }
+function tryLoadSessionConfig() {
+  try {
+    return loadSessionConfig();
+  } catch {
+    return null;
+  }
+}
+
+// src/x402/asset-registry.ts
+var USDC_BY_NETWORK = {
+  "eip155:8453": {
+    address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    chainId: 8453,
+    wireNetwork: "eip155:8453",
+    usdcName: "USD Coin",
+    usdcVersion: "2",
+    decimals: 6
+  },
+  "eip155:84532": {
+    address: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+    chainId: 84532,
+    wireNetwork: "eip155:84532",
+    usdcName: "USDC",
+    usdcVersion: "2",
+    decimals: 6
+  },
+  "eip155:137": {
+    address: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+    chainId: 137,
+    wireNetwork: "eip155:137",
+    usdcName: "USD Coin",
+    usdcVersion: "2",
+    decimals: 6
+  },
+  "eip155:80002": {
+    address: "0x41E94Eb019C0762f9Bfcf9Fb1E58725BfB0e7582",
+    chainId: 80002,
+    wireNetwork: "eip155:80002",
+    usdcName: "USDC",
+    usdcVersion: "2",
+    decimals: 6
+  }
+};
+function usdcForNetwork(network) {
+  return Object.hasOwn(USDC_BY_NETWORK, network) ? USDC_BY_NETWORK[network] : void 0;
+}
+
+// src/x402/permit2.ts
+var PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
 
 // src/lib/session-bridge.ts
+var JAW_ERC20_PAYMASTER_URL = "https://api.justaname.id/proxy/v1/rpc/erc20-paymaster";
+function resolvePaymaster(options) {
+  if (options.paymasterUrl) {
+    return { paymasterUrl: options.paymasterUrl, paymasterContext: options.paymasterContext };
+  }
+  const configured = loadConfig().paymasters?.[options.chainId];
+  if (configured) {
+    return { paymasterUrl: configured.url, paymasterContext: configured.context };
+  }
+  if (!options.apiKey) return {};
+  const asset = usdcForNetwork(`eip155:${options.chainId}`);
+  if (!asset) {
+    console.warn(
+      `[jaw] No USDC in the x402 asset registry for chain ${options.chainId}, so no ERC-20 paymaster can be engaged. Gas will come out of the account\u2019s native balance. Set \`paymasters\` in your config to sponsor this chain.`
+    );
+    return {};
+  }
+  const url = new URL(JAW_ERC20_PAYMASTER_URL);
+  url.searchParams.set("chainId", String(options.chainId));
+  url.searchParams.set("api-key", options.apiKey);
+  return { paymasterUrl: url.toString(), paymasterContext: { token: asset.address } };
+}
+function explainUnchargeableSender(err, sessionAddress) {
+  const message = err instanceof Error ? err.message : String(err);
+  if (!message.includes("Could not size the ERC-20 paymaster approval")) return err;
+  return new Error(
+    `${message}
+
+If ${sessionAddress} holds no USDC, that is why: it pays for its own gas and cannot be charged with an empty balance. Send it 0.1 USDC, or run \`jaw session setup\` again.`,
+    { cause: err }
+  );
+}
 var SessionBridge = class {
   options;
   session = null;
   constructor(options) {
-    this.options = { ...options };
-    if (!this.options.paymasterUrl) {
-      const config = loadConfig();
-      const pm = config.paymasters?.[this.options.chainId];
-      if (pm) {
-        this.options.paymasterUrl = pm.url;
-        this.options.paymasterContext = pm.context;
-      }
-    }
+    this.options = { ...options, ...resolvePaymaster(options) };
   }
   async getSession() {
     if (this.session) {
@@ -642,6 +803,11 @@ var SessionBridge = class {
     }
     const config = loadSessionConfig();
     this.checkExpiry(config);
+    if (isLegacySession(config)) {
+      throw new Error(
+        "This session was created by an older CLI and uses a session address separate from the session key. Run `jaw session setup` to recreate it, which offers to revoke the old permission first. `jaw session status` still shows the old session, and `jaw session revoke` still revokes it."
+      );
+    }
     if (config.chainId !== this.options.chainId) {
       throw new Error(
         `Session was created for chain ${config.chainId}, but --chain ${this.options.chainId} was requested. Run \`jaw session setup --chain ${this.options.chainId}\` to create a session for that chain.`
@@ -659,8 +825,14 @@ var SessionBridge = class {
         paymasterUrl: this.options.paymasterUrl,
         paymasterContext: this.options.paymasterContext
       },
-      localAccount
+      localAccount,
+      { eip7702: true }
     );
+    if (account.address.toLowerCase() !== config.sessionAddress.toLowerCase()) {
+      throw new Error(
+        `Session key derives ${account.address}, but the stored session address is ${config.sessionAddress}. The keystore and session config are out of sync. Run \`jaw session setup\` to recreate the session.`
+      );
+    }
     this.session = { account, config };
     return this.session;
   }
@@ -670,6 +842,46 @@ var SessionBridge = class {
       throw new Error(`Session expired on ${expiryDate}. Run \`jaw session setup\` to create a new session.`);
     }
   }
+  /**
+   * Approve Permit2 to move one of the payer's tokens, and return the batch id.
+   *
+   * The only call this session sends outside its permission, and the only one
+   * that can be: `JustaPermissionManager` checks every call's selector against
+   * the grant, and the x402 grant permits `transfer` alone, so an approval
+   * routed through the permission reverts before anything else happens. Sent by
+   * the session on its own balance it never reaches the manager at all, whose
+   * approval revocation and Permit2 lockdown act on the granting account and
+   * only within their own execution.
+   *
+   * Being outside the permission is exactly why it is not a general send. It
+   * takes a token and nothing else: the spender is Permit2 and the amount is
+   * the maximum, neither reachable by a caller, and the token has to be the
+   * registry's USDC for this session's chain. There is no shape of argument
+   * that turns this into an arbitrary transfer, which matters because an agent
+   * reaches the tools that reach this.
+   */
+  async approvePermit2(token) {
+    const { account, config } = await this.getSession();
+    const usdc = usdcForNetwork(`eip155:${config.chainId}`);
+    if (!usdc || token.toLowerCase() !== usdc.address.toLowerCase()) {
+      throw new Error(
+        `Refusing to approve Permit2 for ${token}: only the registry USDC on chain ${config.chainId} is allowed.`
+      );
+    }
+    const data = encodeFunctionData({
+      abi: erc20Abi,
+      functionName: "approve",
+      args: [PERMIT2_ADDRESS, maxUint256]
+    });
+    try {
+      const sent = await account.sendCalls([{ to: usdc.address, data }]);
+      const id = typeof sent === "string" ? sent : sent?.id;
+      if (!id) throw new Error("approval submitted but no call id was returned");
+      return id;
+    } catch (err) {
+      throw explainUnchargeableSender(err, config.sessionAddress);
+    }
+  }
   async request(method, params) {
     const { account, config } = await this.getSession();
     switch (method) {
@@ -679,24 +891,25 @@ var SessionBridge = class {
       case "wallet_sendCalls": {
         const payload = Array.isArray(params) ? params[0] : params;
         const { calls } = payload;
-        return account.sendCalls(calls, {
-          permissionId: config.permissionId
-        });
+        const sendOptions = { permissionId: config.permissionId };
+        try {
+          return await account.sendCalls(calls, sendOptions);
+        } catch (err) {
+          throw explainUnchargeableSender(err, config.sessionAddress);
+        }
       }
       case "wallet_getCallsStatus": {
         const batchId = Array.isArray(params) ? params[0] : params;
         return account.getCallStatus(batchId);
       }
-      case "personal_sign": {
-        const message = Array.isArray(params) ? params[0] : params;
-        return account.signMessage(message);
-      }
-      case "eth_signTypedData_v4": {
-        const asArray = Array.isArray(params) ? params : [params];
-        const raw = asArray.length > 1 ? asArray[1] : asArray[0];
-        const typedData = typeof raw === "string" ? JSON.parse(raw) : raw;
-        return account.signTypedData(typedData);
-      }
+      // Refused rather than absent, so the reason is on screen instead of a
+      // caller reading "not supported in auto mode" and looking for a flag. See
+      // `supportsSessionMode` in rpc-classifier.ts for why.
+      case "personal_sign":
+      case "eth_signTypedData_v4":
+        throw new Error(
+          `${method} is not available in auto mode: a signature the session makes is not a call, so it never reaches the spend caps or the ledger. Run it through the browser instead.`
+        );
       case "wallet_grantPermissions":
         throw new Error("Requires browser \u2014 run `jaw session setup`.");
       case "wallet_revokePermissions":
@@ -714,9 +927,7 @@ var SESSION_SUPPORTED_METHODS = /* @__PURE__ */ new Set([
   "eth_requestAccounts",
   "eth_accounts",
   "wallet_sendCalls",
-  "wallet_getCallsStatus",
-  "personal_sign",
-  "eth_signTypedData_v4"
+  "wallet_getCallsStatus"
 ]);
 function supportsSessionMode(method) {
   return SESSION_SUPPORTED_METHODS.has(method);
@@ -740,32 +951,31 @@ function envSessionEnabled() {
   const value = process.env["JAW_SESSION"]?.toLowerCase();
   return value === "1" || value === "true";
 }
-var SIGN_RATE_WINDOW_MS = 6e4;
-var MAX_SIGNS_PER_WINDOW = 5;
-var SESSION_SIGNING_METHODS = ["wallet_sendCalls", "personal_sign", "eth_signTypedData_v4"];
+var SEND_RATE_WINDOW_MS = 6e4;
+var MAX_SENDS_PER_WINDOW = 5;
+var RATE_LIMITED_SESSION_METHODS = ["wallet_sendCalls"];
 function registerRpcTool(server) {
-  const recentSigns = [];
-  function assertUnderSignLimit() {
+  const recentSends = [];
+  function assertUnderSendLimit() {
     const now = Date.now();
-    while (recentSigns.length && now - recentSigns[0] > SIGN_RATE_WINDOW_MS) recentSigns.shift();
-    if (recentSigns.length >= MAX_SIGNS_PER_WINDOW) {
-      throw new Error("Autonomous signing rate limit reached, retry shortly or call again with session: false.");
+    while (recentSends.length && now - recentSends[0] > SEND_RATE_WINDOW_MS) recentSends.shift();
+    if (recentSends.length >= MAX_SENDS_PER_WINDOW) {
+      throw new Error("Autonomous send rate limit reached, retry shortly or call again with session: false.");
     }
-    recentSigns.push(now);
+    recentSends.push(now);
   }
   server.registerTool(
     "jaw_rpc",
     {
-      description: "Execute any JAW.id wallet RPC method. Supports transactions, signing, permissions, and queries. By default, methods that require signing open the browser for passkey authentication. Pass session: true to sign autonomously with the local session key instead (requires a session created via `jaw session setup` \u2014 check jaw_session_status). IMPORTANT: Read the jaw://api-reference resource for the full list of methods, and jaw://api-reference/{method} for detailed parameter formats and examples.",
+      description: "Execute any JAW.id wallet RPC method. Supports transactions, signing, permissions, and queries. By default, any method that uses the account opens the browser for passkey authentication. Pass session: true to send transactions autonomously with the local session key instead (requires a session created via `jaw session setup` \u2014 check jaw_session_status). Session mode sends, it does not sign: personal_sign and eth_signTypedData_v4 always open the browser, and asking for either with session: true is refused rather than routed. IMPORTANT: Read the jaw://api-reference resource for the full list of methods, and jaw://api-reference/{method} for detailed parameter formats and examples.",
       inputSchema: rpcMethodSchema
     },
-    // @ts-expect-error — MCP SDK deep type inference with z.any() in schema
     async (params) => {
       try {
         const config = loadConfig();
         const apiKey = resolveApiKey(config);
-        const chainId = resolveChainId(params.chainId, config);
         const useSession = params.session ?? envSessionEnabled();
+        const chainId = useSession && params.chainId === void 0 ? tryLoadSessionConfig()?.chainId ?? resolveChainId(void 0, config) : resolveChainId(params.chainId, config);
         let bridge;
         if (useSession) {
           if (!supportsSessionMode(params.method)) {
@@ -773,8 +983,8 @@ function registerRpcTool(server) {
               `Method ${params.method} is not supported in session mode. Call again with session: false to route through the browser bridge.`
             );
           }
-          if (SESSION_SIGNING_METHODS.includes(params.method)) {
-            assertUnderSignLimit();
+          if (RATE_LIMITED_SESSION_METHODS.includes(params.method)) {
+            assertUnderSendLimit();
           }
           bridge = new SessionBridge({ apiKey, chainId });
         } else {
@@ -782,8 +992,7 @@ function registerRpcTool(server) {
             keysUrl: config.keysUrl,
             apiKey,
             chainId,
-            ens: config.ens,
-            paymasterUrl: config.paymasters?.[chainId]?.url
+            ens: config.ens
           });
         }
         try {