@trustwallet/cli 0.13.0 → 0.14.0

package/dist/index.js

@@ -3124,6 +3124,7 @@ __export(dist_exports, {
   CommandError: () => CommandError,
   ERC20_ERROR_CODES: () => ERC20_ERROR_CODES,
   Erc20Error: () => Erc20Error,
+  McpResponse: () => McpResponse,
   NATIVE_TOKEN_ADDRESS: () => NATIVE_TOKEN_ADDRESS,
   QUERY_ERROR_CODES: () => QUERY_ERROR_CODES,
   QueryError: () => QueryError,
@@ -3613,7 +3614,7 @@ async function fetchBalance(httpClient, assetId, address, currency = "USD") {
     throw new BalanceError("NETWORK_ERROR", "Could not fetch balance. Please try again later.");
   }
 }
-var import_crypto, NATIVE_TOKEN_ADDRESS, SOLANA_NATIVE_ADDRESS, CHAINS, COMMON_TOKENS, BSC_18_DECIMAL_TOKENS, NATIVE_SYMBOLS, TOKEN_DECIMALS, CELO_NATIVE_ADDRESS, TwakError, TwakApiError, TwakNetworkError, TwakValidationError, CommandError, COMMON_ERROR_CODES, FS_ERRNO_CODES, SWAP_ERROR_CODES, SwapError, TRANSFER_ERROR_CODES, TransferError, WALLET_ERROR_CODES, WalletError, QUERY_ERROR_CODES, QueryError, BALANCE_ERROR_CODES, BalanceError, ALERT_ERROR_CODES, AlertError, ERC20_ERROR_CODES, Erc20Error, WATCH_ERROR_CODES, WatchError, AUTOMATION_ERROR_CODES, AutomationError, X402_ERROR_CODES, X402Error, DECIMAL_AMOUNT_RE, UNSAFE_KEYS, NAMING_API, DEFAULT_GATEWAY_URL, DEFAULT_MARKET_URL, DEFAULT_TIMEOUT, DEFAULT_USER_AGENT, DEFAULT_X_ORIGIN, TwakHttpClient, ALLOWED_OFFRAMP_PROVIDERS;
+var import_crypto, NATIVE_TOKEN_ADDRESS, SOLANA_NATIVE_ADDRESS, CHAINS, COMMON_TOKENS, BSC_18_DECIMAL_TOKENS, NATIVE_SYMBOLS, TOKEN_DECIMALS, CELO_NATIVE_ADDRESS, TwakError, TwakApiError, TwakNetworkError, TwakValidationError, CommandError, COMMON_ERROR_CODES, FS_ERRNO_CODES, SWAP_ERROR_CODES, SwapError, TRANSFER_ERROR_CODES, TransferError, WALLET_ERROR_CODES, WalletError, QUERY_ERROR_CODES, QueryError, BALANCE_ERROR_CODES, BalanceError, ALERT_ERROR_CODES, AlertError, ERC20_ERROR_CODES, Erc20Error, WATCH_ERROR_CODES, WatchError, AUTOMATION_ERROR_CODES, AutomationError, X402_ERROR_CODES, X402Error, DECIMAL_AMOUNT_RE, UNSAFE_KEYS, NAMING_API, DEFAULT_GATEWAY_URL, DEFAULT_MARKET_URL, DEFAULT_TIMEOUT, DEFAULT_USER_AGENT, DEFAULT_X_ORIGIN, TwakHttpClient, ALLOWED_OFFRAMP_PROVIDERS, McpResponse;
 var init_dist = __esm({
   "../core/dist/index.mjs"() {
     "use strict";
@@ -4182,7 +4183,11 @@ var init_dist = __esm({
       // Raised by WalletConnect provider methods when the session isn't yet
       // established (user hasn't scanned/approved) or has been dropped/expired.
       // Actionable: agent prompts the user to complete pairing, then retry.
-      WC_NOT_CONNECTED: "WC_NOT_CONNECTED"
+      WC_NOT_CONNECTED: "WC_NOT_CONNECTED",
+      // Raised by signing-path action providers when no wallet mode has been
+      // selected yet for this server lifetime. Actionable: agent calls
+      // switch_wallet_mode (local or walletconnect) and retries.
+      WALLET_NOT_BOUND: "WALLET_NOT_BOUND"
     };
     WalletError = class extends CommandError {
       constructor(code2, message) {
@@ -4373,6 +4378,11 @@ var init_dist = __esm({
       }
     };
     ALLOWED_OFFRAMP_PROVIDERS = /* @__PURE__ */ new Set(["MoonPay"]);
+    McpResponse = class {
+      constructor(content) {
+        this.content = content;
+      }
+    };
   }
 });
 
@@ -6880,7 +6890,7 @@ function registerShutdownHandlers(providers, onBeforeExit) {
     process.removeListener("SIGTERM", handler);
   };
 }
-var fs2, path2, import_trust_sdk, import_trust_sdk2, import_trust_sdk3, import_trust_sdk4, import_crypto2, __require, polyfillsApplied, _credentials, _naasSessionId, nodeStubsPatched, NAAS_SESSION_RE, naasSessionPatched, coinTypeByValue, walletCore, initialized, SPONSORED_RPC, BlockchainClient, WalletCoreSigner, domainsByCoinId, GATEWAY_URL, DEVICE_INFO_BODY, VerifyCredentialsError, WALLET_ID_SUFFIX, WALLET_ID_LENGTH, EVM_COIN_IDS, MAINTAINED_COIN_IDS, WalletProvider, AgentWalletProvider, SHUTDOWN_TIMEOUT_MS;
+var fs2, path2, import_trust_sdk, import_trust_sdk2, import_trust_sdk3, import_trust_sdk4, import_crypto2, __require, polyfillsApplied, _credentials, _naasSessionId, nodeStubsPatched, NAAS_SESSION_RE, naasSessionPatched, coinTypeByValue, walletCore, initialized, SPONSORED_RPC, BlockchainClient, WalletCoreSigner, domainsByCoinId, GATEWAY_URL, DEVICE_INFO_BODY, VerifyCredentialsError, WALLET_ID_SUFFIX, WALLET_ID_LENGTH, EVM_COIN_IDS, MAINTAINED_COIN_IDS, WalletProvider, AgentWalletProvider, WalletContext, SHUTDOWN_TIMEOUT_MS;
 var init_dist3 = __esm({
   "../wallet-core/dist/index.mjs"() {
     "use strict";
@@ -6896,6 +6906,7 @@ var init_dist3 = __esm({
     import_crypto2 = require("crypto");
     init_dist();
     init_dist2();
+    init_dist();
     __require = /* @__PURE__ */ ((x6) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x6, {
       get: (a3, b3) => (typeof require !== "undefined" ? require : a3)[b3]
     }) : x6)(function(x6) {
@@ -7916,10 +7927,33 @@ var init_dist3 = __esm({
           }
         }
       }
+      async signTypedData(chainKey, chainId, typedDataJson) {
+        await this.ensureConnected();
+        this.resetAutoLockTimer();
+        return this.blockchainClient.signTypedData({
+          chainKey,
+          chainId,
+          typedDataJson,
+          hdWallet: this.signer.getHDWallet()
+        });
+      }
+      async approveErc20(chainKey, token, spender, amount) {
+        await this.ensureConnected();
+        this.resetAutoLockTimer();
+        const coinId = chainKeyToCoinType(chainKey);
+        if (coinId === void 0) throw new Error(`Unsupported chain: ${chainKey}`);
+        const result = await this.blockchainClient.approve({
+          assetId: `c${coinId}_t${token}`,
+          spender,
+          amount,
+          hdWallet: this.signer.getHDWallet()
+        });
+        return { txHash: result.hash };
+      }
       async sendTransaction(params) {
         await this.ensureConnected();
         this.resetAutoLockTimer();
-        const { getChainByEvmId: getChainByEvmId2, chainKeyToCoinType: chainKeyToCoinType3 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+        const { getChainByEvmId: getChainByEvmId2, chainKeyToCoinType: chainKeyToCoinType4 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
         let assetId;
         if (params.chainId.startsWith("eip155:")) {
           const chain2 = getChainByEvmId2(params.chainId.replace("eip155:", ""));
@@ -7928,7 +7962,7 @@ var init_dist3 = __esm({
         } else if (params.chainId.startsWith("solana:")) {
           assetId = "c501";
         } else {
-          const coinId = chainKeyToCoinType3(params.chainId);
+          const coinId = chainKeyToCoinType4(params.chainId);
           if (coinId === void 0) throw new Error(`Unsupported chain: ${params.chainId}`);
           assetId = `c${coinId}`;
         }
@@ -7988,14 +8022,206 @@ var init_dist3 = __esm({
         return this.connected;
       }
       getBlockchainClient() {
-        if (!this.connected) throw new Error("Wallet is locked. Use an async method to trigger re-auth.");
+        if (!this.connected)
+          throw new Error("Wallet is locked. Use an async method to trigger re-auth.");
         return this.blockchainClient;
       }
       getSigner() {
-        if (!this.connected) throw new Error("Wallet is locked. Use an async method to trigger re-auth.");
+        if (!this.connected)
+          throw new Error("Wallet is locked. Use an async method to trigger re-auth.");
         return this.signer;
       }
     };
+    WalletContext = class {
+      _state = "unbound";
+      _wallet;
+      /**
+       * The WC instance we're currently pairing with. Used to ignore callbacks
+       * from a previous pairing if the user re-calls `beginWalletConnect` while
+       * already in `wc-pairing` (e.g. the first QR went stale and they want a
+       * fresh one). Without this guard, the first wc's session-established
+       * callback could land later and overwrite `_wallet` with the wrong instance.
+       */
+      _pendingWc;
+      _pairing;
+      _peerName;
+      _lastError;
+      /**
+       * Mode-switch serializer. Concurrent `bindLocal` / `beginWalletConnect` /
+       * `reset` calls otherwise interleave their state writes — `_pendingWc`
+       * identity guards prevent signing-against-wrong-wallet, but `_state` and
+       * `_pairing` can land in an inconsistent shape. We queue each entry so the
+       * second call waits for the first to settle. `.catch(()=>{})` on the field
+       * itself keeps a rejected switch from poisoning the queue for later calls
+       * (the caller still sees the original rejection via the awaited promise
+       * we return from each entry method).
+       */
+      _switchInflight = Promise.resolve();
+      /**
+       * Disconnect any in-flight or established WC session. Used internally when
+       * switching modes and externally by `reset()`. Best-effort — disconnect
+       * failures are swallowed (state still progresses to a clean slot).
+       *
+       * Covers both `wc-connected` (via `_wallet`) and `wc-pairing` (via
+       * `_pendingWc`). Without the pending-wc disconnect, switching away from
+       * `wc-pairing` would leave the relay client open until expiry.
+       */
+      async disconnectWcIfAny() {
+        const targets = [];
+        if (this._wallet && this._wallet.name === "walletconnect") {
+          targets.push(this._wallet);
+        }
+        if (this._pendingWc && this._pendingWc !== this._wallet) {
+          targets.push(this._pendingWc);
+        }
+        for (const t of targets) {
+          try {
+            await t.disconnect();
+          } catch {
+          }
+        }
+      }
+      get state() {
+        return this._state;
+      }
+      /**
+       * Returns the bound wallet, or throws WALLET_NOT_BOUND. All signing-path
+       * action providers (transfer/swap/x402/etc.) should call this at the top
+       * of each action method.
+       */
+      activeWallet() {
+        if (this._state !== "local" && this._state !== "wc-connected") {
+          throw new WalletError(
+            "WALLET_NOT_BOUND",
+            "No wallet mode selected. Ask the user whether to use the local agent wallet or pair via WalletConnect, then call switch_wallet_mode."
+          );
+        }
+        return this._wallet;
+      }
+      /** Snapshot for get_wallet_status MCP action and CLI introspection. */
+      snapshot() {
+        const base3 = {
+          state: this._state,
+          // Spread-copy so consumers can't mutate our internal _lastError object.
+          lastError: this._lastError ? { ...this._lastError } : void 0
+        };
+        if (this._wallet) {
+          base3.walletType = this._wallet.name === "walletconnect" ? "walletconnect" : "agent";
+        }
+        if (this._pairing) {
+          base3.pairing = {
+            uri: this._pairing.uri,
+            deepLink: this._pairing.deepLinks.universal,
+            qrCodeImageUrl: this._pairing.qrCode.imageUrl,
+            expiresAt: this._pairing.expiresAt
+          };
+        }
+        if (this._peerName) base3.peerName = this._peerName;
+        return base3;
+      }
+      /**
+       * Bind to the local agent wallet. Idempotent for the same provider; when
+       * called while bound to WC (`wc-connected` or `wc-pairing`), the WC session
+       * is disconnected first and any in-flight pairing is invalidated so its
+       * later session-established callback can't reclaim state.
+       */
+      async bindLocal(agent) {
+        return this.enqueue(() => this.bindLocalImpl(agent));
+      }
+      async bindLocalImpl(agent) {
+        await this.disconnectWcIfAny();
+        this._pendingWc = void 0;
+        this._wallet = agent;
+        this._pairing = void 0;
+        this._peerName = void 0;
+        this._state = "local";
+        this._lastError = void 0;
+      }
+      /**
+       * Run `task` after any in-flight mode switch finishes. The returned promise
+       * settles with `task`'s outcome (success or failure). The internal queue
+       * promise always resolves so a failing switch can't block subsequent
+       * switches.
+       */
+      enqueue(task) {
+        const next = this._switchInflight.then(task);
+        this._switchInflight = next.catch(() => void 0);
+        return next;
+      }
+      /**
+       * Start a WalletConnect pairing. Returns the pairing payload immediately;
+       * the caller surfaces it (QR code, deep link). When any compatible client
+       * approves, the provider's session_established event fires and the context
+       * transitions to `wc-connected`.
+       *
+       * V1 does not restrict the peer wallet — any WC v2 client can pair. The
+       * user's choice to scan the QR is the consent moment. A peer-identity gate
+       * (e.g. Trust-Wallet-only) is deferred until we have a real pairing log to
+       * write it against.
+       *
+       * `wc` is opaque here — we don't import the WalletConnect package directly
+       * to avoid forcing wallet-core to depend on it. The caller (typically the
+       * MCP action provider) constructs the WC provider and passes it in.
+       */
+      async beginWalletConnect(wc2, chains) {
+        return this.enqueue(() => this.beginWalletConnectImpl(wc2, chains));
+      }
+      async beginWalletConnectImpl(wc2, chains) {
+        await this.disconnectWcIfAny();
+        try {
+          this._pairing = await wc2.connect(chains);
+        } catch (err) {
+          this._wallet = void 0;
+          this._pendingWc = void 0;
+          this._pairing = void 0;
+          this._peerName = void 0;
+          this._state = "unbound";
+          this._lastError = {
+            code: "WC_PAIRING_FAILED",
+            message: `WalletConnect pairing failed: ${err instanceof Error ? err.message : String(err)}`
+          };
+          throw err;
+        }
+        this._wallet = void 0;
+        this._pendingWc = wc2;
+        this._state = "wc-pairing";
+        this._lastError = void 0;
+        this._peerName = void 0;
+        wc2.onSessionEstablished((session) => {
+          if (this._pendingWc !== wc2) return;
+          this._wallet = wc2;
+          this._peerName = session.peerName;
+          this._state = "wc-connected";
+          this._pendingWc = void 0;
+          this._pairing = void 0;
+        });
+        wc2.onSessionEnded((reason) => {
+          if (this._wallet !== wc2) return;
+          this._wallet = void 0;
+          this._pairing = void 0;
+          this._peerName = void 0;
+          this._state = "unbound";
+          this._lastError = {
+            code: "WC_NOT_CONNECTED",
+            message: `WalletConnect session ended (${reason}). Call switch_wallet_mode to re-pair or switch to local.`
+          };
+        });
+        return this.snapshot().pairing;
+      }
+      /** Disconnect the active wallet (best-effort) and return to `unbound`. */
+      async reset() {
+        return this.enqueue(() => this.resetImpl());
+      }
+      async resetImpl() {
+        await this.disconnectWcIfAny();
+        this._wallet = void 0;
+        this._pendingWc = void 0;
+        this._pairing = void 0;
+        this._peerName = void 0;
+        this._state = "unbound";
+        this._lastError = void 0;
+      }
+    };
     SHUTDOWN_TIMEOUT_MS = 3e3;
   }
 });
@@ -38734,10 +38960,10 @@ async function renderPngDataUrl(uri) {
 var DEFAULT_METADATA = {
   name: "TWAK Agent",
   description: "AI Agent for Trust Wallet operations",
-  url: "https://github.com/trustwallet/agent-kit",
+  url: "https://portal.trustwallet.com",
   icons: ["https://avatars.githubusercontent.com/u/32179365"]
 };
-var WC_NOT_CONNECTED_MSG = "WalletConnect session not established. If pairing is in progress, complete the approval in Trust Wallet mobile and retry; otherwise run connect_wallet to start pairing.";
+var WC_NOT_CONNECTED_MSG = 'WalletConnect session not established. If pairing is in progress, complete the approval in Trust Wallet mobile and retry; otherwise call switch_wallet_mode({mode: "walletconnect"}) to start pairing.';
 var WalletConnectProvider = class extends WalletProvider {
   name = "walletconnect";
   client = null;
@@ -38745,6 +38971,7 @@ var WalletConnectProvider = class extends WalletProvider {
   currentSession = null;
   config;
   sessionCallback = null;
+  sessionEndedCallback = null;
   pairingEventCallback = null;
   constructor(config) {
     super();
@@ -38769,12 +38996,13 @@ var WalletConnectProvider = class extends WalletProvider {
     const emit = (event, data) => {
       if (this.pairingEventCallback) this.pairingEventCallback(event, data);
     };
-    client.on("session_delete", ({ topic }) => {
-      if (this.currentSession?.topic === topic) this.currentSession = null;
-    });
-    client.on("session_expire", ({ topic }) => {
-      if (this.currentSession?.topic === topic) this.currentSession = null;
-    });
+    const handleSessionEnded = (topic, reason) => {
+      if (this.currentSession?.topic !== topic) return;
+      this.currentSession = null;
+      if (this.sessionEndedCallback) this.sessionEndedCallback(reason);
+    };
+    client.on("session_delete", ({ topic }) => handleSessionEnded(topic, "deleted"));
+    client.on("session_expire", ({ topic }) => handleSessionEnded(topic, "expired"));
     client.on("session_update", () => {
       if (this.sessionCallback) {
         const session = this.getActiveSession();
@@ -38792,6 +39020,15 @@ var WalletConnectProvider = class extends WalletProvider {
   onSessionEstablished(callback) {
     this.sessionCallback = callback;
   }
+  /**
+   * Register a callback for when the WC session ends (peer wallet revoked,
+   * relay-side expiry, etc.). WalletContext uses this to flip back to
+   * `unbound` so subsequent signing surfaces `WALLET_NOT_BOUND` rather than
+   * a deep WC-RPC failure.
+   */
+  onSessionEnded(callback) {
+    this.sessionEndedCallback = callback;
+  }
   /**
    * Returns the WC account to use as the `from` field for a signing request
    * on `chainId`. EVM-only: throws `CHAIN_UNSUPPORTED` if `chainId` isn't in
@@ -38846,6 +39083,36 @@ var WalletConnectProvider = class extends WalletProvider {
       }
     });
   }
+  async signTypedData(chainKey, chainId, typedDataJson) {
+    const session = this.getActiveSession();
+    if (!session) throw new WalletError("WC_NOT_CONNECTED", WC_NOT_CONNECTED_MSG);
+    const client = await this.ensureClient();
+    const caipChainId = chainKey.includes(":") ? chainKey : `eip155:${chainId}`;
+    return client.request({
+      topic: session.topic,
+      chainId: caipChainId,
+      request: {
+        method: "eth_signTypedData_v4",
+        params: [this.resolveFromAddress(caipChainId), typedDataJson]
+      }
+    });
+  }
+  async approveErc20(chainKey, token, spender, amount) {
+    const chain2 = getChainById(chainKey);
+    if (!chain2) throw new WalletError("CHAIN_UNSUPPORTED", `Unsupported chain: ${chainKey}`);
+    const caipChainId = `${chain2.namespace}:${chain2.chainId}`;
+    const selector = "0x095ea7b3";
+    const paddedSpender = spender.replace(/^0x/, "").toLowerCase().padStart(64, "0");
+    const paddedAmount = BigInt(amount).toString(16).padStart(64, "0");
+    const data = selector + paddedSpender + paddedAmount;
+    const txHash = await this.sendTransaction({
+      chainId: caipChainId,
+      to: token,
+      data,
+      value: "0x0"
+    });
+    return { txHash };
+  }
   async sendTransaction(params) {
     const session = this.getActiveSession();
     if (!session) throw new WalletError("WC_NOT_CONNECTED", WC_NOT_CONNECTED_MSG);
@@ -42665,29 +42932,30 @@ function registerQueryCommand(program3) {
 }
 
 // ../actions/dist/index.mjs
+init_dist();
 var import_zod3 = require("zod");
 init_dist();
 var import_zod4 = require("zod");
+init_dist();
 var import_zod5 = require("zod");
 init_dist();
 var import_zod6 = require("zod");
-init_dist();
 var import_zod7 = require("zod");
+init_dist();
 var import_zod8 = require("zod");
 init_dist();
 var import_zod9 = require("zod");
 init_dist();
 var import_zod10 = require("zod");
+init_dist3();
 init_dist();
 var import_zod11 = require("zod");
-init_dist();
 var import_zod12 = require("zod");
+init_dist();
 var import_zod13 = require("zod");
 init_dist();
 var import_zod14 = require("zod");
 init_dist();
-var import_zod15 = require("zod");
-init_dist();
 
 // ../x402/dist/index.mjs
 init_dist();
@@ -42911,12 +43179,11 @@ async function signTransferWithAuthorization(p3) {
     domain: p3.token,
     message: authorization
   });
-  const rawSignature = await p3.signer.blockchainClient.signTypedData({
-    chainKey: p3.signer.chainKey,
-    chainId: p3.token.chainId,
-    typedDataJson: JSON.stringify(typedData),
-    hdWallet: p3.signer.hdWallet
-  });
+  const rawSignature = await p3.walletProvider.signTypedData(
+    p3.chainKey,
+    p3.token.chainId,
+    JSON.stringify(typedData)
+  );
   const signature = normalizeEip712Signature(rawSignature);
   return { signature, authorization };
 }
@@ -42981,12 +43248,11 @@ async function signPermit2Authorization(p3) {
     witnessTo: p3.payTo,
     validAfter
   });
-  const rawSignature = await p3.signer.blockchainClient.signTypedData({
-    chainKey: p3.signer.chainKey,
-    chainId: p3.chainId,
-    typedDataJson: JSON.stringify(typedData),
-    hdWallet: p3.signer.hdWallet
-  });
+  const rawSignature = await p3.walletProvider.signTypedData(
+    p3.chainKey,
+    p3.chainId,
+    JSON.stringify(typedData)
+  );
   const signature = normalizeEip712Signature(rawSignature);
   return {
     signature,
@@ -43082,17 +43348,16 @@ async function payAndFetch(args) {
     if (!confirmed) {
       throw new X402Error("PAYMENT_CANCELLED", "Payment cancelled by user");
     }
-    const signer = args.provider.getSigner();
-    const hdWallet = signer.getHDWallet();
-    const bc2 = new BlockchainClient(signer);
-    const fromAddress = signer.getAddress(chainKey);
+    const bc2 = new BlockchainClient();
+    const fromAddress = await args.provider.getAddress(chainKey);
     const tokenAddress = getAsset(kind);
     const amount = getAmount(kind);
     let xPayment;
     let nonce;
     if (method === "eip3009") {
       const { signature, authorization } = await signTransferWithAuthorization({
-        signer: { blockchainClient: bc2, hdWallet, chainKey },
+        walletProvider: args.provider,
+        chainKey,
         token: {
           name: rawName,
           version: rawVersion,
@@ -43114,6 +43379,7 @@ async function payAndFetch(args) {
       nonce = authorization.nonce;
     } else {
       approval = await ensurePermit2Allowance({
+        walletProvider: args.provider,
         blockchainClient: bc2,
         chainKey,
         chainId: evmChainId,
@@ -43121,13 +43387,13 @@ async function payAndFetch(args) {
         owner: fromAddress,
         tokenAddress,
         requiredAmount: BigInt(amount),
-        confirmApproval: args.confirmApproval,
-        hdWallet
+        confirmApproval: args.confirmApproval
       }) ?? void 0;
       const rawExtra2 = getExtra(kind);
       const dynamicSpender = typeof rawExtra2?.spenderAddress === "string" ? rawExtra2.spenderAddress : void 0;
       const { signature, permit2Authorization } = await signPermit2Authorization({
-        signer: { blockchainClient: bc2, hdWallet, chainKey },
+        walletProvider: args.provider,
+        chainKey,
         chainId: evmChainId,
         tokenAddress,
         amount,
@@ -43188,14 +43454,14 @@ async function ensurePermit2Allowance(args) {
       `Permit2 needs a one-time approval for ${args.tokenAddress} on ${args.chainKey}. Run: twak erc20 approve --asset ${assetId} --spender ${PERMIT2_ADDRESS} --amount unlimited`
     );
   }
-  const result = await args.blockchainClient.approve({
-    assetId,
-    spender: PERMIT2_ADDRESS,
-    amount: MAX_UINT256_DECIMAL,
-    hdWallet: args.hdWallet
-  });
-  await waitForTxConfirmation(args.blockchainClient, args.chainKey, args.owner, result.hash);
-  return { token: args.tokenAddress, chain: args.chainKey, txHash: result.hash };
+  const { txHash } = await args.walletProvider.approveErc20(
+    args.chainKey,
+    args.tokenAddress,
+    PERMIT2_ADDRESS,
+    MAX_UINT256_DECIMAL
+  );
+  await waitForTxConfirmation(args.blockchainClient, args.chainKey, args.owner, txHash);
+  return { token: args.tokenAddress, chain: args.chainKey, txHash };
 }
 var APPROVE_TIMEOUT_MS = 6e4;
 var APPROVE_POLL_MS = 2e3;
@@ -43412,6 +43678,17 @@ async function readChallenge(resp) {
     );
   }
 }
+function isPayableNetwork(network) {
+  try {
+    parseNetwork(network);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function safeText(s2) {
+  return s2.replace(/[\x00-\x1f\x7f]/g, "");
+}
 async function quoteX402(args) {
   try {
     await validateX402Url(args.url);
@@ -43458,7 +43735,10 @@ async function quoteX402(args) {
   }
   let preferredKind = null;
   try {
-    preferredKind = pickSupportedKind(challenge.accepts);
+    const picked = pickSupportedKind(challenge.accepts);
+    if (isPayableNetwork(getNetwork(picked))) {
+      preferredKind = picked;
+    }
   } catch {
   }
   const accepts = challenge.accepts.map((kind) => {
@@ -43482,22 +43762,32 @@ async function quoteX402(args) {
       maxTimeoutSeconds: getMaxTimeoutSeconds(kind),
       preferred: preferredKind === kind,
       requiresApproval,
-      description: `${amount} of ${tokenLabel} on ${network} via ${transferMethod}${approvalTag}`
+      // `description` is a human-readable string consumers may render to a
+      // terminal (CLI, LLM chat UI). `tokenName` and `transferMethod` are
+      // seller-controlled (`extra.name`, `extra.assetTransferMethod`) so we
+      // strip control chars to defend against terminal-escape injection.
+      // Raw values stay on the structured `tokenName` / `transferMethod`
+      // fields so consumers can apply their own escaping policy.
+      description: `${amount} of ${safeText(tokenLabel)} on ${network} via ${safeText(transferMethod)}${approvalTag}`
     };
   });
   const chosen = accepts.find((a3) => a3.preferred);
-  const summary = chosen ? `Endpoint requires ${chosen.amount} of ${chosen.tokenName || chosen.asset} on ${chosen.network} via ${chosen.transferMethod}${chosen.requiresApproval ? " (requires one-time Permit2 approval)" : " (gasless)"}.` : "Endpoint has no supported payment options.";
+  const safeTokenLabel = chosen ? safeText(chosen.tokenName) || chosen.asset : "";
+  const safeMethod = chosen ? safeText(chosen.transferMethod) : "";
+  const summary = chosen ? `Endpoint offers ${accepts.length} payment option(s). Default route: ${chosen.amount} of ${safeTokenLabel} on ${chosen.network} via ${safeMethod}${chosen.requiresApproval ? " (requires one-time Permit2 approval)" : " (gasless)"}.` : `Endpoint offers ${accepts.length} payment option(s), but none are supported by this client.`;
   const requestShapeHint = supportsBody ? args.body ? ` with method "${httpMethod}" and the same request body` : ` with method "${httpMethod}"` : "";
   return {
     success: true,
     resource: challenge.version === 2 ? challenge.resource : void 0,
     accepts,
     summary,
-    nextAction: chosen ? `Call x402_request with this url${requestShapeHint} and maxPaymentAtomic = "${chosen.amount}" to pay.` : "No supported method offered."
+    nextAction: chosen ? `Show these payment options to the user and let them pick one. Then call x402_request with this url${requestShapeHint}, maxPaymentAtomic set to the picked option's amount, and preferAsset set to its asset contract.` : "No supported route. The endpoint offered no payment method this client can sign."
   };
 }
 
 // ../actions/dist/index.mjs
+var import_zod15 = require("zod");
+init_dist();
 var ActionProvider = class {
   supportsChain(_chainId) {
     return true;
@@ -43614,88 +43904,6 @@ var BalanceActionProvider = class extends ActionProvider {
     };
   }
 };
-var WalletActionProvider = class extends ActionProvider {
-  constructor(walletProvider, agentWallet) {
-    super();
-    this.walletProvider = walletProvider;
-    this.agentWallet = agentWallet;
-  }
-  name = "wallet";
-  description = "Wallet connection and address management";
-  getActions() {
-    if (!this.walletProvider) return [];
-    return [this.getWalletAddress(), this.getWalletStatus(), this.connectWallet()];
-  }
-  getWalletAddress() {
-    return {
-      name: "get_wallet_address",
-      description: "Get the connected wallet address",
-      schema: import_zod4.z.object({
-        chainId: import_zod4.z.string().optional().default("eip155:1").describe("Chain ID")
-      }),
-      invoke: async (_ctx, input2) => {
-        const provider = this.agentWallet ?? this.walletProvider;
-        if (!provider) {
-          return {
-            connected: false,
-            code: "WALLET_NOT_FOUND",
-            message: "No wallet provider configured"
-          };
-        }
-        try {
-          const address = await provider.getAddress(input2.chainId);
-          return { connected: true, address, chainId: input2.chainId, provider: provider.name };
-        } catch {
-          return { connected: false };
-        }
-      }
-    };
-  }
-  connectWallet() {
-    return {
-      name: "connect_wallet",
-      description: "Connect a wallet via WalletConnect (returns QR code / deep link)",
-      schema: import_zod4.z.object({
-        chains: import_zod4.z.array(import_zod4.z.string()).optional().default(["eip155:1"]).describe("Chains to connect")
-      }),
-      invoke: async (_ctx, input2) => {
-        if (!this.walletProvider) {
-          return {
-            success: false,
-            code: "WALLET_NOT_FOUND",
-            message: "No wallet provider configured"
-          };
-        }
-        const result = await this.walletProvider.connect(input2.chains);
-        return { success: true, ...result };
-      }
-    };
-  }
-  getWalletStatus() {
-    return {
-      name: "get_wallet_status",
-      description: "Check wallet connection status",
-      schema: import_zod4.z.object({}),
-      invoke: async (_ctx) => {
-        const status = {};
-        if (this.agentWallet) {
-          status.agent = {
-            connected: this.agentWallet.isConnected(),
-            addresses: await this.agentWallet.getAddresses()
-          };
-        }
-        if (this.walletProvider) {
-          status.walletConnect = {
-            connected: this.walletProvider.isConnected(),
-            addresses: this.walletProvider.isConnected() ? await this.walletProvider.getAddresses() : []
-          };
-        }
-        const hasAny = this.agentWallet || this.walletProvider;
-        return hasAny ? status : { connected: false, provider: "none" };
-      }
-    };
-  }
-};
 var ERC20_TRANSFER_SIG = "0xa9059cbb";
 var NATIVE_TOKEN_PLACEHOLDER = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
 var DEFAULT_MAX_TRANSFER_USD2 = 1e4;
@@ -43731,9 +43939,9 @@ function toCaip2(chain2) {
   return caip2;
 }
 var TransferActionProvider = class extends ActionProvider {
-  constructor(walletProvider, priceLookup, maxTransferUsd = DEFAULT_MAX_TRANSFER_USD2) {
+  constructor(walletContext, priceLookup, maxTransferUsd = DEFAULT_MAX_TRANSFER_USD2) {
     super();
-    this.walletProvider = walletProvider;
+    this.walletContext = walletContext;
     this.priceLookup = priceLookup;
     this.maxTransferUsd = maxTransferUsd;
   }
@@ -43746,20 +43954,17 @@ var TransferActionProvider = class extends ActionProvider {
     return {
       name: "transfer",
       description: 'Transfer native or ERC-20 tokens to a destination address on any EVM chain. Resolves ENS for the "to" field, applies a USD safety cap, and works with both the local agent wallet and an external WalletConnect-paired wallet.',
-      schema: import_zod5.z.object({
-        chain: import_zod5.z.string().describe(
+      schema: import_zod4.z.object({
+        chain: import_zod4.z.string().describe(
           'Chain name (e.g., ethereum, bsc, polygon, arbitrum, base). CAIP-2 ids like "eip155:1" also accepted.'
         ),
-        to: import_zod5.z.string().describe("Destination address or ENS name (e.g., vitalik.eth)"),
-        amount: import_zod5.z.string().describe('Amount in human-readable format (e.g., "1.5", "0.01")'),
-        token: import_zod5.z.string().optional().describe("ERC-20 token contract address (omit for native token)"),
-        decimals: import_zod5.z.coerce.number().optional().default(18).describe("Token decimals (default 18, use 6 for USDC/USDT)")
+        to: import_zod4.z.string().describe("Destination address or ENS name (e.g., vitalik.eth)"),
+        amount: import_zod4.z.string().describe('Amount in human-readable format (e.g., "1.5", "0.01")'),
+        token: import_zod4.z.string().optional().describe("ERC-20 token contract address (omit for native token)"),
+        decimals: import_zod4.z.coerce.number().optional().default(18).describe("Token decimals (default 18, use 6 for USDC/USDT)")
       }),
       invoke: async (_ctx, input2) => {
-        const signer = this.walletProvider;
-        if (!signer) {
-          throw new TransferError("WALLET_NOT_FOUND", "No wallet provider configured");
-        }
+        const signer = this.walletContext.activeWallet();
         const caip2 = toCaip2(input2.chain);
         if (this.priceLookup) {
           try {
@@ -43816,10 +44021,10 @@ var TransferActionProvider = class extends ActionProvider {
   }
 };
 var SwapActionProvider = class extends ActionProvider {
-  constructor(swapClient, walletProvider, blockchainClient) {
+  constructor(swapClient, walletContext, blockchainClient) {
     super();
     this.swapClient = swapClient;
-    this.walletProvider = walletProvider;
+    this.walletContext = walletContext;
     this.blockchainClient = blockchainClient;
   }
   name = "swap";
@@ -43871,19 +44076,19 @@ var SwapActionProvider = class extends ActionProvider {
     return {
       name: "swap",
       description: "Execute a token swap via Trust Wallet (supports all chains including cross-chain)",
-      schema: import_zod6.z.object({
-        fromChain: import_zod6.z.string().describe("Source chain (e.g., ethereum, polygon, solana)"),
-        fromToken: import_zod6.z.string().describe("Source token symbol or address"),
-        toChain: import_zod6.z.string().describe("Destination chain"),
-        toToken: import_zod6.z.string().describe("Destination token symbol or address"),
-        amount: import_zod6.z.string().describe("Human-readable amount to swap"),
-        slippage: import_zod6.z.string().optional().default("1").describe("Slippage tolerance % (max 50)")
+      schema: import_zod5.z.object({
+        fromChain: import_zod5.z.string().describe("Source chain (e.g., ethereum, polygon, solana)"),
+        fromToken: import_zod5.z.string().describe("Source token symbol or address"),
+        toChain: import_zod5.z.string().describe("Destination chain"),
+        toToken: import_zod5.z.string().describe("Destination token symbol or address"),
+        amount: import_zod5.z.string().describe("Human-readable amount to swap"),
+        slippage: import_zod5.z.string().optional().default("1").describe("Slippage tolerance % (max 50)")
       }),
       invoke: async (_ctx, input2) => {
-        const signer = this.walletProvider;
-        if (!signer || !this.swapClient) {
-          throw new SwapError("WALLET_NOT_FOUND", "Wallet and swap client required");
+        if (!this.swapClient) {
+          throw new SwapError("WALLET_NOT_FOUND", "Swap client not configured");
         }
+        const signer = this.walletContext.activeWallet();
         const slippage = parseFloat(input2.slippage ?? "1");
         if (isNaN(slippage) || slippage <= 0 || slippage > 50) {
           return {
@@ -43958,12 +44163,12 @@ var SwapActionProvider = class extends ActionProvider {
     return {
       name: "get_swap_quote",
       description: "Get a swap quote without executing",
-      schema: import_zod6.z.object({
-        fromChain: import_zod6.z.string().describe("Source chain"),
-        fromToken: import_zod6.z.string().describe("Source token symbol or address"),
-        toChain: import_zod6.z.string().describe("Destination chain"),
-        toToken: import_zod6.z.string().describe("Destination token symbol or address"),
-        amount: import_zod6.z.string().describe("Human-readable amount")
+      schema: import_zod5.z.object({
+        fromChain: import_zod5.z.string().describe("Source chain"),
+        fromToken: import_zod5.z.string().describe("Source token symbol or address"),
+        toChain: import_zod5.z.string().describe("Destination chain"),
+        toToken: import_zod5.z.string().describe("Destination token symbol or address"),
+        amount: import_zod5.z.string().describe("Human-readable amount")
       }),
       invoke: async (_ctx, input2) => {
         if (!this.swapClient) {
@@ -44016,9 +44221,9 @@ var SwapActionProvider = class extends ActionProvider {
     return {
       name: "get_token_price",
       description: "Get current USD price for a token",
-      schema: import_zod6.z.object({
-        chain: import_zod6.z.string().describe("Chain name (e.g., ethereum)"),
-        token: import_zod6.z.string().describe("Token symbol or address")
+      schema: import_zod5.z.object({
+        chain: import_zod5.z.string().describe("Chain name (e.g., ethereum)"),
+        token: import_zod5.z.string().describe("Token symbol or address")
       }),
       invoke: async (_ctx, input2) => {
         if (!this.swapClient) {
@@ -44067,10 +44272,10 @@ var SecurityActionProvider = class extends ActionProvider {
     return {
       name: "validate_transaction",
       description: "Validate an address or transaction for security",
-      schema: import_zod7.z.object({
-        address: import_zod7.z.string().describe("Address to validate"),
-        assetId: import_zod7.z.string().optional().describe("Asset ID"),
-        type: import_zod7.z.string().optional().describe("Validation type")
+      schema: import_zod6.z.object({
+        address: import_zod6.z.string().describe("Address to validate"),
+        assetId: import_zod6.z.string().optional().describe("Asset ID"),
+        type: import_zod6.z.string().optional().describe("Validation type")
       }),
       invoke: async (ctx, input2) => {
         return this.getService(ctx).validate(input2);
@@ -44081,8 +44286,8 @@ var SecurityActionProvider = class extends ActionProvider {
     return {
       name: "get_asset_info",
       description: "Get detailed information about an asset",
-      schema: import_zod7.z.object({
-        assetId: import_zod7.z.string().describe("Asset ID (e.g., c60_t0xA0b8...)")
+      schema: import_zod6.z.object({
+        assetId: import_zod6.z.string().describe("Asset ID (e.g., c60_t0xA0b8...)")
       }),
       invoke: async (ctx, input2) => {
         return this.getService(ctx).getAssetInfo(input2.assetId);
@@ -44107,12 +44312,12 @@ var HistoryActionProvider = class extends ActionProvider {
     return {
       name: "get_transaction_history",
       description: "Get transaction history for an address",
-      schema: import_zod8.z.object({
-        address: import_zod8.z.string().describe("Wallet address"),
-        chain: import_zod8.z.string().optional().describe("Chain name"),
-        limit: import_zod8.z.coerce.number().optional().default(20).describe("Max results"),
-        from: import_zod8.z.string().optional().describe("Start date (ISO)"),
-        to: import_zod8.z.string().optional().describe("End date (ISO)")
+      schema: import_zod7.z.object({
+        address: import_zod7.z.string().describe("Wallet address"),
+        chain: import_zod7.z.string().optional().describe("Chain name"),
+        limit: import_zod7.z.coerce.number().optional().default(20).describe("Max results"),
+        from: import_zod7.z.string().optional().describe("Start date (ISO)"),
+        to: import_zod7.z.string().optional().describe("End date (ISO)")
       }),
       invoke: async (ctx, input2) => {
         return this.getService(ctx).getHistory(input2);
@@ -44123,9 +44328,9 @@ var HistoryActionProvider = class extends ActionProvider {
     return {
       name: "get_transaction_details",
       description: "Get details of a specific transaction by hash",
-      schema: import_zod8.z.object({
-        hash: import_zod8.z.string().describe("Transaction hash"),
-        chain: import_zod8.z.string().describe("Chain name")
+      schema: import_zod7.z.object({
+        hash: import_zod7.z.string().describe("Transaction hash"),
+        chain: import_zod7.z.string().describe("Chain name")
       }),
       invoke: async (ctx, input2) => {
         const details = await this.getService(ctx).getByHash(input2.hash, input2.chain);
@@ -44138,10 +44343,10 @@ var HistoryActionProvider = class extends ActionProvider {
     return {
       name: "get_swap_history",
       description: "Get swap transaction history",
-      schema: import_zod8.z.object({
-        address: import_zod8.z.string().describe("Wallet address"),
-        chain: import_zod8.z.string().optional().describe("Chain name"),
-        limit: import_zod8.z.coerce.number().optional().default(20).describe("Max results")
+      schema: import_zod7.z.object({
+        address: import_zod7.z.string().describe("Wallet address"),
+        chain: import_zod7.z.string().optional().describe("Chain name"),
+        limit: import_zod7.z.coerce.number().optional().default(20).describe("Max results")
       }),
       invoke: async (ctx, input2) => {
         return this.getService(ctx).getSwapHistory(input2);
@@ -44171,11 +44376,11 @@ var AlertActionProvider = class extends ActionProvider {
     return {
       name: "create_alert",
       description: "Create a price alert for a token. Triggers when price goes above or below a target.",
-      schema: import_zod9.z.object({
-        tokenId: import_zod9.z.string().describe('Token ID (e.g., "c60" for ETH, "c20000714_t0x55d3..." for BSC USDT)'),
-        chainKey: import_zod9.z.string().describe('Chain key (e.g., "ethereum", "bsc")'),
-        condition: import_zod9.z.enum(["above", "below"]).describe("Alert when price goes above or below target"),
-        targetPrice: import_zod9.z.coerce.number().positive().describe("Target price in USD")
+      schema: import_zod8.z.object({
+        tokenId: import_zod8.z.string().describe('Token ID (e.g., "c60" for ETH, "c20000714_t0x55d3..." for BSC USDT)'),
+        chainKey: import_zod8.z.string().describe('Chain key (e.g., "ethereum", "bsc")'),
+        condition: import_zod8.z.enum(["above", "below"]).describe("Alert when price goes above or below target"),
+        targetPrice: import_zod8.z.coerce.number().positive().describe("Target price in USD")
       }),
       invoke: async (_ctx, input2) => {
         try {
@@ -44200,8 +44405,8 @@ var AlertActionProvider = class extends ActionProvider {
     return {
       name: "list_alerts",
       description: "List all price alerts",
-      schema: import_zod9.z.object({
-        activeOnly: import_zod9.z.boolean().optional().default(false).describe("Only show active alerts")
+      schema: import_zod8.z.object({
+        activeOnly: import_zod8.z.boolean().optional().default(false).describe("Only show active alerts")
       }),
       invoke: async (_ctx, input2) => {
         const alerts = input2.activeOnly ? await this.alertStore.getActive() : await this.alertStore.list();
@@ -44213,7 +44418,7 @@ var AlertActionProvider = class extends ActionProvider {
     return {
       name: "check_alerts",
       description: "Check active alerts against current prices and trigger any that match",
-      schema: import_zod9.z.object({}),
+      schema: import_zod8.z.object({}),
       invoke: async (_ctx, _input) => {
         const activeAlerts = await this.alertStore.getActive();
         const triggered = [];
@@ -44246,8 +44451,8 @@ var AlertActionProvider = class extends ActionProvider {
     return {
       name: "delete_alert",
       description: "Delete a price alert by ID",
-      schema: import_zod9.z.object({
-        id: import_zod9.z.string().describe("Alert ID to delete")
+      schema: import_zod8.z.object({
+        id: import_zod8.z.string().describe("Alert ID to delete")
       }),
       invoke: async (_ctx, input2) => {
         const deleted = await this.alertStore.delete(input2.id);
@@ -44260,31 +44465,25 @@ var AlertActionProvider = class extends ActionProvider {
   }
 };
 var AgentWalletActionProvider = class extends ActionProvider {
-  constructor(blockchainClient, agentWallet) {
+  constructor(blockchainClient, walletContext) {
     super();
     this.blockchainClient = blockchainClient;
-    this.agentWallet = agentWallet;
+    this.walletContext = walletContext;
   }
   name = "agent-wallet";
-  description = "Derive addresses and read native balances for the HD wallet at ~/.twak/wallet.json. The wallet is unlocked once at MCP server startup; these actions read the in-memory wallet directly and never require a password.";
+  description = "Derive addresses and read native balances for the active wallet (local HD or WalletConnect-paired). Returns the address that will actually sign \u2014 call these to surface the user-facing wallet identity.";
   getActions() {
     return [this.getAddress(), this.listAddresses(), this.walletBalance()];
   }
   requireWallet() {
-    if (!this.agentWallet) {
-      throw new WalletError(
-        "WALLET_NOT_FOUND",
-        "Agent wallet not loaded. Create one with `twak init` (CLI) and restart the MCP server so it can unlock the wallet at startup."
-      );
-    }
-    return this.agentWallet;
+    return this.walletContext.activeWallet();
   }
   getAddress() {
     return {
       name: "get_address",
-      description: "Derive the HD wallet's address for a specific chain.",
-      schema: import_zod10.z.object({
-        chainKey: import_zod10.z.string().describe('Chain key (e.g., "ethereum", "bsc", "solana")')
+      description: "Get the active wallet's address for a specific chain.",
+      schema: import_zod9.z.object({
+        chainKey: import_zod9.z.string().describe('Chain key (e.g., "ethereum", "bsc", "solana")')
       }),
       invoke: async (_ctx, input2) => {
         const wallet = this.requireWallet();
@@ -44296,8 +44495,8 @@ var AgentWalletActionProvider = class extends ActionProvider {
   listAddresses() {
     return {
       name: "list_addresses",
-      description: "Derive the HD wallet's addresses for every supported chain. Returns one address per chain.",
-      schema: import_zod10.z.object({}),
+      description: "Get the active wallet's addresses for every supported chain. Returns one address per chain.",
+      schema: import_zod9.z.object({}),
       invoke: async () => {
         const wallet = this.requireWallet();
         const addresses = await wallet.getAddresses();
@@ -44308,9 +44507,9 @@ var AgentWalletActionProvider = class extends ActionProvider {
   walletBalance() {
     return {
       name: "wallet_balance",
-      description: "Read the native-coin balance (BNB on BSC, ETH on Ethereum / Base / X-Layer, SOL on Solana) for the HD wallet on a specific chain. For ERC-20 / SPL token balances, use `get_balance`.",
-      schema: import_zod10.z.object({
-        chainKey: import_zod10.z.string().describe('Chain key (e.g., "ethereum", "bsc")')
+      description: "Read the native-coin balance (BNB on BSC, ETH on Ethereum / Base / Arbitrum, SOL on Solana, etc.) for the active wallet on a specific chain. For ERC-20 / SPL token balances, use `get_balance`.",
+      schema: import_zod9.z.object({
+        chainKey: import_zod9.z.string().describe('Chain key (e.g., "ethereum", "bsc")')
       }),
       invoke: async (_ctx, input2) => {
         const wallet = this.requireWallet();
@@ -44330,10 +44529,10 @@ var AgentWalletActionProvider = class extends ActionProvider {
   }
 };
 var TokenActionProvider = class extends ActionProvider {
-  constructor(blockchainClient, agentWallet) {
+  constructor(blockchainClient, walletContext) {
     super();
     this.blockchainClient = blockchainClient;
-    this.agentWallet = agentWallet;
+    this.walletContext = walletContext;
   }
   name = "token";
   description = "Chain-agnostic token operations \u2014 balances, approvals, and transfers";
@@ -44350,9 +44549,9 @@ var TokenActionProvider = class extends ActionProvider {
     return {
       name: "token_balance",
       description: "Get balance for a specific token or native asset by asset ID",
-      schema: import_zod11.z.object({
-        assetId: import_zod11.z.string().describe('Token ID (e.g., "c60" for ETH, "c20000714_t0x55d3..." for BSC USDT)'),
-        address: import_zod11.z.string().describe("Wallet address to check balance for")
+      schema: import_zod10.z.object({
+        assetId: import_zod10.z.string().describe('Token ID (e.g., "c60" for ETH, "c20000714_t0x55d3..." for BSC USDT)'),
+        address: import_zod10.z.string().describe("Wallet address to check balance for")
       }),
       invoke: async (_ctx, input2) => {
         if (!this.blockchainClient) {
@@ -44366,29 +44565,64 @@ var TokenActionProvider = class extends ActionProvider {
   transferToken() {
     return {
       name: "transfer_token",
-      description: "Transfer a token or native asset to a destination address",
-      schema: import_zod11.z.object({
-        assetId: import_zod11.z.string().describe("Token ID to transfer"),
-        to: import_zod11.z.string().describe("Destination address"),
-        amount: import_zod11.z.string().describe("Amount to transfer (in smallest unit)"),
-        memo: import_zod11.z.string().optional().describe("Optional memo/note")
+      description: "Transfer a token or native asset to a destination address. Works in both local and WalletConnect modes for EVM chains; non-EVM chains (e.g. Solana) require local wallet mode.",
+      schema: import_zod10.z.object({
+        assetId: import_zod10.z.string().describe("Token ID to transfer"),
+        to: import_zod10.z.string().describe("Destination address"),
+        amount: import_zod10.z.string().describe("Amount to transfer (in smallest unit)"),
+        memo: import_zod10.z.string().optional().describe("Optional memo/note")
       }),
       invoke: async (_ctx, input2) => {
-        if (!this.blockchainClient) {
-          throw new WalletError("WALLET_NOT_FOUND", "BlockchainClient not available");
+        const wallet = this.walletContext.activeWallet();
+        if (wallet instanceof AgentWalletProvider) {
+          if (!this.blockchainClient) {
+            throw new WalletError("WALLET_NOT_FOUND", "BlockchainClient not available");
+          }
+          const hdWallet = wallet.getSigner().getHDWallet();
+          const result = await this.blockchainClient.transfer({
+            assetId: input2.assetId,
+            to: input2.to,
+            amount: input2.amount,
+            memo: input2.memo,
+            hdWallet
+          });
+          return { hash: result.hash, chainKey: result.chainKey };
         }
-        if (!this.agentWallet) {
-          throw new WalletError("WALLET_NOT_FOUND", "Wallet not connected");
+        const { coinId, contractAddress } = parseTokenId(input2.assetId);
+        const chainKey = coinTypeToChainKey(coinId);
+        if (!chainKey) {
+          throw new WalletError("CHAIN_UNSUPPORTED", `Unknown coin type: ${coinId}`);
         }
-        const hdWallet = this.agentWallet.getSigner().getHDWallet();
-        const result = await this.blockchainClient.transfer({
-          assetId: input2.assetId,
-          to: input2.to,
-          amount: input2.amount,
-          memo: input2.memo,
-          hdWallet
-        });
-        return { hash: result.hash, chainKey: result.chainKey };
+        const chain2 = getChainById(chainKey);
+        if (!chain2 || chain2.namespace !== "eip155") {
+          throw new WalletError(
+            "CHAIN_UNSUPPORTED",
+            `transfer_token on ${chainKey} is not supported in WalletConnect mode (EVM-only). Switch to local wallet mode for ${chainKey} transfers.`
+          );
+        }
+        const caipChainId = `${chain2.namespace}:${chain2.chainId}`;
+        let txHash;
+        if (contractAddress) {
+          const selector = "0xa9059cbb";
+          const paddedTo = input2.to.replace(/^0x/, "").toLowerCase().padStart(64, "0");
+          const paddedAmount = BigInt(input2.amount).toString(16).padStart(64, "0");
+          const data = selector + paddedTo + paddedAmount;
+          txHash = await wallet.sendTransaction({
+            chainId: caipChainId,
+            to: contractAddress,
+            data,
+            value: "0x0"
+          });
+        } else {
+          const valueHex = "0x" + BigInt(input2.amount).toString(16);
+          txHash = await wallet.sendTransaction({
+            chainId: caipChainId,
+            to: input2.to,
+            data: "0x",
+            value: valueHex
+          });
+        }
+        return { hash: txHash, chainKey };
       }
     };
   }
@@ -44396,27 +44630,31 @@ var TokenActionProvider = class extends ActionProvider {
     return {
       name: "approve_token",
       description: `Approve a spender to use tokens on your behalf (ERC-20 approve). SAFETY: when amount is "unlimited" (or the MaxUint256 decimal string), you MUST surface the risk to the user and get their explicit consent before calling this tool \u2014 unlimited approvals grant the spender access to ALL of the user's tokens of this type, including future transfers, and have been used in many drainer attacks. Prefer a finite amount equal to the immediate need. Use revoke_token_approval (or amount: "0") to revoke an existing approval.`,
-      schema: import_zod11.z.object({
-        assetId: import_zod11.z.string().describe("Token ID to approve"),
-        spender: import_zod11.z.string().describe("Spender address to approve"),
-        amount: import_zod11.z.string().describe('Amount to approve (in smallest unit, or "unlimited")')
+      schema: import_zod10.z.object({
+        assetId: import_zod10.z.string().describe("Token ID to approve"),
+        spender: import_zod10.z.string().describe("Spender address to approve"),
+        amount: import_zod10.z.string().describe('Amount to approve (in smallest unit, or "unlimited")')
       }),
       invoke: async (_ctx, input2) => {
-        if (!this.blockchainClient) {
-          throw new WalletError("WALLET_NOT_FOUND", "BlockchainClient not available");
+        const wallet = this.walletContext.activeWallet();
+        const { coinId, contractAddress } = parseTokenId(input2.assetId);
+        if (!contractAddress) {
+          throw new WalletError("VALIDATION_ERROR", "Cannot approve native token (no contract).");
         }
-        if (!this.agentWallet) {
-          throw new WalletError("WALLET_NOT_FOUND", "Wallet not connected");
+        const chainKey = coinTypeToChainKey(coinId);
+        if (!chainKey) {
+          throw new WalletError("CHAIN_UNSUPPORTED", `Unsupported coin type: ${coinId}`);
+        }
+        const chain2 = getChainById(chainKey);
+        if (!chain2 || chain2.namespace !== "eip155") {
+          throw new WalletError(
+            "CHAIN_UNSUPPORTED",
+            `approve_token on ${chainKey} is not supported \u2014 ERC-20 approvals are EVM-only.`
+          );
         }
-        const hdWallet = this.agentWallet.getSigner().getHDWallet();
         const amount = input2.amount === "unlimited" ? "115792089237316195423570985008687907853269984665640564039457584007913129639935" : input2.amount;
-        const result = await this.blockchainClient.approve({
-          assetId: input2.assetId,
-          spender: input2.spender,
-          amount,
-          hdWallet
-        });
-        return { hash: result.hash, chainKey: result.chainKey };
+        const result = await wallet.approveErc20(chainKey, contractAddress, input2.spender, amount);
+        return { hash: result.txHash, chainKey };
       }
     };
   }
@@ -44424,27 +44662,31 @@ var TokenActionProvider = class extends ActionProvider {
     return {
       name: "revoke_token_approval",
       description: 'Revoke an ERC-20 token approval by setting the spender allowance to 0. Use this to remove a previously-granted allowance \u2014 especially important after unlimited approvals or any approval you no longer need. Applies only to ERC-20 tokens (asset IDs of form "c{coinId}_t{contract}"); native tokens have no approvals to revoke. This is the inverse of approve_token.',
-      schema: import_zod11.z.object({
-        assetId: import_zod11.z.string().describe(
+      schema: import_zod10.z.object({
+        assetId: import_zod10.z.string().describe(
           'ERC-20 token ID to revoke approval for (e.g., "c60_t0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" for USDC on Ethereum)'
         ),
-        spender: import_zod11.z.string().describe("Spender address whose allowance should be set to 0")
+        spender: import_zod10.z.string().describe("Spender address whose allowance should be set to 0")
       }),
       invoke: async (_ctx, input2) => {
-        if (!this.blockchainClient) {
-          throw new WalletError("WALLET_NOT_FOUND", "BlockchainClient not available");
+        const wallet = this.walletContext.activeWallet();
+        const { coinId, contractAddress } = parseTokenId(input2.assetId);
+        if (!contractAddress) {
+          throw new WalletError("VALIDATION_ERROR", "Native tokens have no approval to revoke.");
         }
-        if (!this.agentWallet) {
-          throw new WalletError("WALLET_NOT_FOUND", "Wallet not connected");
+        const chainKey = coinTypeToChainKey(coinId);
+        if (!chainKey) {
+          throw new WalletError("CHAIN_UNSUPPORTED", `Unsupported coin type: ${coinId}`);
         }
-        const hdWallet = this.agentWallet.getSigner().getHDWallet();
-        const result = await this.blockchainClient.approve({
-          assetId: input2.assetId,
-          spender: input2.spender,
-          amount: "0",
-          hdWallet
-        });
-        return { hash: result.hash, chainKey: result.chainKey };
+        const chain2 = getChainById(chainKey);
+        if (!chain2 || chain2.namespace !== "eip155") {
+          throw new WalletError(
+            "CHAIN_UNSUPPORTED",
+            `revoke_token_approval on ${chainKey} is not supported \u2014 ERC-20 approvals are EVM-only.`
+          );
+        }
+        const result = await wallet.approveErc20(chainKey, contractAddress, input2.spender, "0");
+        return { hash: result.txHash, chainKey };
       }
     };
   }
@@ -44452,10 +44694,10 @@ var TokenActionProvider = class extends ActionProvider {
     return {
       name: "check_allowance",
       description: "Check the token allowance for a spender address",
-      schema: import_zod11.z.object({
-        assetId: import_zod11.z.string().describe("Token ID to check allowance for"),
-        owner: import_zod11.z.string().describe("Token owner address"),
-        spender: import_zod11.z.string().describe("Spender address to check")
+      schema: import_zod10.z.object({
+        assetId: import_zod10.z.string().describe("Token ID to check allowance for"),
+        owner: import_zod10.z.string().describe("Token owner address"),
+        spender: import_zod10.z.string().describe("Spender address to check")
       }),
       invoke: async (_ctx, input2) => {
         if (!this.blockchainClient) {
@@ -44493,8 +44735,8 @@ var MarketActionProvider = class extends ActionProvider {
     return {
       name: "get_trending_tokens",
       description: "Get a list of trending tokens by market activity",
-      schema: import_zod12.z.object({
-        limit: import_zod12.z.coerce.number().optional().default(20).describe("Number of tokens to return (default 20)")
+      schema: import_zod11.z.object({
+        limit: import_zod11.z.coerce.number().optional().default(20).describe("Number of tokens to return (default 20)")
       }),
       invoke: async (ctx, input2) => {
         const tokens = await this.getService(ctx).getAssetListings({ limit: input2.limit });
@@ -44506,8 +44748,8 @@ var MarketActionProvider = class extends ActionProvider {
     return {
       name: "check_token_risk",
       description: "Check security and risk information for a token (honeypot detection, audit status, freeze authority)",
-      schema: import_zod12.z.object({
-        assetId: import_zod12.z.string().describe("Asset ID (e.g., c60_t0xA0b8... for ERC-20, c60 for native)")
+      schema: import_zod11.z.object({
+        assetId: import_zod11.z.string().describe("Asset ID (e.g., c60_t0xA0b8... for ERC-20, c60 for native)")
       }),
       invoke: async (ctx, input2) => {
         const status = await this.getService(ctx).checkCoinStatus(input2.assetId);
@@ -44613,9 +44855,9 @@ var OnrampActionProvider = class extends ActionProvider {
   // TransferActionProvider for the off-ramp payout path (confirm_offramp_transfer).
   // Off-ramp sends crypto to a third-party deposit address, so the cap is
   // strictly more important here than for peer-to-peer transfers.
-  constructor(walletProvider, priceLookup, maxTransferUsd = DEFAULT_MAX_OFFRAMP_USD) {
+  constructor(walletContext, priceLookup, maxTransferUsd = DEFAULT_MAX_OFFRAMP_USD) {
     super();
-    this.walletProvider = walletProvider;
+    this.walletContext = walletContext;
     this.priceLookup = priceLookup;
     this.maxTransferUsd = maxTransferUsd;
   }
@@ -44632,12 +44874,6 @@ var OnrampActionProvider = class extends ActionProvider {
   }
   async resolveAddress(providedAddress, cryptoAsset) {
     if (providedAddress) return providedAddress;
-    if (!this.walletProvider) {
-      throw new TransferError(
-        "WALLET_NOT_FOUND",
-        "walletAddress not provided and no wallet provider is configured. Pass walletAddress explicitly or configure an agent wallet."
-      );
-    }
     if (!cryptoAsset) {
       throw new TransferError(
         "VALIDATION_ERROR",
@@ -44651,19 +44887,19 @@ var OnrampActionProvider = class extends ActionProvider {
         `Cannot determine chain for asset ${cryptoAsset}. Pass walletAddress explicitly.`
       );
     }
-    return this.walletProvider.getAddress(chainKey);
+    return this.walletContext.activeWallet().getAddress(chainKey);
   }
   getOnrampQuote() {
     return {
       name: "get_onramp_quote",
       description: "Step 1 of buying crypto with fiat: get quotes from available payment providers (MoonPay, Transak, etc.) for a given fiat amount. Returns an array of quotes each with a quoteId \u2014 pass one to get_onramp_url to generate the checkout redirect.",
-      schema: import_zod13.z.object({
-        fiatAmount: import_zod13.z.coerce.number().positive().describe("Amount of fiat currency to spend (e.g., 100 for $100)."),
-        fiatCurrency: import_zod13.z.string().length(3).default("USD").describe("Fiat currency as a 3-letter ISO 4217 code (e.g., USD, EUR, GBP)."),
-        cryptoAsset: import_zod13.z.string().describe(
+      schema: import_zod12.z.object({
+        fiatAmount: import_zod12.z.coerce.number().positive().describe("Amount of fiat currency to spend (e.g., 100 for $100)."),
+        fiatCurrency: import_zod12.z.string().length(3).default("USD").describe("Fiat currency as a 3-letter ISO 4217 code (e.g., USD, EUR, GBP)."),
+        cryptoAsset: import_zod12.z.string().describe(
           "Target crypto asset ID. Format: c<coinId> for native coins (e.g., c60 for ETH, c0 for BTC, c501 for SOL) or c<coinId>_t<contract> for tokens (e.g., c60_t0xA0b8... for USDC on Ethereum)."
         ),
-        walletAddress: import_zod13.z.string().optional().describe(
+        walletAddress: import_zod12.z.string().optional().describe(
           "Destination wallet address where the purchased crypto will be sent. OMIT to auto-derive from the configured wallet using cryptoAsset's chain \u2014 this is the safe default and prevents sending funds to a stranger by mistake. Only supply this when operating on behalf of a different user."
         )
       }),
@@ -44697,12 +44933,12 @@ var OnrampActionProvider = class extends ActionProvider {
     return {
       name: "get_onramp_url",
       description: "Step 2 of buying crypto with fiat: exchange a quoteId from get_onramp_quote for a browser redirect URL. The user opens that URL to complete KYC and payment with the provider; on success, the provider sends the purchased crypto to the destination address. After this tool returns a URL, poll the balance tool named in the `followUp` field to observe the incoming funds \u2014 there is no background polling, webhook, or push notification.",
-      schema: import_zod13.z.object({
-        quoteId: import_zod13.z.string().describe("Quote ID returned by get_onramp_quote."),
-        walletAddress: import_zod13.z.string().optional().describe(
+      schema: import_zod12.z.object({
+        quoteId: import_zod12.z.string().describe("Quote ID returned by get_onramp_quote."),
+        walletAddress: import_zod12.z.string().optional().describe(
           "Destination wallet address. OMIT to auto-derive from the configured wallet \u2014 requires cryptoAsset so the chain can be determined. Only supply this when operating on behalf of a different user."
         ),
-        cryptoAsset: import_zod13.z.string().optional().describe(
+        cryptoAsset: import_zod12.z.string().optional().describe(
           "Crypto asset ID that was used for the quote (e.g., c60 for ETH). Required when walletAddress is omitted so the chain can be derived for address lookup."
         )
       }),
@@ -44745,16 +44981,16 @@ var OnrampActionProvider = class extends ActionProvider {
     return {
       name: "get_offramp_quote",
       description: "Step 1 of selling crypto for fiat: get quotes from available providers for converting a crypto amount into fiat. Returns an array of quotes each with a quoteId \u2014 pass one to get_offramp_url to generate the checkout redirect for completing KYC and order creation. The provider page cannot sign the payout (no key access in the browser); the agent must broadcast it natively via confirm_offramp_transfer once the deposit address is known.",
-      schema: import_zod13.z.object({
-        cryptoAmount: import_zod13.z.coerce.number().positive().describe("Amount of crypto to sell (e.g., 0.1 for 0.1 ETH)."),
-        cryptoAsset: import_zod13.z.string().describe(
+      schema: import_zod12.z.object({
+        cryptoAmount: import_zod12.z.coerce.number().positive().describe("Amount of crypto to sell (e.g., 0.1 for 0.1 ETH)."),
+        cryptoAsset: import_zod12.z.string().describe(
           "Crypto asset ID to sell. Format: c<coinId> for native coins (e.g., c60 for ETH, c0 for BTC) or c<coinId>_t<contract> for tokens."
         ),
-        fiatCurrency: import_zod13.z.string().length(3).default("USD").describe("Target fiat currency as a 3-letter ISO 4217 code (e.g., USD, EUR, GBP)."),
-        paymentMethod: import_zod13.z.enum(["ANY", "bank_transfer", "card"]).optional().default("ANY").describe(
+        fiatCurrency: import_zod12.z.string().length(3).default("USD").describe("Target fiat currency as a 3-letter ISO 4217 code (e.g., USD, EUR, GBP)."),
+        paymentMethod: import_zod12.z.enum(["ANY", "bank_transfer", "card"]).optional().default("ANY").describe(
           'Payout method. Default "ANY" is a sentinel that matches any provider \u2014 recommended unless you specifically need "card" or "bank_transfer". Sending an unrecognised value (or `bank_transfer` in regions without bank-payout coverage) silently returns an empty quotes array.'
         ),
-        walletAddress: import_zod13.z.string().optional().describe(
+        walletAddress: import_zod12.z.string().optional().describe(
           "Source wallet address holding the crypto to be sold. OMIT to auto-derive from the configured wallet using cryptoAsset's chain \u2014 this is the safe default. Only supply this when operating on behalf of a different user."
         )
       }),
@@ -44797,12 +45033,12 @@ var OnrampActionProvider = class extends ActionProvider {
     return {
       name: "get_offramp_url",
       description: "Step 2 of selling crypto for fiat: exchange a quoteId from get_offramp_quote for a browser checkout URL. The user opens that URL to complete KYC and order creation with the provider; the provider then displays a deposit address (plus a memo/tag on chains that require one) and the exact amount to send. The agent must then call confirm_offramp_transfer with those values to sign and broadcast the payout natively \u2014 the browser has no access to wallet keys and cannot sign the transfer itself. After the payout broadcasts, poll the balance tool named in the `followUp` field to observe the outgoing tx. Fiat payout arrives separately via the provider.",
-      schema: import_zod13.z.object({
-        quoteId: import_zod13.z.string().describe("Quote ID returned by get_offramp_quote."),
-        walletAddress: import_zod13.z.string().optional().describe(
+      schema: import_zod12.z.object({
+        quoteId: import_zod12.z.string().describe("Quote ID returned by get_offramp_quote."),
+        walletAddress: import_zod12.z.string().optional().describe(
           "Source wallet address. OMIT to auto-derive from the configured wallet \u2014 requires cryptoAsset so the chain can be determined. Only supply this when operating on behalf of a different user."
         ),
-        cryptoAsset: import_zod13.z.string().optional().describe(
+        cryptoAsset: import_zod12.z.string().optional().describe(
           "Crypto asset ID that was used for the quote (e.g., c60 for ETH). Required when walletAddress is omitted so the chain can be derived for address lookup."
         )
       }),
@@ -44846,31 +45082,28 @@ var OnrampActionProvider = class extends ActionProvider {
     return {
       name: "confirm_offramp_transfer",
       description: "Step 3 of selling crypto for fiat: sign and broadcast the payout transaction to the provider's deposit address. Call this AFTER the user has completed KYC in the browser and can read the deposit address + exact amount the provider displayed. Works with any wallet provider that implements sendTransaction (the local agent wallet, or a WalletConnect-paired external wallet). EVM-only \u2014 for BTC / Solana / Cosmos off-ramps use the `twak onramp sell-confirm` CLI command instead. Returns a tx hash on success; fiat payout from the provider then arrives separately (no on-chain signal for that step).",
-      schema: import_zod13.z.object({
-        depositAddress: import_zod13.z.string().describe(
+      schema: import_zod12.z.object({
+        depositAddress: import_zod12.z.string().describe(
           "The deposit address displayed by the provider after KYC. This is a third-party address \u2014 verify it matches what the provider shows before calling."
         ),
-        cryptoAmount: import_zod13.z.string().describe(
+        cryptoAmount: import_zod12.z.string().describe(
           'Exact amount to send in human-readable format (e.g., "0.1" for 0.1 ETH). Must match the amount the provider displays; under-sending will invalidate the sell order.'
         ),
-        cryptoAsset: import_zod13.z.string().describe(
+        cryptoAsset: import_zod12.z.string().describe(
           "Crypto asset being sold. Format: c<coinId> for native coins (e.g., c60 for ETH) or c<coinId>_t<contract> for ERC-20 tokens."
         ),
-        decimals: import_zod13.z.coerce.number().optional().describe(
+        decimals: import_zod12.z.coerce.number().optional().describe(
           "Token decimals. REQUIRED for ERC-20 assets (pass 6 for USDC/USDT, 18 for DAI, etc.) \u2014 omitting it will be rejected rather than silently defaulting to 18, because a wrong-decimals encode can over-pay the provider by orders of magnitude. Ignored for native coins."
         ),
-        memo: import_zod13.z.string().optional().describe(
+        memo: import_zod12.z.string().optional().describe(
           "Memo / destination tag. Not used on EVM chains, so supplying one on EVM is a no-op warning. Exists in the schema for forward-compat with non-EVM chains."
         ),
-        quoteId: import_zod13.z.string().optional().describe(
+        quoteId: import_zod12.z.string().optional().describe(
           "Quote ID from get_offramp_quote. Optional \u2014 included only for traceability in the response; tx details come from depositAddress / cryptoAmount."
         )
       }),
       invoke: async (_ctx, input2) => {
-        const signer = this.walletProvider;
-        if (!signer) {
-          throw new TransferError("WALLET_NOT_FOUND", "No wallet provider configured");
-        }
+        const signer = this.walletContext.activeWallet();
         let parsed;
         try {
           parsed = parseTokenId(input2.cryptoAsset);
@@ -44973,11 +45206,11 @@ var OnrampActionProvider = class extends ActionProvider {
   }
 };
 var AutomateActionProvider = class extends ActionProvider {
-  constructor(automationStore, swapClient, walletProvider, blockchainClient) {
+  constructor(automationStore, swapClient, walletContext, blockchainClient) {
     super();
     this.automationStore = automationStore;
     this.swapClient = swapClient;
-    this.walletProvider = walletProvider;
+    this.walletContext = walletContext;
     this.blockchainClient = blockchainClient;
   }
   name = "automate";
@@ -44994,15 +45227,15 @@ var AutomateActionProvider = class extends ActionProvider {
     return {
       name: "create_automation",
       description: "Create a DCA (recurring buy) or limit order (buy/sell when price condition is met)",
-      schema: import_zod14.z.object({
-        type: import_zod14.z.enum(["dca", "limit"]).describe("Automation type: dca (recurring) or limit (price trigger)"),
-        fromToken: import_zod14.z.string().describe("Source token symbol or address"),
-        toToken: import_zod14.z.string().describe("Destination token symbol or address"),
-        chain: import_zod14.z.string().default("ethereum").describe("Chain name"),
-        amount: import_zod14.z.string().describe("Amount of fromToken per execution"),
-        intervalMs: import_zod14.z.coerce.number().optional().describe("Interval in milliseconds for DCA (e.g., 86400000 for daily)"),
-        targetPrice: import_zod14.z.coerce.number().optional().describe("Target price in USD for limit orders"),
-        condition: import_zod14.z.enum(["above", "below"]).optional().describe("Price condition for limit orders")
+      schema: import_zod13.z.object({
+        type: import_zod13.z.enum(["dca", "limit"]).describe("Automation type: dca (recurring) or limit (price trigger)"),
+        fromToken: import_zod13.z.string().describe("Source token symbol or address"),
+        toToken: import_zod13.z.string().describe("Destination token symbol or address"),
+        chain: import_zod13.z.string().default("ethereum").describe("Chain name"),
+        amount: import_zod13.z.string().describe("Amount of fromToken per execution"),
+        intervalMs: import_zod13.z.coerce.number().optional().describe("Interval in milliseconds for DCA (e.g., 86400000 for daily)"),
+        targetPrice: import_zod13.z.coerce.number().optional().describe("Target price in USD for limit orders"),
+        condition: import_zod13.z.enum(["above", "below"]).optional().describe("Price condition for limit orders")
       }),
       invoke: async (_ctx, input2) => {
         if (input2.type === "dca" && !input2.intervalMs) {
@@ -45038,8 +45271,8 @@ var AutomateActionProvider = class extends ActionProvider {
     return {
       name: "list_automations",
       description: "List all active automation rules (DCA and limit orders)",
-      schema: import_zod14.z.object({
-        activeOnly: import_zod14.z.boolean().optional().default(true).describe("Only show active automations")
+      schema: import_zod13.z.object({
+        activeOnly: import_zod13.z.boolean().optional().default(true).describe("Only show active automations")
       }),
       invoke: async (_ctx, input2) => {
         const all = await this.automationStore.list();
@@ -45052,8 +45285,8 @@ var AutomateActionProvider = class extends ActionProvider {
     return {
       name: "delete_automation",
       description: "Delete (deactivate) an automation rule",
-      schema: import_zod14.z.object({
-        id: import_zod14.z.string().describe("Automation ID to delete")
+      schema: import_zod13.z.object({
+        id: import_zod13.z.string().describe("Automation ID to delete")
       }),
       invoke: async (_ctx, input2) => {
         const deleted = await this.automationStore.delete(input2.id);
@@ -45109,16 +45342,17 @@ var AutomateActionProvider = class extends ActionProvider {
     return {
       name: "run_automation_now",
       description: "Manually execute an automation immediately (runs the swap now regardless of schedule)",
-      schema: import_zod14.z.object({
-        id: import_zod14.z.string().describe("Automation ID to run")
+      schema: import_zod13.z.object({
+        id: import_zod13.z.string().describe("Automation ID to run")
       }),
       invoke: async (_ctx, input2) => {
-        if (!this.walletProvider || !this.swapClient) {
+        if (!this.swapClient) {
           throw new AutomationError(
-            "WALLET_NOT_FOUND",
-            "Agent wallet and swap client required to execute automation"
+            "VALIDATION_ERROR",
+            "Swap client required to execute automation"
           );
         }
+        const walletProvider = this.walletContext.activeWallet();
         const record2 = await this.automationStore.getById(input2.id);
         if (!record2) {
           return {
@@ -45151,7 +45385,7 @@ var AutomateActionProvider = class extends ActionProvider {
           };
         }
         const parsedAmount = parseAmount(record2.amount, fromTokenInfo.decimals);
-        const address = await this.walletProvider.getAddress(record2.chain);
+        const address = await walletProvider.getAddress(record2.chain);
         const quote = await this.swapClient.getQuote({
           fromChain: record2.chain,
           fromToken: fromTokenInfo.address,
@@ -45168,7 +45402,7 @@ var AutomateActionProvider = class extends ActionProvider {
         const transactions = await this.swapClient.getSwapTransactions(route);
         let txHash = "";
         for (const txData of transactions) {
-          txHash = await this.sendSwapTx(txData, chainConfig, this.walletProvider);
+          txHash = await this.sendSwapTx(txData, chainConfig, walletProvider);
           const isApproval = txData.transaction.type === "approval" || txData.transaction.type === "revokeApproval";
           await this.pollConfirmation(record2.chain, address, txHash, isApproval ? 6e4 : 12e4);
         }
@@ -45186,9 +45420,9 @@ var AutomateActionProvider = class extends ActionProvider {
   }
 };
 var X402ActionProvider = class extends ActionProvider {
-  constructor(agentWallet) {
+  constructor(walletContext) {
     super();
-    this.agentWallet = agentWallet;
+    this.walletContext = walletContext;
   }
   name = "x402";
   description = "HTTP requests to x402 payment-gated endpoints \u2014 pay and fetch in one call";
@@ -45198,13 +45432,13 @@ var X402ActionProvider = class extends ActionProvider {
   x402Quote() {
     return {
       name: "x402_quote",
-      description: 'Preview the payment requirements at an x402 payment-gated endpoint WITHOUT signing or paying. Returns the full list of payment options (each entry has chain, asset address, tokenName, amount, transferMethod, requiresApproval, and a pre-formatted `description` string). IMPORTANT: each entry in `accepts[]` is an INDEPENDENT payment option \u2014 a unique (chain, token, transfer method) triple. Do NOT merge entries by chain (e.g. "BSC USDC via EIP-3009 or Permit2" is wrong if BSC USDC is only offered via Permit2 and a separate BSC entry for a different token offers EIP-3009). Read each entry as its own row; use the per-entry `description` field verbatim when surfacing options to the user. Use this BEFORE x402_request to surface cost + method to the user, get their go-ahead, then call x402_request with the agreed maxPaymentAtomic plus optionally preferNetwork/preferMethod/preferAsset to disambiguate. The `preferred: true` entry is the one x402_request would automatically pick when no overrides are passed. INTERPRETING `requiresApproval`: `false` (EIP-3009, e.g. USDC on Base / Ethereum / X-Layer) \u2014 gasless. Sign the payment and you are done. No setup, no on-chain tx for the buyer, ever. `true` (Permit2, e.g. USDC on BSC) \u2014 the industry-standard Permit2 flow used by Uniswap, 1inch, and most major DeFi apps. THE FIRST x402_request to a Permit2 endpoint for a given token+chain broadcasts a one-time `approve(Permit2, MAX_UINT256)` tx (the buyer pays the gas \u2014 varies by chain: usually a few cents on BSC / Base / X-Layer, can be several dollars on Ethereum mainnet). The allowance granted is unlimited for the canonical Permit2 contract at 0x000000000022D473030F116dDEE9F6B43aC78BA3. After that, every future Permit2 payment for that token is signature-only (gasless). Revocable any time via `twak erc20 revoke`. The per-call spend is still capped at the request `maxPaymentAtomic` \u2014 unlimited allowance does NOT mean unlimited per-call spend. When `requiresApproval: true` AND the buyer has not used Permit2 for that token on that chain before, the agent SHOULD tell the user concretely what is about to happen (one-time approval on <chain> for <token>, gas paid in the chain native token, then the payment) before calling x402_request. BALANCE CHECK \u2014 AFTER this quote returns and BEFORE recommending any route or showing the menu to the user, check the wallet balance for every viable entry in `accepts`. For each entry: call `get_address(chainKey)` to find the wallet address on that chain, then `get_balance` for the entry\'s asset (or `wallet_balance(chainKey)` for native coins). Filter or annotate the menu \u2014 only recommend routes where the wallet has enough of the asset to cover `amount`. If a Permit2 entry needs a first-time approval (`requiresApproval: true`), also confirm the wallet holds some native chain gas (gas amount varies by chain). If no viable route has sufficient balance, tell the user upfront \u2014 do not present a menu that includes routes they cannot pay. This avoids the failure mode where the agent recommends a chain the user has no balance on and the user finds out only after committing. No wallet required \u2014 read-only HTTPS + 402 parse. HTTPS-only; private IPs and non-HTTPS schemes are rejected.',
-      schema: import_zod15.z.object({
-        url: import_zod15.z.string().describe(
+      description: 'Preview the payment requirements at an x402 payment-gated endpoint WITHOUT signing or paying. Returns the full list of payment options (each entry has chain, asset address, tokenName, amount, transferMethod, requiresApproval, and a pre-formatted `description` string). CRITICAL \u2014 after this returns, ALWAYS surface ALL entries in `accepts[]` to the user (as a short numbered list: chain \xB7 token \xB7 amount \xB7 method \xB7 "preferred" tag if applicable) and ask which to use BEFORE calling x402_request. Do not silently pick the `preferred` entry just because it is marked preferred \u2014 that is the picker default if no override is passed, but the user deserves to see every option (other chains may have cheaper gas, the user may hold balance only on a specific chain, etc.). The only exception: if you have already done a balance check and only one entry is viable, you may proceed with that one after noting the others as "unavailable (no balance)". IMPORTANT: each entry in `accepts[]` is an INDEPENDENT payment option \u2014 a unique (chain, token, transfer method) triple. Do NOT merge entries by chain (e.g. "BSC USDC via EIP-3009 or Permit2" is wrong if BSC USDC is only offered via Permit2 and a separate BSC entry for a different token offers EIP-3009). Read each entry as its own row; use the per-entry `description` field verbatim when surfacing options to the user. Once the user picks, call x402_request with the agreed maxPaymentAtomic plus optionally preferNetwork/preferMethod/preferAsset to disambiguate. INTERPRETING `requiresApproval`: `false` (EIP-3009, e.g. USDC on Base / Ethereum) \u2014 gasless. Sign the payment and you are done. No setup, no on-chain tx for the buyer, ever. `true` (Permit2, e.g. USDC on BSC) \u2014 the industry-standard Permit2 flow used by Uniswap, 1inch, and most major DeFi apps. THE FIRST x402_request to a Permit2 endpoint for a given token+chain broadcasts a one-time `approve(Permit2, MAX_UINT256)` tx (the buyer pays the gas \u2014 usually a few cents on BSC / Base, more on Ethereum mainnet). The allowance granted is unlimited for the canonical Permit2 contract at 0x000000000022D473030F116dDEE9F6B43aC78BA3. After that, every future Permit2 payment for that token is signature-only (gasless). Revocable any time via `twak erc20 revoke`. The per-call spend is still capped at the request `maxPaymentAtomic` \u2014 unlimited allowance does NOT mean unlimited per-call spend. When `requiresApproval: true` AND the buyer has not used Permit2 for that token on that chain before, the agent SHOULD tell the user concretely what is about to happen (one-time approval on <chain> for <token>, gas paid in the chain native token, then the payment) before calling x402_request. BALANCE CHECK \u2014 AFTER this quote returns and BEFORE recommending any route or showing the menu to the user, check the wallet balance for every viable entry in `accepts`. For each entry: call `get_address(chainKey)` to find the wallet address on that chain, then `get_balance` for the entry\'s asset (or `wallet_balance(chainKey)` for native coins). Filter or annotate the menu \u2014 only recommend routes where the wallet has enough of the asset to cover `amount`. If a Permit2 entry needs a first-time approval (`requiresApproval: true`), also confirm the wallet holds some native chain gas (gas amount varies by chain). If no viable route has sufficient balance, tell the user upfront \u2014 do not present a menu that includes routes they cannot pay. This avoids the failure mode where the agent recommends a chain the user has no balance on and the user finds out only after committing. No wallet required \u2014 read-only HTTPS + 402 parse. HTTPS-only; private IPs and non-HTTPS schemes are rejected.',
+      schema: import_zod14.z.object({
+        url: import_zod14.z.string().describe(
           "Target endpoint URL. Must be HTTPS. Resolves via DNS; private/local IPs are rejected."
         ),
-        method: import_zod15.z.string().optional().default("GET").describe("HTTP verb (GET, POST, PUT, ...). Case-insensitive."),
-        body: import_zod15.z.string().optional().describe(
+        method: import_zod14.z.string().optional().default("GET").describe("HTTP verb (GET, POST, PUT, ...). Case-insensitive."),
+        body: import_zod14.z.string().optional().describe(
           "Pre-serialized request body. For JSON payloads, pass JSON.stringify(...) on the caller side."
         )
       }),
@@ -45214,35 +45448,33 @@ var X402ActionProvider = class extends ActionProvider {
   x402Request() {
     return {
       name: "x402_request",
-      description: "Make an HTTP request to an x402 payment-gated endpoint. Handles the full flow: sends the initial request, parses any 402 challenge, signs an EIP-3009 or Permit2 payment authorization with the agent wallet, retries with the X-Payment header. PAYMENT METHODS: x402 endpoints offer one or more options in their 402 response. EIP-3009 is gasless for the buyer (no setup, no approval) \u2014 preferred when available, e.g. USDC on Base / Ethereum / X-Layer. Permit2 needs a one-time approve(Permit2, MAX) tx on the chain (the buyer pays the gas \u2014 usually a few cents on BSC / Base / X-Layer, can be several dollars on Ethereum mainnet), then every future Permit2 payment for that token is signature-only. Permit2 is required when the token does not support EIP-3009 \u2014 e.g. USDC on BSC. SAFETY \u2014 autoApprove decision: When autoApprove=true (default), this action silently broadcasts the one-time Permit2 approval if your wallet has not yet approved the canonical Permit2 contract for that token. The approval is to the same Permit2 contract Uniswap, 1inch, and most major DeFi apps use \u2014 it is not exotic infrastructure. The approval alone does not move funds; each subsequent payment still needs a fresh signature. Revocable any time via `twak erc20 revoke`. For first-time use of an endpoint you SHOULD tell the user concretely what is about to happen (one-time approval on <chain> for <token>, gas paid in the chain native token, then the payment) and get their go-ahead before calling. After the approval lands, subsequent Permit2 payments for that token are free of further approvals. Set autoApprove=false to surface code: 'PERMIT2_APPROVAL_REQUIRED' instead of broadcasting \u2014 useful when the user is not around or you want to handle the approval out-of-band. maxPaymentAtomic is the user's pre-commitment to a maximum payment in the asset's smallest unit (e.g. \"10000\" = 0.01 USDC at 6 decimals). If the server demands more than this cap, the call returns code: 'PAYMENT_AMOUNT_EXCEEDED' \u2014 DO NOT retry with a higher cap without asking the user. BALANCE CHECK \u2014 Before calling this action, verify the wallet holds enough of the chosen asset on the chosen chain. Call `get_address(chainKey)` to find the wallet address, then `get_balance` for the asset (or `wallet_balance(chainKey)` for native coins). For Permit2 first-time use, also confirm the wallet holds some native chain gas (amount varies by chain). Surface insufficient balance to the user BEFORE calling this action \u2014 a failed payment mid-flow can leave the wallet in a half-state (e.g. Permit2 approval broadcast, then the transfer signature fails). The balance check should already have happened during the `x402_quote` flow that produced the menu; redo it here only if you skipped quote or the balance might have changed since. WALLET \u2014 Uses twak's LOCAL agent wallet (an HD wallet stored encrypted on disk at ~/.twak/wallet.json). NOT WalletConnect: x402 signs entirely locally \u2014 no external app prompt, no QR scan, no session pairing, no `connect_wallet` call required. Do NOT call `connect_wallet` or `get_wallet_status` before this action; they relate to the separate WalletConnect signer flow and aren't needed here. To retrieve the local wallet's address for a chain (e.g. to show the user which address will pay, or to call `wallet_balance` / `get_balance`), call `get_address` with the chain key (e.g. \"bsc\", \"base\"), or `list_addresses` for all chains at once. If the local wallet is missing the call returns code: 'WALLET_NOT_FOUND' \u2014 direct the user to `twak init` (CLI) to create one. HTTPS-only; non-HTTPS schemes and private IPs are rejected before any payment signing.",
-      schema: import_zod15.z.object({
-        url: import_zod15.z.string().describe(
+      description: "Make an HTTP request to an x402 payment-gated endpoint. Handles the full flow: sends the initial request, parses any 402 challenge, signs an EIP-3009 or Permit2 payment authorization with the agent wallet, retries with the X-Payment header. PAYMENT METHODS: x402 endpoints offer one or more options in their 402 response. EIP-3009 is gasless for the buyer (no setup, no approval) \u2014 preferred when available, e.g. USDC on Base / Ethereum. Permit2 needs a one-time approve(Permit2, MAX) tx on the chain (the buyer pays the gas \u2014 usually a few cents on BSC / Base, more on Ethereum mainnet), then every future Permit2 payment for that token is signature-only. Permit2 is required when the token does not support EIP-3009 \u2014 e.g. USDC on BSC. SAFETY \u2014 autoApprove decision: When autoApprove=true (default), this action silently broadcasts the one-time Permit2 approval if your wallet has not yet approved the canonical Permit2 contract for that token. The approval is to the same Permit2 contract Uniswap, 1inch, and most major DeFi apps use \u2014 it is not exotic infrastructure. The approval alone does not move funds; each subsequent payment still needs a fresh signature. Revocable any time via `twak erc20 revoke`. For first-time use of an endpoint you SHOULD tell the user concretely what is about to happen (one-time approval on <chain> for <token>, gas paid in the chain native token, then the payment) and get their go-ahead before calling. After the approval lands, subsequent Permit2 payments for that token are free of further approvals. Set autoApprove=false to surface code: 'PERMIT2_APPROVAL_REQUIRED' instead of broadcasting \u2014 useful when the user is not around or you want to handle the approval out-of-band. maxPaymentAtomic is the user's pre-commitment to a maximum payment in the asset's smallest unit (e.g. \"10000\" = 0.01 USDC at 6 decimals). If the server demands more than this cap, the call returns code: 'PAYMENT_AMOUNT_EXCEEDED' \u2014 DO NOT retry with a higher cap without asking the user. BALANCE CHECK \u2014 Before calling this action, verify the wallet holds enough of the chosen asset on the chosen chain. Call `get_address(chainKey)` to find the wallet address, then `get_balance` for the asset (or `wallet_balance(chainKey)` for native coins). For Permit2 first-time use, also confirm the wallet holds some native chain gas (amount varies by chain). Surface insufficient balance to the user BEFORE calling this action \u2014 a failed payment mid-flow can leave the wallet in a half-state (e.g. Permit2 approval broadcast, then the transfer signature fails). The balance check should already have happened during the `x402_quote` flow that produced the menu; redo it here only if you skipped quote or the balance might have changed since. WALLET \u2014 Signs through whichever wallet mode is active for this session (local by default; switchable via `switch_wallet_mode`). If mode='local', signs in-process (no external prompt). If mode='walletconnect', signs over the WalletConnect relay \u2014 the user must approve each signature on their paired wallet. To retrieve the active wallet's address for a chain (e.g. to call `wallet_balance` / `get_balance`), call `get_address` with the chain key (e.g. \"bsc\", \"base\"), or `list_addresses` for all chains at once. HTTPS-only; non-HTTPS schemes and private IPs are rejected before any payment signing.",
+      schema: import_zod14.z.object({
+        url: import_zod14.z.string().describe(
           "Target endpoint URL. Must be HTTPS. Resolves via DNS; private/local IPs are rejected before any payment."
         ),
-        method: import_zod15.z.string().optional().default("GET").describe("HTTP verb (GET, POST, PUT, ...). Case-insensitive."),
-        body: import_zod15.z.string().optional().describe(
+        method: import_zod14.z.string().optional().default("GET").describe("HTTP verb (GET, POST, PUT, ...). Case-insensitive."),
+        body: import_zod14.z.string().optional().describe(
           "Pre-serialized request body. For JSON payloads, pass JSON.stringify(...) on the caller side."
         ),
-        maxPaymentAtomic: import_zod15.z.string().describe(
+        maxPaymentAtomic: import_zod14.z.string().describe(
           `Hard cap on payment amount in the asset's smallest atomic unit (integer string, e.g. "10000" = 0.01 USDC at 6 decimals). If the server demands more than this cap, the call returns code: 'PAYMENT_AMOUNT_EXCEEDED' rather than overpaying. The user has pre-committed to this cap \u2014 do NOT raise it without asking the user.`
         ),
-        autoApprove: import_zod15.z.boolean().optional().default(true).describe(
+        autoApprove: import_zod14.z.boolean().optional().default(true).describe(
           "When true (default), silently grants an UNLIMITED Permit2 allowance if the endpoint requires it \u2014 DANGEROUS, see SAFETY in the action description. Defaults true because MCP agents cannot interact with a prompt, but you MUST consult the user before relying on this on any endpoint you have not paid before. Set to false to surface code: 'PERMIT2_APPROVAL_REQUIRED' instead and route approval out-of-band."
         ),
-        preferNetwork: import_zod15.z.string().optional().describe(
+        preferNetwork: import_zod14.z.string().optional().describe(
           `Optional override: restrict payment to this network when the endpoint offers multiple. Accepts either CAIP-2 ("eip155:8453") or a chain key ("base"). Case-insensitive. Use this when the user has a balance on a specific chain \u2014 without it, the picker chooses based on transfer-method preference (EIP-3009 over Permit2), which can land on a chain where the wallet has no funds. If no offered entry matches, the call returns code: 'NO_MATCHING_ROUTE' with the list of offered networks so you can re-ask the user.`
         ),
-        preferMethod: import_zod15.z.string().optional().describe(
+        preferMethod: import_zod14.z.string().optional().describe(
           `Optional override: restrict payment to this transfer method ("eip3009", "permit2", or "permit2-exact"). Case-insensitive. Use this to force the gasless route (eip3009) or to insist on a specific Permit2 variant. If no offered entry matches, the call returns code: 'NO_MATCHING_ROUTE'.`
         ),
-        preferAsset: import_zod15.z.string().optional().describe(
+        preferAsset: import_zod14.z.string().optional().describe(
           "Optional override: restrict payment to entries matching this asset. Matches the entry's `asset` field (contract address, exact, case-insensitive) or its `tokenName` field (substring, case-insensitive). Pass the exact value from the quote's output. Returns code: 'NO_MATCHING_ROUTE' when nothing matches."
         )
       }),
       invoke: async (_ctx, input2) => {
-        if (!this.agentWallet) {
-          throw new WalletError("WALLET_NOT_FOUND", "Agent wallet required for x402 payments");
-        }
+        const provider = this.walletContext.activeWallet();
         try {
           const result = await payAndFetch({
             url: input2.url,
@@ -45252,8 +45484,13 @@ var X402ActionProvider = class extends ActionProvider {
             preferNetwork: input2.preferNetwork,
             preferMethod: input2.preferMethod,
             preferAsset: input2.preferAsset,
-            provider: this.agentWallet,
-            // maxPaymentAtomic is the cap; no per-call prompt for MCP.
+            provider,
+            // maxPaymentAtomic is the cap; no per-call prompt for MCP. The
+            // expectation is the LLM ran x402_quote first, presented the
+            // menu to the user, and is now calling x402_request with the
+            // user-picked (chain, asset). Token-substitution risk is
+            // accepted at the MCP layer — the CLI path has a readline
+            // confirm that surfaces the contract address as the safety net.
             confirm: async () => true,
             // Auto-true when autoApprove=true; omit (rejects) otherwise.
             confirmApproval: input2.autoApprove ? async () => true : void 0
@@ -45276,6 +45513,80 @@ var X402ActionProvider = class extends ActionProvider {
     };
   }
 };
+var WalletModeActionProvider = class extends ActionProvider {
+  name = "wallet-mode";
+  description = "Switch wallet modes mid-session. The local agent wallet is auto-bound at server startup when configured, so signing actions work out of the box without calling this. Only call switch_wallet_mode when the user explicitly asks to use WalletConnect (or to return to the local wallet afterwards).";
+  walletContext;
+  agentWallet;
+  walletConnectFactory;
+  constructor(options) {
+    super();
+    this.walletContext = options.walletContext;
+    this.agentWallet = options.agentWallet;
+    this.walletConnectFactory = options.walletConnectFactory;
+  }
+  getActions() {
+    return [this.switchWalletMode(), this.getWalletStatus()];
+  }
+  /**
+   * Builds the MCP response for a snapshot. When state is `wc-pairing` and
+   * a QR code is available, emits a text block + an image block so MCP
+   * clients (Claude Desktop etc.) render the QR inline. For other states,
+   * emits a single text block with the JSON snapshot.
+   */
+  snapshotResponse(snapshot) {
+    const textPayload = snapshot.pairing ? { ...snapshot, pairing: { ...snapshot.pairing, qrCodeImageUrl: void 0 } } : snapshot;
+    const content = [{ type: "text", text: JSON.stringify(textPayload, null, 2) }];
+    if (snapshot.pairing?.qrCodeImageUrl) {
+      const match = snapshot.pairing.qrCodeImageUrl.match(/^data:(image\/[^;]+);base64,(.+)$/);
+      if (match) {
+        const [, mimeType, base642] = match;
+        content.push({ type: "image", data: base642, mimeType });
+      }
+    }
+    return new McpResponse(content);
+  }
+  switchWalletMode() {
+    return {
+      name: "switch_wallet_mode",
+      description: 'Switch the active wallet mode for this MCP server session. IMPORTANT: the LOCAL agent wallet is auto-bound at server startup when one is configured, so most users do NOT need to call this \u2014 signing actions just work. Call this ONLY when the user explicitly asks to switch. Two flows: (a) user wants to sign on their phone via Trust Wallet (or any WC-compatible wallet) \u2192 mode="walletconnect"; (b) user wants to switch back from WalletConnect to the local wallet \u2192 mode="local". \n\nDISCOVERABILITY: most users do not know WalletConnect is an option. When the user first asks about wallet operations or signing in a fresh conversation, briefly mention that they can optionally switch to signing via Trust Wallet on their phone (more secure: keys never leave their device) by saying so \u2014 then call switch_wallet_mode if they opt in. Do not push it on every signing call; just surface it once early on or when the user expresses security concerns.\n\nFor mode="walletconnect": returns a pairing payload (URI, mobile deep link, inline QR image). Surface the QR to the user, then poll get_wallet_status until state="wc-connected" before retrying any signing action. Do NOT call switch_wallet_mode while a signing action is in flight: switching disconnects the prior WC relay session, which can break the in-flight signature; wait for the current action to settle before changing modes.',
+      schema: import_zod15.z.object({
+        mode: import_zod15.z.enum(["local", "walletconnect"]).describe(
+          '"local" for the on-disk agent wallet, "walletconnect" to pair a remote wallet'
+        )
+      }),
+      invoke: async (_ctx, input2) => {
+        if (input2.mode === "local") {
+          if (!this.agentWallet) {
+            throw new WalletError(
+              "WALLET_NOT_FOUND",
+              "No local agent wallet found. Create one with `twak init` (CLI), then restart the MCP client (e.g. Claude Desktop)."
+            );
+          }
+          await this.walletContext.bindLocal(this.agentWallet);
+          return this.snapshotResponse(this.walletContext.snapshot());
+        }
+        if (!this.walletConnectFactory) {
+          throw new WalletError(
+            "VALIDATION_ERROR",
+            "WalletConnect is not configured. Set WALLETCONNECT_PROJECT_ID (env var or `twak init --wc-project-id <id>`) and restart the MCP server."
+          );
+        }
+        const wc2 = this.walletConnectFactory();
+        await this.walletContext.beginWalletConnect(wc2);
+        return this.snapshotResponse(this.walletContext.snapshot());
+      }
+    };
+  }
+  getWalletStatus() {
+    return {
+      name: "get_wallet_status",
+      description: 'Returns the current wallet binding for this MCP server session: state ("unbound" | "local" | "wc-pairing" | "wc-connected"), wallet type (when bound), peer name (when wc-connected), and pairing data (URI / deep link / QR code, when state="wc-pairing"). When state="wc-pairing", the response includes an inline QR-code image (MCP image content), a mobile deep link (`pairing.deepLink`) for users on their phone, and the raw `pairing.uri` as a copyable string for advanced users. Poll this after switch_wallet_mode({mode: "walletconnect"}) until state transitions to "wc-connected"; that\'s when signing actions become usable. If the user asks to see the QR code again (e.g. "show me the QR", "I can\'t see it"), call this action again \u2014 every call while state="wc-pairing" re-emits the inline QR image. Do NOT try to render the QR yourself from the URI or the response JSON.',
+      schema: import_zod15.z.object({}),
+      invoke: async () => this.snapshotResponse(this.walletContext.snapshot())
+    };
+  }
+};
 
 // src/commands/serve.ts
 init_dist2();
@@ -49915,6 +50226,15 @@ var import_http = require("http");
 var import_crypto7 = require("crypto");
 init_dist2();
 init_dist();
+var SERVER_INSTRUCTIONS = `twak signs blockchain operations through one of two wallet modes:
+
+LOCAL (default): an HD wallet auto-bound at server startup. In-process signing, no user-side prompts.
+
+WALLETCONNECT: a remote wallet (e.g. Trust Wallet on phone) paired via WC v2. Each signing action prompts the user on their device. More secure: the private key never leaves the user's device.
+
+When the user first engages with signing operations in a fresh conversation, briefly mention that they can optionally switch to phone-based signing via \`switch_wallet_mode({mode: "walletconnect"})\` \u2014 many users don't know this is an option. Mention once; don't repeat on every signing call.
+
+To switch mid-session, call \`switch_wallet_mode\`. The new mode applies to subsequent calls; in-flight signing keeps using its captured wallet. Mode persists for the MCP server's lifetime; restarting the MCP client (e.g. Claude Desktop) resets to local.`;
 var TwakMcpServer = class {
   server;
   registry;
@@ -49922,7 +50242,10 @@ var TwakMcpServer = class {
   constructor(registry, context) {
     this.registry = registry;
     this.context = context;
-    this.server = new Server({ name: "twak", version: "0.1.0" }, { capabilities: { tools: {} } });
+    this.server = new Server(
+      { name: "twak", version: "0.1.0" },
+      { capabilities: { tools: {} }, instructions: SERVER_INSTRUCTIONS }
+    );
     this.setupHandlers();
   }
   setupHandlers() {
@@ -49956,6 +50279,9 @@ var TwakMcpServer = class {
       try {
         const parsed = action.schema.parse(args);
         const result = await action.invoke(this.context, parsed);
+        if (result instanceof McpResponse) {
+          return { content: result.content };
+        }
         return {
           content: [
             {
@@ -49999,7 +50325,7 @@ var CAIP2_TO_BC_CHAIN = {
   "eip155:42161": "arbitrum",
   "eip155:8453": "base",
   "eip155:10": "optimism",
-  "eip155:43114": "avalanchec"
+  "eip155:43114": "avalanche"
 };
 var RPC_REGISTRY = {
   "eip155:1": {
@@ -50146,7 +50472,13 @@ async function verifyPayment(rawHeader, config, httpClient, seenHashes, blockcha
   if (await seenHashes.hasSeen(txHash)) {
     return { valid: false, error: "Transaction hash already used (replay attack detected)" };
   }
-  const chainId = (typeof proof.chainId === "string" ? proof.chainId : config.chainId).toLowerCase();
+  if (typeof proof.chainId === "string" && proof.chainId.toLowerCase() !== config.chainId.toLowerCase()) {
+    return {
+      valid: false,
+      error: `Payment chain mismatch \u2014 merchant configured ${config.chainId}, proof claims ${proof.chainId}`
+    };
+  }
+  const chainId = config.chainId.toLowerCase();
   const chainKey = CAIP2_TO_CHAIN[chainId];
   if (!chainKey) {
     return { valid: false, error: `Unsupported chain: ${chainId}` };
@@ -50160,7 +50492,10 @@ async function verifyPayment(rawHeader, config, httpClient, seenHashes, blockcha
         txHash
       );
       if (status.failed) {
-        return { valid: false, error: `Transaction reverted on-chain${status.error ? `: ${status.error}` : ""}` };
+        return {
+          valid: false,
+          error: `Transaction reverted on-chain${status.error ? `: ${status.error}` : ""}`
+        };
       }
       if (status.confirmed) {
         const rpcResult2 = await verifyViaRPC(txHash, config, chainId);
@@ -50189,14 +50524,20 @@ async function verifyPayment(rawHeader, config, httpClient, seenHashes, blockcha
     const decimals = isNative ? chain2.nativeDecimals : tokenInfo?.decimals ?? 18;
     const expectedAtomic = parseTokenAmount(config.amount, decimals);
     if (BigInt(tx.amount) < expectedAtomic) {
-      return { valid: false, error: `Insufficient payment: received ${tx.amount}, expected ${config.amount}` };
+      return {
+        valid: false,
+        error: `Insufficient payment: received ${tx.amount}, expected ${config.amount}`
+      };
     }
     await seenHashes.markSeen(txHash, chainId);
     return { valid: true, method: "txhub" };
   } catch (err) {
     const is403 = err instanceof Error && err.message.includes("403");
     if (!is403) {
-      return { valid: false, error: `Failed to fetch transaction: ${err instanceof Error ? err.message : String(err)}` };
+      return {
+        valid: false,
+        error: `Failed to fetch transaction: ${err instanceof Error ? err.message : String(err)}`
+      };
     }
   }
   const rpcResult = await verifyViaRPC(txHash, config, chainId);
@@ -50414,7 +50755,7 @@ function registerServeCommand(program3) {
     "--payment-recipient <address>",
     "Address to receive payments (required for on-chain verification)",
     ""
-  ).option("--password <password>", "Wallet password (falls back to keychain)").option("--auto-lock <minutes>", "Auto-lock wallet after N minutes of inactivity").option("--walletconnect", "Enable WalletConnect for interactive wallet approval").option("--wc-project-id <id>", "WalletConnect project ID (or set WALLETCONNECT_PROJECT_ID)").action(async (opts) => {
+  ).option("--password <password>", "Wallet password (falls back to keychain)").option("--auto-lock <minutes>", "Auto-lock wallet after N minutes of inactivity").option("--wc-project-id <id>", "WalletConnect project ID (or set WALLETCONNECT_PROJECT_ID)").action(async (opts) => {
     await ensureTrustSDK();
     const client = await getClient();
     const swapClient = new SwapClient(client);
@@ -50427,15 +50768,6 @@ function registerServeCommand(program3) {
       if (password3) agentWallet = await AgentWalletProvider.fromStorage(password3);
     } catch {
     }
-    let wallet;
-    if (opts.walletconnect) {
-      const projectId = opts.wcProjectId || process.env.WALLETCONNECT_PROJECT_ID;
-      if (!projectId) {
-        error("--walletconnect requires --wc-project-id or WALLETCONNECT_PROJECT_ID");
-        process.exit(1);
-      }
-      wallet = new WalletConnectProvider({ projectId });
-    }
     if (opts.autoLock && agentWallet) {
       const minutes = parseInt(opts.autoLock, 10);
       if (isNaN(minutes) || minutes <= 0) {
@@ -50447,33 +50779,37 @@ function registerServeCommand(program3) {
         passwordResolver: () => resolvePassword(opts)
       });
     }
-    const useWalletConnect = Boolean(opts.walletconnect);
-    let walletProvider;
-    if (useWalletConnect) {
-      if (!wallet) {
-        error("--walletconnect was passed but WalletConnect provider failed to initialize");
-        process.exit(1);
+    let wcProjectId = opts.wcProjectId || process.env.WALLETCONNECT_PROJECT_ID;
+    if (!wcProjectId) {
+      try {
+        const creds = await new CredentialManager().load();
+        wcProjectId = creds?.walletConnectProjectId;
+      } catch {
       }
-      walletProvider = wallet;
-    } else {
-      walletProvider = agentWallet;
+    }
+    const walletConnectFactory = wcProjectId ? () => new WalletConnectProvider({ projectId: wcProjectId }) : void 0;
+    const walletContext = new WalletContext();
+    if (agentWallet) {
+      await walletContext.bindLocal(agentWallet);
     }
     const registry = new ActionRegistry();
     registry.register(new BalanceActionProvider());
-    registry.register(new WalletActionProvider(wallet, agentWallet));
-    registry.register(new SwapActionProvider(swapClient, walletProvider, blockchainClient));
+    registry.register(
+      new WalletModeActionProvider({ walletContext, agentWallet, walletConnectFactory })
+    );
+    registry.register(new SwapActionProvider(swapClient, walletContext, blockchainClient));
     registry.register(new SecurityActionProvider());
     registry.register(new HistoryActionProvider());
-    registry.register(new TransferActionProvider(walletProvider, swapClient));
+    registry.register(new TransferActionProvider(walletContext, swapClient));
     registry.register(new AlertActionProvider(alertStore, swapClient));
-    registry.register(new AgentWalletActionProvider(blockchainClient, agentWallet));
-    registry.register(new TokenActionProvider(blockchainClient, agentWallet));
+    registry.register(new AgentWalletActionProvider(blockchainClient, walletContext));
+    registry.register(new TokenActionProvider(blockchainClient, walletContext));
     registry.register(new MarketActionProvider());
-    registry.register(new OnrampActionProvider(walletProvider, swapClient));
+    registry.register(new OnrampActionProvider(walletContext, swapClient));
     registry.register(
-      new AutomateActionProvider(automationStore, swapClient, walletProvider, blockchainClient)
+      new AutomateActionProvider(automationStore, swapClient, walletContext, blockchainClient)
     );
-    registry.register(new X402ActionProvider(agentWallet));
+    registry.register(new X402ActionProvider(walletContext));
     const context = {
       httpClient: client
     };
@@ -50489,7 +50825,10 @@ function registerServeCommand(program3) {
         paymentRecipient: opts.paymentRecipient,
         blockchainClient
       });
-      registerShutdownHandlers([agentWallet, wallet], () => restServer.stop());
+      registerShutdownHandlers([agentWallet], async () => {
+        await walletContext.reset();
+        restServer.stop();
+      });
       try {
         await restServer.start();
       } catch (err) {
@@ -50497,7 +50836,7 @@ function registerServeCommand(program3) {
         process.exit(1);
       }
     } else {
-      registerShutdownHandlers([agentWallet, wallet]);
+      registerShutdownHandlers([agentWallet], () => walletContext.reset());
       const mcpServer = new TwakMcpServer(registry, context);
       console.error("TW Agent MCP server starting...");
       await mcpServer.start();
@@ -51149,6 +51488,7 @@ function registerAutomateCommand(program3) {
 }
 
 // src/commands/x402.ts
+init_dist();
 function makeReadlineConfirm() {
   return async (k4) => {
     const readline = await import("readline");
@@ -51205,6 +51545,54 @@ async function autoApproveConfirm(c3) {
   warn(`x402: auto-approving Permit2 unlimited allowance for ${c3.token} on ${c3.chain}`);
   return true;
 }
+function supportedChainName(network) {
+  if (!network.startsWith("eip155:")) return null;
+  const chain2 = getChainByEvmId(network.slice("eip155:".length));
+  return chain2 ? chain2.name : null;
+}
+function filterAndSortAccepts(accepts) {
+  const supported = accepts.flatMap((a3) => {
+    const chainName = supportedChainName(a3.network);
+    return chainName ? [{ ...a3, chainName }] : [];
+  });
+  return supported.sort((a3, b3) => Number(b3.preferred) - Number(a3.preferred));
+}
+function safeTokenName(s2) {
+  return s2.replace(/[\x00-\x1f\x7f]/g, "");
+}
+function renderAcceptsTable(accepts) {
+  const rows = accepts.map((a3, i2) => ({
+    idx: String(i2 + 1),
+    token: safeTokenName(a3.tokenName) || a3.asset,
+    chain: a3.chainName,
+    amount: a3.amount,
+    method: a3.transferMethod + (a3.requiresApproval ? " (Permit2)" : " (gasless)"),
+    asset: a3.asset
+  }));
+  const headers = {
+    idx: "#",
+    token: "Token",
+    chain: "Chain",
+    amount: "Amount",
+    method: "Method",
+    asset: "Asset"
+  };
+  const widths = {
+    idx: Math.max(headers.idx.length, ...rows.map((r3) => r3.idx.length)),
+    token: Math.max(headers.token.length, ...rows.map((r3) => r3.token.length)),
+    chain: Math.max(headers.chain.length, ...rows.map((r3) => r3.chain.length)),
+    amount: Math.max(headers.amount.length, ...rows.map((r3) => r3.amount.length)),
+    method: Math.max(headers.method.length, ...rows.map((r3) => r3.method.length)),
+    asset: Math.max(headers.asset.length, ...rows.map((r3) => r3.asset.length))
+  };
+  const pad3 = (s2, w4) => s2 + " ".repeat(Math.max(0, w4 - s2.length));
+  const line = (r3) => `${pad3(r3.idx, widths.idx)}  ${pad3(r3.token, widths.token)}  ${pad3(r3.chain, widths.chain)}  ${pad3(r3.amount, widths.amount)}  ${pad3(r3.method, widths.method)}  ${pad3(r3.asset, widths.asset)}`;
+  const totalWidth = Object.values(widths).reduce((a3, b3) => a3 + b3, 0) + (Object.keys(widths).length - 1) * 2;
+  console.log(line(headers));
+  console.log("\u2500".repeat(totalWidth));
+  rows.forEach((r3) => console.log(line(r3)));
+  console.log("\u2500".repeat(totalWidth));
+}
 function registerX402Command(program3) {
   const x402 = program3.command("x402").description("x402 micropayment protocol \u2014 pay HTTP endpoints that require on-chain payment");
   x402.command("request <url>").description(
@@ -51258,13 +51646,84 @@ function registerX402Command(program3) {
       handleCommandError(err, opts.json ?? false, "x402 request failed");
     }
   });
+  x402.command("quote <url>").description(
+    "Preview an x402 endpoint's payment options without signing. Read-only; no wallet needed."
+  ).option("--method <method>", "HTTP method", "GET").option("--body <json>", "Request body (JSON string)").option("--json", "JSON output").action(async (url, opts) => {
+    try {
+      const result = await quoteX402({ url, method: opts.method, body: opts.body });
+      if (!result.success) {
+        if (opts.json) {
+          output({ ...result, error: result.message, errorCode: result.code }, true);
+        } else {
+          error(result.message);
+        }
+        process.exitCode = 1;
+        return;
+      }
+      const sorted = filterAndSortAccepts(result.accepts);
+      const shQuote = (s2) => `'${s2.replace(/'/g, `'\\''`)}'`;
+      const cliCommand = (amount) => {
+        const parts = ["twak x402 request", shQuote(url)];
+        if (opts.method && opts.method.toUpperCase() !== "GET") {
+          parts.push(`--method ${shQuote(opts.method)}`);
+        }
+        if (opts.body) parts.push(`--body ${shQuote(opts.body)}`);
+        parts.push(`--max-payment ${amount}`);
+        return parts.join(" ");
+      };
+      if (opts.json) {
+        if (sorted.length === 0) {
+          output(
+            {
+              ...result,
+              nextAction: `Endpoint offered ${result.accepts.length} option(s) but none on chains this client supports.`
+            },
+            true
+          );
+          process.exitCode = 1;
+          return;
+        }
+        output(
+          {
+            ...result,
+            nextAction: `Show these payment options to the user. Default route is ${sorted[0].amount} ${safeTokenName(sorted[0].tokenName) || sorted[0].asset} on ${sorted[0].chainName}. Pick one and run: ${cliCommand(sorted[0].amount)} --prefer-asset <picked asset>. Omit --prefer-asset to use the default.`
+          },
+          true
+        );
+        return;
+      }
+      if (result.resource?.url) {
+        info(`Resource: ${result.resource.url}`);
+      }
+      info(result.summary);
+      const dropped = result.accepts.length - sorted.length;
+      if (dropped > 0) {
+        warn(`Filtered ${dropped} route(s) on chains this client does not support.`);
+      }
+      console.log("");
+      if (sorted.length === 0) {
+        error("No supported route from this endpoint.");
+        process.exitCode = 1;
+        return;
+      }
+      renderAcceptsTable(sorted);
+      console.log(
+        "If you don't pass --prefer-asset/--prefer-method/--prefer-network, the first row is used."
+      );
+      console.log("");
+      info(`Next: ${cliCommand(sorted[0].amount)}`);
+    } catch (err) {
+      handleCommandError(err, opts.json ?? false, "x402 quote failed");
+    }
+  });
   x402.command("info").description("Show x402 client information and usage").action(() => {
     info("twak x402 client \u2014 speaks canonical x402 (V1 + V2) with EIP-3009 + Permit2 signing");
     console.log("");
     console.log("Usage:");
+    console.log("  twak x402 quote <url>               Preview payment options (read-only)");
     console.log("  twak x402 request <url>             Pay an x402-gated endpoint");
     console.log("");
-    console.log("Options:");
+    console.log("Options (request):");
     console.log("  --method <method>          HTTP method (default: GET)");
     console.log("  --body <json>              Request body");
     console.log("  --max-payment <atomic>     Cap auto-approval; integer atomic units");
@@ -51292,7 +51751,7 @@ var crypto7 = __toESM(require("crypto"));
 // package.json
 var package_default = {
   name: "@trustwallet/cli",
-  version: "0.13.0",
+  version: "0.14.0",
   description: "TWAK CLI \u2014 command-line interface for Trust Wallet Agent Kit",
   main: "dist/index.js",
   types: "dist/index.d.ts",