@trustwallet/cli 0.6.10 → 0.7.0

package/dist/index.js

@@ -3138,7 +3138,7 @@ function getBackend() {
   if (macSecurity.isAvailable()) return macSecurity;
   return null;
 }
-var fs, path, os, crypto2, import_child_process, import_os, crypto22, __require, FileStore, ALGORITHM, KEY_LENGTH, IV_LENGTH, SALT_LENGTH, ITERATIONS, SERVICE, WALLET_ACCOUNT, API_SECRET_ACCOUNT, macSecurity, KeychainManager, CREDENTIALS_FILE, CredentialManager, WALLET_FILE, WalletConfigStore, ALERTS_FILE, AlertStore, SEEN_HASHES_FILE, SeenHashStore;
+var fs, path, os, crypto2, import_child_process, import_os, crypto22, crypto3, __require, FileStore, ALGORITHM, KEY_LENGTH, IV_LENGTH, SALT_LENGTH, ITERATIONS, SERVICE, WALLET_ACCOUNT, API_SECRET_ACCOUNT, macSecurity, KeychainManager, CREDENTIALS_FILE, CredentialManager, WALLET_FILE, WalletConfigStore, ALERTS_FILE, AlertStore, AUTOMATIONS_FILE, AutomationStore, SEEN_HASHES_FILE, SeenHashStore;
 var init_dist = __esm({
   "../storage/dist/index.mjs"() {
     "use strict";
@@ -3149,6 +3149,7 @@ var init_dist = __esm({
     import_child_process = require("child_process");
     import_os = require("os");
     crypto22 = __toESM(require("crypto"), 1);
+    crypto3 = __toESM(require("crypto"), 1);
     __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) {
@@ -3410,6 +3411,51 @@ var init_dist = __esm({
         await this.store.remove(ALERTS_FILE);
       }
     };
+    AUTOMATIONS_FILE = "automations.json";
+    AutomationStore = class {
+      store;
+      constructor(config2) {
+        this.store = new FileStore(config2);
+      }
+      async create(record2) {
+        const automations = await this.list();
+        const entry = {
+          ...record2,
+          id: crypto3.randomUUID(),
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          active: true
+        };
+        automations.push(entry);
+        await this.store.write(AUTOMATIONS_FILE, automations);
+        return entry;
+      }
+      async list() {
+        return await this.store.read(AUTOMATIONS_FILE) || [];
+      }
+      async getById(id) {
+        const automations = await this.list();
+        return automations.find((a3) => a3.id === id);
+      }
+      async update(id, updates) {
+        const automations = await this.list();
+        const index = automations.findIndex((a3) => a3.id === id);
+        if (index === -1) return void 0;
+        automations[index] = { ...automations[index], ...updates };
+        await this.store.write(AUTOMATIONS_FILE, automations);
+        return automations[index];
+      }
+      async delete(id) {
+        const automations = await this.list();
+        const filtered = automations.filter((a3) => a3.id !== id);
+        if (filtered.length === automations.length) return false;
+        await this.store.write(AUTOMATIONS_FILE, filtered);
+        return true;
+      }
+      async getActive() {
+        const automations = await this.list();
+        return automations.filter((a3) => a3.active);
+      }
+    };
     SEEN_HASHES_FILE = "seen-hashes.json";
     SeenHashStore = class {
       store;
@@ -6167,6 +6213,9 @@ function patchNodeStubs() {
       parsed.pathname = `/naas/session/${_naasSessionId}${parsed.pathname}`;
       resolvedUrl = parsed.toString();
     }
+    if (resolvedUrl.includes("aag") || resolvedUrl.includes("account-abstraction")) {
+      console.error("[AAG]", init3?.method || "GET", resolvedUrl.slice(0, 200));
+    }
     if (resolvedUrl.includes("gateway.us.trustwallet.com")) {
       resolvedUrl = resolvedUrl.replace("gateway.us.trustwallet.com", "tws.trustwallet.com");
     }
@@ -6406,7 +6455,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, __require2, polyfillsApplied, _credentials, _naasSessionId, nodeStubsPatched, NAAS_SESSION_RE, naasSessionPatched, coinTypeByValue, walletCore, initialized, BlockchainClient, WalletCoreSigner, domainsByCoinId, GATEWAY_URL, 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, __require2, polyfillsApplied, _credentials, _naasSessionId, nodeStubsPatched, NAAS_SESSION_RE, naasSessionPatched, coinTypeByValue, walletCore, initialized, SPONSORED_RPC, BlockchainClient, WalletCoreSigner, domainsByCoinId, GATEWAY_URL, WALLET_ID_SUFFIX, WALLET_ID_LENGTH, EVM_COIN_IDS, MAINTAINED_COIN_IDS, WalletProvider, AgentWalletProvider, SHUTDOWN_TIMEOUT_MS;
 var init_dist3 = __esm({
   "../wallet-core/dist/index.mjs"() {
     "use strict";
@@ -6436,7 +6485,11 @@ var init_dist3 = __esm({
     coinTypeByValue = null;
     walletCore = null;
     initialized = false;
-    BlockchainClient = class {
+    SPONSORED_RPC = {
+      20000714: "https://bsc-sponsored.twnodes.com",
+      60: "https://ethereum-sponsored.twnodes.com"
+    };
+    BlockchainClient = class _BlockchainClient {
       signer;
       constructor(signer) {
         this.signer = signer;
@@ -6553,14 +6606,15 @@ var init_dist3 = __esm({
         const asset = contractAddress ? new import_trust_sdk2.Asset.Token(account, contractAddress, tokenTypeForCoinId(coinId)) : new import_trust_sdk2.Asset.Coin(account);
         const decimals = params.decimals !== void 0 ? params.decimals : contractAddress ? resolveToken(params.assetId, chainKey).decimals : getCoinDecimals(coinId);
         const amountWei = humanAmountToWei(params.amount, decimals);
-        const transaction = new import_trust_sdk2.TransactionTransfer(
+        let transaction = new import_trust_sdk2.TransactionTransfer(
           params.to,
           asset,
           amountWei.toString(),
           false,
           params.memo || null
         );
-        const fee = await import_trust_sdk2.BlockchainService.calculateFee(transaction);
+        const { fee, transaction7702 } = await this.calculateFeeWithSponsorship(transaction, account, coinId);
+        if (transaction7702) transaction = transaction7702;
         const nonce = await import_trust_sdk2.BlockchainService.fetchNonce(account);
         let encodedTx;
         try {
@@ -6584,7 +6638,7 @@ var init_dist3 = __esm({
             }
           }
         }
-        const hash = await import_trust_sdk2.BlockchainService.sendTransactionV2(chain2, encodedTx);
+        const hash = await this.sendTransactionWithSponsorship(chain2, encodedTx, coinId);
         return { hash, chainKey };
       }
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -6602,13 +6656,14 @@ var init_dist3 = __esm({
         const account = this.getAccountFromSigner(chainKey);
         const asset = new import_trust_sdk2.Asset.Token(account, contractAddress, tokenTypeForCoinId(coinId));
         const approveData = this.encodeApproveCalldata(params.spender, params.amount);
-        const transaction = new import_trust_sdk2.TransactionSmartContract(
+        let transaction = new import_trust_sdk2.TransactionSmartContract(
           asset,
           contractAddress,
           "0",
           approveData
         );
-        const fee = await import_trust_sdk2.BlockchainService.calculateFee(transaction);
+        const { fee, transaction7702 } = await this.calculateFeeWithSponsorship(transaction, account, coinId);
+        if (transaction7702) transaction = transaction7702;
         const nonce = await import_trust_sdk2.BlockchainService.fetchNonce(account);
         let encodedTx;
         try {
@@ -6632,7 +6687,7 @@ var init_dist3 = __esm({
             }
           }
         }
-        const hash = await import_trust_sdk2.BlockchainService.sendTransactionV2(chain2, encodedTx);
+        const hash = await this.sendTransactionWithSponsorship(chain2, encodedTx, coinId);
         return { hash, chainKey };
       }
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -6647,8 +6702,9 @@ var init_dist3 = __esm({
         const account = this.getAccountFromSigner(chainKey);
         const asset = new import_trust_sdk2.Asset.Coin(account);
         const valueWei = params.value && params.value !== "0x0" && params.value !== "0x" ? BigInt(params.value).toString() : "0";
-        const transaction = new import_trust_sdk2.TransactionSmartContract(asset, params.to, valueWei, params.data);
-        const fee = await import_trust_sdk2.BlockchainService.calculateFee(transaction);
+        let transaction = new import_trust_sdk2.TransactionSmartContract(asset, params.to, valueWei, params.data);
+        const { fee, transaction7702 } = await this.calculateFeeWithSponsorship(transaction, account, coinId);
+        if (transaction7702) transaction = transaction7702;
         const nonce = await import_trust_sdk2.BlockchainService.fetchNonce(account);
         let encodedTx;
         try {
@@ -6667,7 +6723,7 @@ var init_dist3 = __esm({
             }
           }
         }
-        const hash = await import_trust_sdk2.BlockchainService.sendTransactionV2(chain2, encodedTx);
+        const hash = await this.sendTransactionWithSponsorship(chain2, encodedTx, coinId);
         return { hash, chainKey };
       }
       async getAllowance(params) {
@@ -6828,6 +6884,193 @@ var init_dist3 = __esm({
         const chain2 = new import_trust_sdk2.DefinedChain(ct5);
         await import_trust_sdk2.BlockchainService.setNode(chain2, new import_trust_sdk2.Node(rpcUrl));
       }
+      // EIP-7702 sponsorship-eligible chain coin IDs
+      static SPONSORABLE_COINS = [60, 20000714];
+      /**
+       * Build the sponsored RPC URL with NaaS session if available.
+       */
+      getSponsoredRpcUrl(coinId) {
+        const base3 = SPONSORED_RPC[coinId];
+        if (!base3) return void 0;
+        const sessionId = process.env.TWAK_NAAS_SESSION_ID;
+        return sessionId ? `${base3}/naas/session/${sessionId}/` : base3;
+      }
+      /**
+       * Try sending via sponsored RPC first (checks pm_isSponsorable, then
+       * eth_sendRawTransaction). Falls back to regular BlockchainService.
+       */
+      async sendTransactionWithSponsorship(chain2, encodedTx, coinId) {
+        const sponsoredUrl = this.getSponsoredRpcUrl(coinId);
+        if (sponsoredUrl) {
+          try {
+            let rlpStart = 0;
+            if (encodedTx[0] === 10) {
+              let offset = 1;
+              while (offset < encodedTx.length && (encodedTx[offset] & 128) !== 0) offset++;
+              offset++;
+              rlpStart = offset;
+            }
+            const rawRlp = "0x" + Array.from(encodedTx.slice(rlpStart)).map((b3) => b3.toString(16).padStart(2, "0")).join("");
+            const resp = await fetch(sponsoredUrl, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({ id: 0, jsonrpc: "2.0", method: "eth_sendRawTransaction", params: [rawRlp] }),
+              signal: AbortSignal.timeout(3e4)
+            });
+            const json = await resp.json();
+            if (json.result) return json.result;
+          } catch {
+          }
+        }
+        return import_trust_sdk2.BlockchainService.sendTransactionV2(chain2, encodedTx);
+      }
+      // Known stablecoins to try as gas payment tokens when getSupportedTokens returns empty
+      static FALLBACK_GAS_TOKENS = {
+        20000714: [
+          // BSC
+          "0x55d398326f99059fF775485246999027B3197955",
+          // USDT
+          "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d"
+          // USDC
+        ],
+        60: [
+          // ETH
+          "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+          // USDT
+          "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
+          // USDC
+        ]
+      };
+      /**
+       * Find a token the wallet holds that can pay for gas on this chain.
+       * Tries SmartWalletConfig.getSupportedTokens() first, then falls back
+       * to known stablecoins (USDT/USDC).
+       */
+      async findGasToken(account, coinId) {
+        const ct5 = requireCoinType(coinId);
+        const chain2 = new import_trust_sdk2.DefinedChain(ct5);
+        const candidates = [];
+        try {
+          const supportedTokens = await import_trust_sdk2.SmartWalletConfig.getSupportedTokens(chain2);
+          if (supportedTokens?.length) {
+            for (const t of supportedTokens) {
+              if (t.address) candidates.push(t.address);
+            }
+          }
+        } catch {
+        }
+        const seen = new Set(candidates.map((a3) => a3.toLowerCase()));
+        for (const addr of _BlockchainClient.FALLBACK_GAS_TOKENS[coinId] || []) {
+          if (!seen.has(addr.toLowerCase())) candidates.push(addr);
+        }
+        if (candidates.length === 0) return void 0;
+        const tokenAssets = candidates.map((addr) => new import_trust_sdk2.Asset.Token(account, addr, import_trust_sdk2.TokenType.Erc20));
+        try {
+          const balances = await import_trust_sdk2.BlockchainService.loadBalances(ct5, tokenAssets);
+          for (let i2 = 0; i2 < balances.length; i2++) {
+            const avail = balances[i2]?.balances?.find(
+              (b3) => b3.type === import_trust_sdk2.BalanceType.Available
+            );
+            if (avail && BigInt(avail.amount || "0") > 0n) {
+              return tokenAssets[i2];
+            }
+          }
+        } catch {
+        }
+        return void 0;
+      }
+      /**
+       * Calculate fee, falling back to EIP-7702 smart wallet sponsorship
+       * when the wallet can't afford native gas (BSC/ETH only).
+       *
+       * Sets is7702=true and energy=tokenAsset on the transaction so the
+       * Trust SDK routes through the Smart Wallet fee service internally.
+       */
+      async calculateFeeWithSponsorship(transaction, account, coinId) {
+        if (!_BlockchainClient.SPONSORABLE_COINS.includes(coinId)) {
+          return { fee: await import_trust_sdk2.BlockchainService.calculateFee(transaction) };
+        }
+        let supports7702 = false;
+        try {
+          const ct5 = requireCoinType(coinId);
+          supports7702 = await import_trust_sdk2.SmartWalletConfig.supports7702(ct5);
+        } catch {
+        }
+        if (!supports7702) {
+          return { fee: await import_trust_sdk2.BlockchainService.calculateFee(transaction) };
+        }
+        const fee = await import_trust_sdk2.BlockchainService.calculateFee(transaction);
+        const feeAmount = BigInt(fee.amount || "0");
+        if (feeAmount <= 0n) return { fee };
+        let canAfford = true;
+        try {
+          const ct5 = requireCoinType(coinId);
+          const energy = new import_trust_sdk2.Asset.Coin(account);
+          const balanceResults = await import_trust_sdk2.BlockchainService.loadBalances(ct5, [energy]);
+          const available = balanceResults[0]?.balances?.find(
+            (b3) => b3.type === import_trust_sdk2.BalanceType.Available
+          );
+          const nativeBalance = BigInt(available?.amount || "0");
+          canAfford = nativeBalance >= feeAmount;
+        } catch {
+          canAfford = false;
+        }
+        if (canAfford) return { fee };
+        const nativeEnergy = new import_trust_sdk2.Asset.Coin(account);
+        let tx7702 = transaction;
+        if (transaction instanceof import_trust_sdk2.TransactionSmartContract) {
+          tx7702 = transaction.copy(void 0, void 0, void 0, void 0, nativeEnergy, true);
+        } else if (transaction instanceof import_trust_sdk2.TransactionTransfer) {
+          tx7702 = transaction.copy(void 0, void 0, void 0, void 0, void 0, void 0, nativeEnergy, true);
+        } else if (transaction instanceof import_trust_sdk2.TransactionTrade) {
+          tx7702 = transaction.copy(void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, nativeEnergy, true);
+        }
+        let baseFee;
+        try {
+          baseFee = await import_trust_sdk2.BlockchainService.calculateFee(tx7702);
+          process.stderr.write(`[7702] baseFee ok, amount:${baseFee.amount} type:${baseFee.constructor?.name}
+`);
+        } catch (e2) {
+          process.stderr.write(`[7702] baseFee FAILED: ${e2 instanceof Error ? e2.message : String(e2)}
+`);
+          return { fee };
+        }
+        const userOpData = baseFee.data;
+        if (!userOpData) {
+          return { fee: baseFee, transaction7702: tx7702 };
+        }
+        const gasToken = await this.findGasToken(account, coinId);
+        if (!gasToken) {
+          return { fee: baseFee, transaction7702: tx7702 };
+        }
+        try {
+          const int8Data = typeof userOpData === "string" ? new Int8Array(Buffer.from(userOpData.replace("0x", ""), "hex")) : new Int8Array(userOpData);
+          const { EthereumAaService } = await import("@trustwallet-trust-sdk/trust-sdk");
+          const paymasters = await EthereumAaService.getFeeQuotes(
+            tx7702,
+            nativeEnergy,
+            int8Data,
+            [gasToken]
+          );
+          if (paymasters && paymasters.length > 0) {
+            const finalFee = await EthereumAaService.simulatePaymasterTransaction(
+              tx7702,
+              paymasters[0]
+            );
+            let txWithToken = transaction;
+            if (transaction instanceof import_trust_sdk2.TransactionSmartContract) {
+              txWithToken = transaction.copy(void 0, void 0, void 0, void 0, gasToken, true);
+            } else if (transaction instanceof import_trust_sdk2.TransactionTransfer) {
+              txWithToken = transaction.copy(void 0, void 0, void 0, void 0, void 0, void 0, gasToken, true);
+            } else if (transaction instanceof import_trust_sdk2.TransactionTrade) {
+              txWithToken = transaction.copy(void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, gasToken, true);
+            }
+            return { fee: finalFee, transaction7702: txWithToken };
+          }
+        } catch {
+        }
+        return { fee: baseFee, transaction7702: tx7702 };
+      }
       getAccountFromSigner(chainKey) {
         if (!this.signer) {
           throw new Error("BlockchainClient requires a signer for this operation");
@@ -14385,8 +14628,8 @@ var require_dataType = __commonJS({
       return types;
     }
     exports2.getSchemaTypes = getSchemaTypes;
-    function getJSONTypes(ts3) {
-      const types = Array.isArray(ts3) ? ts3 : ts3 ? [ts3] : [];
+    function getJSONTypes(ts4) {
+      const types = Array.isArray(ts4) ? ts4 : ts4 ? [ts4] : [];
       if (types.every(rules_1.isJSONType))
         return types;
       throw new Error("type must be JSONType or JSONType[]: " + types.join(","));
@@ -15428,18 +15671,18 @@ var require_validate = __commonJS({
       });
       narrowSchemaTypes(it4, types);
     }
-    function checkMultipleTypes(it4, ts3) {
-      if (ts3.length > 1 && !(ts3.length === 2 && ts3.includes("null"))) {
+    function checkMultipleTypes(it4, ts4) {
+      if (ts4.length > 1 && !(ts4.length === 2 && ts4.includes("null"))) {
         strictTypesError(it4, "use allowUnionTypes to allow union type keyword");
       }
     }
-    function checkKeywordTypes(it4, ts3) {
+    function checkKeywordTypes(it4, ts4) {
       const rules = it4.self.RULES.all;
       for (const keyword in rules) {
         const rule = rules[keyword];
         if (typeof rule == "object" && (0, applicability_1.shouldUseRule)(it4.schema, rule)) {
           const { type } = rule.definition;
-          if (type.length && !type.some((t) => hasApplicableType(ts3, t))) {
+          if (type.length && !type.some((t) => hasApplicableType(ts4, t))) {
             strictTypesError(it4, `missing type "${type.join(",")}" for keyword "${keyword}"`);
           }
         }
@@ -15448,18 +15691,18 @@ var require_validate = __commonJS({
     function hasApplicableType(schTs, kwdT) {
       return schTs.includes(kwdT) || kwdT === "number" && schTs.includes("integer");
     }
-    function includesType(ts3, t) {
-      return ts3.includes(t) || t === "integer" && ts3.includes("number");
+    function includesType(ts4, t) {
+      return ts4.includes(t) || t === "integer" && ts4.includes("number");
     }
     function narrowSchemaTypes(it4, withTypes) {
-      const ts3 = [];
+      const ts4 = [];
       for (const t of it4.dataTypes) {
         if (includesType(withTypes, t))
-          ts3.push(t);
+          ts4.push(t);
         else if (withTypes.includes("integer") && t === "number")
-          ts3.push("integer");
+          ts4.push("integer");
       }
-      it4.dataTypes = ts3;
+      it4.dataTypes = ts4;
     }
     function strictTypesError(it4, msg) {
       const schemaPath = it4.schemaEnv.baseId + it4.errSchemaPath;
@@ -22171,12 +22414,21 @@ function warn(message) {
 function info(message) {
   console.log(import_chalk.default.cyan(message));
 }
+function dim(message) {
+  console.log(import_chalk.default.dim(message));
+}
 
 // src/config-loader.ts
 var import_chalk2 = __toESM(require_source());
 init_dist2();
 init_dist4();
 init_dist();
+var EMBEDDED_NAAS_SESSION_ID = "NDVjMWRjY2MtYTYwNy00NGNhLWIxZGUtMmJiZDIyNmEyODQ4";
+function resolveNaasSessionId() {
+  if (process.env.TWAK_NAAS_SESSION_ID) return process.env.TWAK_NAAS_SESSION_ID;
+  if (EMBEDDED_NAAS_SESSION_ID && !EMBEDDED_NAAS_SESSION_ID.startsWith("__")) return EMBEDDED_NAAS_SESSION_ID;
+  return void 0;
+}
 async function getCredentials() {
   const envAccessId = process.env.TWAK_ACCESS_ID;
   const envSecret = process.env.TWAK_HMAC_SECRET;
@@ -22201,7 +22453,7 @@ async function ensureTrustSDK() {
   await initTrustSDK({
     accessId: creds.accessId,
     hmacSecret: creds.hmacSecret,
-    naasSessionId: process.env.TWAK_NAAS_SESSION_ID
+    naasSessionId: resolveNaasSessionId()
   });
   return creds;
 }
@@ -25065,7 +25317,7 @@ function walk(err, fn2) {
 
 // ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/cryptoNode.js
 var nc = __toESM(require("crypto"), 1);
-var crypto3 = nc && typeof nc === "object" && "webcrypto" in nc ? nc.webcrypto : nc && typeof nc === "object" && "randomBytes" in nc ? nc : void 0;
+var crypto4 = nc && typeof nc === "object" && "webcrypto" in nc ? nc.webcrypto : nc && typeof nc === "object" && "randomBytes" in nc ? nc : void 0;
 
 // ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/utils.js
 function isBytes(a3) {
@@ -25162,11 +25414,11 @@ function createHasher(hashCons) {
   return hashC;
 }
 function randomBytes2(bytesLength = 32) {
-  if (crypto3 && typeof crypto3.getRandomValues === "function") {
-    return crypto3.getRandomValues(new Uint8Array(bytesLength));
+  if (crypto4 && typeof crypto4.getRandomValues === "function") {
+    return crypto4.getRandomValues(new Uint8Array(bytesLength));
   }
-  if (crypto3 && typeof crypto3.randomBytes === "function") {
-    return Uint8Array.from(crypto3.randomBytes(bytesLength));
+  if (crypto4 && typeof crypto4.randomBytes === "function") {
+    return Uint8Array.from(crypto4.randomBytes(bytesLength));
   }
   throw new Error("crypto.getRandomValues must be defined");
 }
@@ -38951,6 +39203,18 @@ ${qr3}`;
         return [{ chainKey, chain: chain2, address: addrEntry.address }];
       });
       const suppress = (fn2) => fn2();
+      const pMap = async (items, fn2, concurrency) => {
+        const results = new Array(items.length);
+        let idx = 0;
+        const run = async () => {
+          while (idx < items.length) {
+            const i2 = idx++;
+            results[i2] = await fn2(items[i2]);
+          }
+        };
+        await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => run()));
+        return results;
+      };
       const toHuman = (raw, decimals) => {
         const big = BigInt(raw);
         const div = 10n ** BigInt(decimals);
@@ -38961,14 +39225,14 @@ ${qr3}`;
       };
       const holdingsAssets = chainEntries.map(({ chain: chain2, address }) => ({ coin: chain2.coinId, address }));
       const [nativeResults, holdings] = await Promise.all([
-        Promise.all(chainEntries.map(async ({ chainKey, chain: chain2, address }) => {
+        pMap(chainEntries, async ({ chainKey, chain: chain2, address }) => {
           try {
             const balance = await suppress(() => blockchainClient.getBalance(`c${chain2.coinId}`, address));
             return { chainKey, chain: chain2, address, balance };
           } catch {
             return { chainKey, chain: chain2, address, balance: null };
           }
-        })),
+        }, 5),
         (async () => {
           try {
             return await new SecurityService2(httpClient).getTokenHoldings(holdingsAssets);
@@ -38999,7 +39263,7 @@ ${qr3}`;
           if (t.contract) tokenJobs.push({ chainKey, coinId: chain2.coinId, address, ...t });
         }
       }
-      const tokenBalances = await Promise.all(tokenJobs.map(async (job) => {
+      const tokenBalances = await pMap(tokenJobs, async (job) => {
         const fallback = job.balance ?? "0";
         try {
           const assetId = `c${job.coinId}_t${job.contract}`;
@@ -39008,7 +39272,7 @@ ${qr3}`;
         } catch {
           return { ...job, rawBalance: fallback };
         }
-      }));
+      }, 5);
       const nativeAssetIds = nativeResults.map(({ chain: chain2 }) => `c${chain2.coinId}`);
       const nonZeroTokens = tokenBalances.filter((t) => {
         const dec = t.decimals ?? 18;
@@ -39256,6 +39520,108 @@ var SwapClient = class {
     }
   }
 };
+var SwapExecutor = class {
+  constructor(swapClient, walletProvider, options = {}) {
+    this.swapClient = swapClient;
+    this.walletProvider = walletProvider;
+    this.options = options;
+  }
+  log(msg) {
+    this.options.onStatus?.(msg);
+  }
+  async execute(params) {
+    const address = await this.walletProvider.getAddress(params.fromChain);
+    const fromTokenInfo = resolveToken(params.fromToken, params.fromChain);
+    const toTokenInfo = resolveToken(params.toToken, params.toChain);
+    const parsedAmount = parseAmount(params.amount, fromTokenInfo.decimals);
+    const fromCoinId = getChainById(params.fromChain)?.coinId;
+    const toCoinId = getChainById(params.toChain)?.coinId;
+    const domains = this.options.amberDomains || /* @__PURE__ */ new Map();
+    let destinationAddress;
+    if (params.toChain !== params.fromChain) {
+      destinationAddress = await this.walletProvider.getAddress(params.toChain);
+    }
+    const quote = await this.swapClient.getQuote({
+      fromChain: params.fromChain,
+      fromToken: fromTokenInfo.address,
+      toChain: params.toChain,
+      toToken: toTokenInfo.address,
+      amount: parsedAmount,
+      walletAddress: address,
+      destinationAddress,
+      slippage: params.slippage,
+      fromDomainId: fromCoinId ? domains.get(fromCoinId) : void 0,
+      toDomainId: toCoinId ? domains.get(toCoinId) : void 0
+    });
+    if (quote.routes.length === 0) {
+      return { success: false, route: { id: "", steps: [], warnings: ["No routes found"], expirationDate: "", totalOutput: "0" }, error: "No swap routes found" };
+    }
+    const route = quote.routes[0];
+    const firstStep = route.steps[0];
+    const lastStep = route.steps[route.steps.length - 1];
+    const inputAmt = formatAmount(firstStep.from.amount, firstStep.from.asset.metadata.decimals);
+    const outputAmt = formatAmount(lastStep.to.amount, lastStep.to.asset.metadata.decimals);
+    this.log(`Swapping ${inputAmt} ${firstStep.from.asset.metadata.symbol} -> ${outputAmt} ${lastStep.to.asset.metadata.symbol} via ${route.steps.map((s2) => s2.provider.name).join(" -> ")}`);
+    const chainConfig = getChainById(params.fromChain);
+    const transactions = await this.swapClient.getSwapTransactions(route);
+    try {
+      let txHash = "";
+      for (const txData of transactions) {
+        const txType = txData.transaction.type;
+        const isApproval = txType === "approval" || txType === "revokeApproval";
+        if (isApproval) {
+          this.log(txType === "revokeApproval" ? "Revoking prior approval..." : "Sending token approval...");
+        }
+        txHash = await this.sendTransaction(txData, chainConfig, params.fromChain);
+        this.log(`${isApproval ? "Approval" : "Swap"} tx: ${getExplorerTxUrl(params.fromChain, txHash)}`);
+        await this.pollForConfirmation(params.fromChain, address, txHash, isApproval ? 6e4 : 12e4);
+      }
+      return {
+        success: true,
+        txHash,
+        route,
+        explorerUrl: getExplorerTxUrl(params.fromChain, txHash)
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "Unknown error";
+      return { success: false, route, error: msg };
+    }
+  }
+  async sendTransaction(txData, chainConfig, fromChain) {
+    if (chainConfig?.namespace === "solana" && txData.transaction.solanaTx) {
+      return this.walletProvider.sendTransaction({
+        chainId: `solana:${chainConfig.chainId}`,
+        to: "",
+        data: txData.transaction.solanaTx.serializedMessage
+      });
+    } else if (txData.transaction.evmTx) {
+      return this.walletProvider.sendTransaction({
+        chainId: `eip155:${chainConfig?.chainId || "1"}`,
+        to: txData.transaction.evmTx.to,
+        data: txData.transaction.evmTx.data,
+        value: txData.transaction.evmTx.value || "0x0"
+      });
+    }
+    throw new Error(`No transaction data returned for swap step on ${fromChain}`);
+  }
+  async pollForConfirmation(chainKey, address, hash, timeoutMs) {
+    const blockchainClient = this.walletProvider.getBlockchainClient?.();
+    if (!blockchainClient) return;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      await new Promise((r3) => setTimeout(r3, 2e3));
+      try {
+        const status = await blockchainClient.findTransactionStatus(chainKey, address, hash);
+        if (status.confirmed) return;
+        if (status.failed) throw new Error(`Transaction failed: ${status.error || "unknown error"}`);
+      } catch (e2) {
+        const err = e2 instanceof Error ? e2 : new Error(String(e2));
+        if (err.message.startsWith("Transaction failed")) throw err;
+      }
+    }
+    throw new Error(`Transaction ${hash} was not confirmed within ${Math.round(timeoutMs / 1e3)}s`);
+  }
+};
 
 // src/commands/transfer.ts
 var DEFAULT_MAX_TRANSFER_USD = 1e4;
@@ -39513,6 +39879,55 @@ function registerSwapCommand(program3) {
       const transactions = await swapClient.getSwapTransactions(route);
       let txHash = "";
       const blockchainClient = provider.getBlockchainClient();
+      const hasApprovalTx = transactions.some((t) => t.transaction.type === "approval");
+      if (!hasApprovalTx && chainConfig?.isEVM) {
+        const stepApproval = firstStep.approval;
+        if (stepApproval && stepApproval.operatorAddress) {
+          const fromAssetAddr = firstStep.from.asset.address;
+          const isNative = !fromAssetAddr || fromAssetAddr === NATIVE_TOKEN_ADDRESS;
+          if (!isNative && chainConfig.coinId) {
+            const assetId = formatTokenId(chainConfig.coinId, fromAssetAddr);
+            try {
+              const allowance = await blockchainClient.getAllowance({
+                assetId,
+                owner: walletAddress,
+                spender: stepApproval.operatorAddress
+              });
+              const requiredAmount = BigInt(stepApproval.minAmount || parsedAmount);
+              if (allowance < requiredAmount) {
+                info("Sending token approval...");
+                const hdWallet = provider.getSigner().getHDWallet();
+                const approveResult = await blockchainClient.approve({
+                  assetId,
+                  spender: stepApproval.operatorAddress,
+                  amount: requiredAmount.toString(),
+                  hdWallet
+                });
+                info(`Approval tx: ${getExplorerTxUrl(fromChain, approveResult.hash)}`);
+                const approvalDeadline = Date.now() + 6e4;
+                while (Date.now() < approvalDeadline) {
+                  await new Promise((r3) => setTimeout(r3, 2e3));
+                  try {
+                    const status = await blockchainClient.findTransactionStatus(fromChain, walletAddress, approveResult.hash);
+                    if (status.confirmed) break;
+                    if (status.failed) throw new Error("Approval transaction failed");
+                  } catch (e2) {
+                    const err = e2 instanceof Error ? e2 : new Error(String(e2));
+                    if (err.message.startsWith("Approval transaction failed")) throw err;
+                  }
+                }
+              }
+            } catch (e2) {
+              const msg = e2 instanceof Error ? e2.message : String(e2);
+              if (msg.includes("insufficient funds")) {
+                throw new Error(`Insufficient ${chainConfig?.symbol || "native token"} for approval gas. Fund your wallet with ${chainConfig?.symbol || "native tokens"} first.`);
+              }
+              if (msg.includes("failed")) throw e2;
+              info(`Warning: could not check/send approval: ${msg}`);
+            }
+          }
+        }
+      }
       const pollForConfirmation = async (hash, timeoutMs) => {
         const deadline = Date.now() + timeoutMs;
         while (Date.now() < deadline) {
@@ -39585,10 +40000,11 @@ init_dist2();
 init_dist4();
 function registerErc20Command(program3) {
   const erc20 = program3.command("erc20").description("ERC-20 token operations");
-  erc20.command("approve").description("Approve a spender for token spending").requiredOption("--token <assetId>", "Token asset ID (e.g., c60_t0xA0b8...)").requiredOption("--spender <address>", "Spender address").requiredOption("--amount <n>", 'Amount to approve (in smallest unit, or "unlimited")').requiredOption("--password <password>", "Wallet password").option("--confirm-unlimited", "Required when --amount unlimited to acknowledge the security risk").option("--json", "JSON output").action(async (opts) => {
+  erc20.command("approve").description("Approve a spender for token spending").requiredOption("--token <assetId>", "Token asset ID (e.g., c60_t0xA0b8...)").requiredOption("--spender <address>", "Spender address").requiredOption("--amount <n>", 'Amount to approve (in smallest unit, or "unlimited")').option("--password <password>", "Wallet password (falls back to keychain / TWAK_WALLET_PASSWORD)").option("--confirm-unlimited", "Required when --amount unlimited to acknowledge the security risk").option("--json", "JSON output").action(async (opts) => {
     try {
       await ensureTrustSDK();
-      const provider = await AgentWalletProvider.fromStorage(opts.password);
+      const password = await resolvePassword(opts);
+      const provider = await AgentWalletProvider.fromStorage(password);
       const { coinId, contractAddress } = parseTokenId(opts.token);
       if (!contractAddress) {
         const msg = "Cannot approve native tokens. Provide an ERC-20 asset ID (e.g., c60_t0xA0b8...)";
@@ -39648,10 +40064,11 @@ function registerErc20Command(program3) {
     }
     process.exit();
   });
-  erc20.command("revoke").description("Revoke token approval (set allowance to 0)").requiredOption("--token <assetId>", "Token asset ID (e.g., c60_t0xA0b8...)").requiredOption("--spender <address>", "Spender address to revoke").requiredOption("--password <password>", "Wallet password").option("--json", "JSON output").action(async (opts) => {
+  erc20.command("revoke").description("Revoke token approval (set allowance to 0)").requiredOption("--token <assetId>", "Token asset ID (e.g., c60_t0xA0b8...)").requiredOption("--spender <address>", "Spender address to revoke").option("--password <password>", "Wallet password (falls back to keychain / TWAK_WALLET_PASSWORD)").option("--json", "JSON output").action(async (opts) => {
     try {
       await ensureTrustSDK();
-      const provider = await AgentWalletProvider.fromStorage(opts.password);
+      const password = await resolvePassword(opts);
+      const provider = await AgentWalletProvider.fromStorage(password);
       const { coinId, contractAddress } = parseTokenId(opts.token);
       if (!contractAddress) {
         const msg = "Cannot revoke approval for native tokens. Provide an ERC-20 asset ID.";
@@ -39739,7 +40156,7 @@ function resolveTokenLabel(tokenId) {
 function registerAlertCommand(program3) {
   const alert = program3.command("alert").description("Manage price alerts");
   const alertStore = new AlertStore();
-  alert.command("create").description("Create a price alert").requiredOption("--token <tokenId>", "Token ID (e.g., c60, c20000714)").requiredOption("--chain <key>", "Chain key").option("--above <price>", "Alert when price goes above").option("--below <price>", "Alert when price goes below").option("--json", "JSON output").action(async (opts) => {
+  alert.command("create").description("Create a price alert").requiredOption("--token <tokenId>", "Token symbol (e.g., ETH, BTC) or asset ID (e.g., c60)").option("--chain <key>", "Chain key (auto-detected for native tokens like ETH, BNB, SOL)").option("--above <price>", "Alert when price goes above").option("--below <price>", "Alert when price goes below").option("--json", "JSON output").action(async (opts) => {
     const aboveProvided = typeof opts.above !== "undefined";
     const belowProvided = typeof opts.below !== "undefined";
     if (aboveProvided && belowProvided || !aboveProvided && !belowProvided) {
@@ -39756,23 +40173,73 @@ function registerAlertCommand(program3) {
       process.exitCode = 1;
       return;
     }
-    if (!isChainSupported(opts.chain)) {
-      error(`Unknown chain: ${opts.chain}. Run \`twak chains\` to see supported chains.`);
-      if (opts.json) output({ error: `Unknown chain: ${opts.chain}` }, true);
-      process.exitCode = 1;
-      return;
-    }
+    let resolvedTokenId = opts.token;
+    let resolvedChain = opts.chain;
     try {
       parseTokenId(opts.token);
+      if (!resolvedChain) {
+        resolvedChain = tokenIdToChain(opts.token);
+        if (!resolvedChain) {
+          error("Could not detect chain from asset ID. Provide --chain.");
+          if (opts.json) output({ error: "Chain required for this asset ID" }, true);
+          process.exitCode = 1;
+          return;
+        }
+      }
     } catch {
-      error(`Invalid token ID format: ${opts.token}. Expected format: c60 or c60_t0xABC...`);
-      if (opts.json) output({ error: `Invalid token ID: ${opts.token}` }, true);
+      const sym = opts.token.toUpperCase();
+      const NATIVE_SYMBOLS2 = {
+        ETH: "ethereum",
+        BNB: "bsc",
+        SOL: "solana",
+        BTC: "bitcoin",
+        MATIC: "polygon",
+        AVAX: "avalanche",
+        FTM: "fantom",
+        TRX: "tron",
+        DOT: "polkadot",
+        ATOM: "cosmos",
+        NEAR: "near",
+        APT: "aptos",
+        TON: "ton",
+        SUI: "sui",
+        LTC: "litecoin",
+        DOGE: "dogecoin",
+        CELO: "celo",
+        S: "sonic"
+      };
+      if (!resolvedChain && NATIVE_SYMBOLS2[sym]) {
+        resolvedChain = NATIVE_SYMBOLS2[sym];
+      }
+      if (!resolvedChain) {
+        error(`Cannot resolve "${opts.token}" without --chain. Provide --chain or use asset ID format (c60).`);
+        if (opts.json) output({ error: "Chain required" }, true);
+        process.exitCode = 1;
+        return;
+      }
+      const chain2 = getChainById(resolvedChain);
+      if (!chain2) {
+        error(`Unknown chain: ${resolvedChain}. Run \`twak chains\` to see supported chains.`);
+        if (opts.json) output({ error: `Unknown chain: ${resolvedChain}` }, true);
+        process.exitCode = 1;
+        return;
+      }
+      const resolved = resolveToken(sym, resolvedChain);
+      if (resolved.address === NATIVE_TOKEN_ADDRESS || resolved.address === sym) {
+        resolvedTokenId = formatTokenId(chain2.coinId);
+      } else {
+        resolvedTokenId = formatTokenId(chain2.coinId, resolved.address);
+      }
+    }
+    if (!isChainSupported(resolvedChain)) {
+      error(`Unknown chain: ${resolvedChain}. Run \`twak chains\` to see supported chains.`);
+      if (opts.json) output({ error: `Unknown chain: ${resolvedChain}` }, true);
       process.exitCode = 1;
       return;
     }
     const record2 = await alertStore.create({
-      tokenId: opts.token,
-      chainKey: opts.chain,
+      tokenId: resolvedTokenId,
+      chainKey: resolvedChain,
       condition,
       targetPrice
     });
@@ -45312,6 +45779,171 @@ var MarketActionProvider = class extends ActionProvider {
     };
   }
 };
+var AutomateActionProvider = class extends ActionProvider {
+  constructor(automationStore, swapClient, walletProvider, blockchainClient) {
+    super();
+    this.automationStore = automationStore;
+    this.swapClient = swapClient;
+    this.walletProvider = walletProvider;
+    this.blockchainClient = blockchainClient;
+  }
+  name = "automate";
+  description = "DCA and limit-order automation for recurring and conditional swaps";
+  getActions() {
+    return [
+      this.createAutomation(),
+      this.listAutomations(),
+      this.deleteAutomation(),
+      this.runAutomationNow()
+    ];
+  }
+  createAutomation() {
+    return {
+      name: "create_automation",
+      description: "Create a DCA (recurring buy) or limit order (buy/sell when price condition is met)",
+      schema: external_exports.object({
+        type: external_exports.enum(["dca", "limit"]).describe("Automation type: dca (recurring) or limit (price trigger)"),
+        fromToken: external_exports.string().describe("Source token symbol or address"),
+        toToken: external_exports.string().describe("Destination token symbol or address"),
+        chain: external_exports.string().default("ethereum").describe("Chain name"),
+        amount: external_exports.string().describe("Amount of fromToken per execution"),
+        intervalMs: external_exports.coerce.number().optional().describe("Interval in milliseconds for DCA (e.g., 86400000 for daily)"),
+        targetPrice: external_exports.coerce.number().optional().describe("Target price in USD for limit orders"),
+        condition: external_exports.enum(["above", "below"]).optional().describe("Price condition for limit orders")
+      }),
+      invoke: async (_ctx, input) => {
+        if (input.type === "dca" && !input.intervalMs) {
+          return { success: false, error: "DCA automations require intervalMs" };
+        }
+        if (input.type === "limit" && (input.targetPrice == null || !input.condition)) {
+          return { success: false, error: "Limit orders require targetPrice and condition" };
+        }
+        const record2 = await this.automationStore.create({
+          type: input.type,
+          fromToken: input.fromToken,
+          toToken: input.toToken,
+          chain: input.chain,
+          amount: input.amount,
+          intervalMs: input.intervalMs,
+          targetPrice: input.targetPrice,
+          condition: input.condition
+        });
+        const summary = input.type === "dca" ? `DCA: ${input.amount} ${input.fromToken} \u2192 ${input.toToken} every ${Math.round((input.intervalMs || 0) / 36e5)}h` : `Limit: swap ${input.amount} ${input.fromToken} \u2192 ${input.toToken} when price ${input.condition} $${input.targetPrice}`;
+        return { success: true, id: record2.id, summary, record: record2 };
+      }
+    };
+  }
+  listAutomations() {
+    return {
+      name: "list_automations",
+      description: "List all active automation rules (DCA and limit orders)",
+      schema: external_exports.object({
+        activeOnly: external_exports.boolean().optional().default(true).describe("Only show active automations")
+      }),
+      invoke: async (_ctx, input) => {
+        const all = await this.automationStore.list();
+        const automations = input.activeOnly ? all.filter((a3) => a3.active) : all;
+        return { success: true, count: automations.length, automations };
+      }
+    };
+  }
+  deleteAutomation() {
+    return {
+      name: "delete_automation",
+      description: "Delete (deactivate) an automation rule",
+      schema: external_exports.object({
+        id: external_exports.string().describe("Automation ID to delete")
+      }),
+      invoke: async (_ctx, input) => {
+        const deleted = await this.automationStore.delete(input.id);
+        return deleted ? { success: true, message: `Automation ${input.id} deleted` } : { success: false, error: `Automation ${input.id} not found` };
+      }
+    };
+  }
+  async sendSwapTx(txData, chainConfig, signer) {
+    if (chainConfig?.namespace === "solana" && txData.transaction.solanaTx) {
+      return signer.sendTransaction({
+        chainId: `solana:${chainConfig.chainId}`,
+        to: "",
+        data: txData.transaction.solanaTx.serializedMessage
+      });
+    } else if (txData.transaction.evmTx) {
+      return signer.sendTransaction({
+        chainId: `eip155:${chainConfig?.chainId || "1"}`,
+        to: txData.transaction.evmTx.to,
+        data: txData.transaction.evmTx.data,
+        value: txData.transaction.evmTx.value || "0x0"
+      });
+    }
+    throw new Error("No transaction data returned for this swap step");
+  }
+  async pollConfirmation(chainKey, address, hash, timeoutMs) {
+    if (!this.blockchainClient) return;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      await new Promise((r3) => setTimeout(r3, 2e3));
+      try {
+        const status = await this.blockchainClient.findTransactionStatus(chainKey, address, hash);
+        if (status.confirmed) return;
+        if (status.failed) throw new Error(`Transaction failed: ${status.error || "unknown error"}`);
+      } catch (e2) {
+        const err = e2 instanceof Error ? e2 : new Error(String(e2));
+        if (err.message.startsWith("Transaction failed")) throw err;
+      }
+    }
+    throw new Error(`Transaction ${hash} was not confirmed within ${Math.round(timeoutMs / 1e3)}s`);
+  }
+  runAutomationNow() {
+    return {
+      name: "run_automation_now",
+      description: "Manually execute an automation immediately (runs the swap now regardless of schedule)",
+      schema: external_exports.object({
+        id: external_exports.string().describe("Automation ID to run")
+      }),
+      invoke: async (_ctx, input) => {
+        if (!this.walletProvider || !this.swapClient) {
+          return { success: false, error: "Agent wallet and swap client required to execute automation" };
+        }
+        const record2 = await this.automationStore.getById(input.id);
+        if (!record2) return { success: false, error: `Automation ${input.id} not found` };
+        if (!record2.active) return { success: false, error: `Automation ${input.id} is inactive` };
+        const fromTokenInfo = resolveToken(record2.fromToken, record2.chain);
+        const toTokenInfo = resolveToken(record2.toToken, record2.chain);
+        const parsedAmount = parseAmount(record2.amount, fromTokenInfo.decimals);
+        const address = await this.walletProvider.getAddress(record2.chain);
+        const quote = await this.swapClient.getQuote({
+          fromChain: record2.chain,
+          fromToken: fromTokenInfo.address,
+          toChain: record2.chain,
+          toToken: toTokenInfo.address,
+          amount: parsedAmount,
+          walletAddress: address
+        });
+        if (quote.routes.length === 0) {
+          return { success: false, error: "No swap routes found" };
+        }
+        const route = quote.routes[0];
+        const chainConfig = getChainById(record2.chain);
+        const transactions = await this.swapClient.getSwapTransactions(route);
+        let txHash = "";
+        for (const txData of transactions) {
+          txHash = await this.sendSwapTx(txData, chainConfig, this.walletProvider);
+          const isApproval = txData.transaction.type === "approval" || txData.transaction.type === "revokeApproval";
+          await this.pollConfirmation(record2.chain, address, txHash, isApproval ? 6e4 : 12e4);
+        }
+        await this.automationStore.update(record2.id, { lastRunAt: (/* @__PURE__ */ new Date()).toISOString() });
+        const explorerUrl = getExplorerTxUrl(record2.chain, txHash);
+        return {
+          success: true,
+          txHash,
+          automationId: record2.id,
+          swapped: `${record2.amount} ${record2.fromToken} \u2192 ${record2.toToken}`,
+          explorer: explorerUrl || void 0
+        };
+      }
+    };
+  }
+};
 
 // src/commands/serve.ts
 init_dist();
@@ -54110,6 +54742,7 @@ function registerServeCommand(program3) {
     const client = await getClient();
     const swapClient = new SwapClient(client);
     const alertStore = new AlertStore();
+    const automationStore = new AutomationStore();
     const blockchainClient = new BlockchainClient();
     let agentWallet;
     try {
@@ -54149,6 +54782,7 @@ function registerServeCommand(program3) {
     registry2.register(new AgentWalletActionProvider(blockchainClient));
     registry2.register(new TokenActionProvider(blockchainClient, agentWallet));
     registry2.register(new MarketActionProvider());
+    registry2.register(new AutomateActionProvider(automationStore, swapClient, walletProvider, blockchainClient));
     const context = {
       httpClient: client
     };
@@ -54180,6 +54814,221 @@ function registerServeCommand(program3) {
   });
 }
 
+// src/commands/automate.ts
+init_dist();
+init_dist2();
+function parseInterval(value) {
+  const match = value.match(/^(\d+(?:\.\d+)?)\s*(s|m|h)?$/i);
+  if (!match) return null;
+  const num = parseFloat(match[1]);
+  if (isNaN(num)) return null;
+  const unit = (match[2] || "s").toLowerCase();
+  if (unit === "s") return num * 1e3;
+  if (unit === "m") return num * 6e4;
+  if (unit === "h") return num * 36e5;
+  return num * 1e3;
+}
+function formatInterval(ms3) {
+  if (ms3 >= 36e5) return `${ms3 / 36e5}h`;
+  if (ms3 >= 6e4) return `${ms3 / 6e4}m`;
+  return `${ms3 / 1e3}s`;
+}
+function formatRelativeTime(diffMs) {
+  const absDiff = Math.abs(diffMs);
+  let value;
+  if (absDiff < 6e4) {
+    value = `${Math.round(absDiff / 1e3)}s`;
+  } else if (absDiff < 36e5) {
+    value = `${Math.round(absDiff / 6e4)}m`;
+  } else {
+    value = `${Math.round(absDiff / 36e5)}h`;
+  }
+  if (diffMs <= 0) return "overdue";
+  return `in ${value}`;
+}
+function formatTimeAgo(isoDate) {
+  const diffMs = Date.now() - new Date(isoDate).getTime();
+  const absDiff = Math.abs(diffMs);
+  if (absDiff < 6e4) return `${Math.round(absDiff / 1e3)}s ago`;
+  if (absDiff < 36e5) return `${Math.round(absDiff / 6e4)}m ago`;
+  return `${Math.round(absDiff / 36e5)}h ago`;
+}
+function registerAutomateCommand(program3) {
+  const automate = program3.command("automate").description("Manage DCA and limit order automations");
+  automate.command("add").description("Create a DCA or limit order automation").requiredOption("--from <token>", "Source token (e.g., USDC)").requiredOption("--to <token>", "Destination token (e.g., ETH)").option("--chain <chain>", "Chain", "ethereum").requiredOption("--amount <n>", "Amount of source token per run").option("--interval <duration>", "DCA interval \u2014 e.g. 30s, 5m, 1h (creates DCA automation)").option("--price <usd>", "Target price in USD (creates limit order)").option("--condition <cond>", "Price condition: above or below", "below").option("--max-runs <n>", "Stop after N executions").option("--expires <date>", "Expiry date (ISO 8601, e.g. 2026-04-01)").option("--json", "JSON output").action(async (opts) => {
+    try {
+      if (!opts.interval && !opts.price) {
+        error("Provide --interval (DCA) or --price (limit order)");
+        process.exitCode = 1;
+        return;
+      }
+      const amount = parseFloat(opts.amount);
+      if (isNaN(amount) || amount <= 0) {
+        error("Amount must be a positive number");
+        process.exitCode = 1;
+        return;
+      }
+      if (!isChainSupported(opts.chain)) {
+        error(`Unsupported chain: ${opts.chain}. Run 'twak chains' to list supported chains.`);
+        process.exitCode = 1;
+        return;
+      }
+      let intervalMs;
+      if (opts.interval) {
+        const parsed = parseInterval(opts.interval);
+        if (parsed === null || parsed < 5e3) {
+          error("Interval must be at least 5s (e.g. 30s, 5m, 1h)");
+          process.exitCode = 1;
+          return;
+        }
+        intervalMs = parsed;
+      }
+      const maxRuns = opts.maxRuns ? parseInt(opts.maxRuns) : void 0;
+      if (maxRuns !== void 0 && (isNaN(maxRuns) || maxRuns < 1)) {
+        error("--max-runs must be a positive integer");
+        process.exitCode = 1;
+        return;
+      }
+      let expiresAt;
+      if (opts.expires) {
+        const d3 = new Date(opts.expires);
+        if (isNaN(d3.getTime())) {
+          error("--expires must be a valid date (e.g. 2026-04-01)");
+          process.exitCode = 1;
+          return;
+        }
+        expiresAt = d3.toISOString();
+      }
+      const store = new AutomationStore();
+      const record2 = await store.create({
+        type: opts.interval ? "dca" : "limit",
+        fromToken: opts.from,
+        toToken: opts.to,
+        chain: opts.chain,
+        amount: opts.amount,
+        intervalMs,
+        targetPrice: opts.price ? parseFloat(opts.price) : void 0,
+        condition: opts.price ? opts.condition : void 0,
+        maxRuns,
+        runCount: 0,
+        expiresAt
+      });
+      success("Automation created!");
+      if (opts.interval && intervalMs) {
+        info(`DCA: ${opts.amount} ${opts.from} \u2192 ${opts.to} every ${formatInterval(intervalMs)} on ${opts.chain}`);
+      } else {
+        info(`Limit: swap ${opts.amount} ${opts.from} \u2192 ${opts.to} when price ${opts.condition} $${opts.price} on ${opts.chain}`);
+      }
+      output(record2, opts.json);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      error(msg);
+      if (opts.json) output({ error: msg }, true);
+      process.exitCode = 1;
+    }
+  });
+  automate.command("list").description("List active automations").option("--all", "Include inactive automations").option("--json", "JSON output").action(async (opts) => {
+    try {
+      const store = new AutomationStore();
+      const all = await store.list();
+      const records = opts.all ? all : all.filter((a3) => a3.active);
+      if (opts.json) {
+        const enriched = records.map((r3) => {
+          const nextRunAt = r3.type === "dca" && r3.intervalMs ? r3.lastRunAt ? new Date(new Date(r3.lastRunAt).getTime() + r3.intervalMs).toISOString() : (/* @__PURE__ */ new Date()).toISOString() : null;
+          const nextRunIn = nextRunAt ? formatRelativeTime(new Date(nextRunAt).getTime() - Date.now()) : null;
+          return { ...r3, nextRunAt, nextRunIn };
+        });
+        output(enriched, true);
+        return;
+      }
+      if (records.length === 0) {
+        info("No automations found.");
+        return;
+      }
+      for (const r3 of records) {
+        const tag = r3.id.slice(0, 8);
+        const label = r3.type.toUpperCase();
+        const pair = `${r3.amount} ${r3.fromToken}\u2192${r3.toToken} (${r3.chain})`;
+        if (r3.type === "dca") {
+          const interval = formatInterval(r3.intervalMs || 0);
+          const lastPart = r3.lastRunAt ? `last: ${formatTimeAgo(r3.lastRunAt)}` : "never run";
+          let nextPart;
+          if (!r3.intervalMs) {
+            nextPart = "next: unknown";
+          } else if (!r3.lastRunAt) {
+            nextPart = "next: now";
+          } else {
+            const nextAt = new Date(r3.lastRunAt).getTime() + r3.intervalMs;
+            nextPart = `next: ${formatRelativeTime(nextAt - Date.now())}`;
+          }
+          console.log(`[${tag}] ${label} ${pair} every ${interval} \u2014 ${lastPart}, ${nextPart}`);
+        } else {
+          const cond = `${r3.fromToken} ${r3.condition} $${r3.targetPrice}`;
+          console.log(`[${tag}] ${label} ${pair} when ${cond} \u2014 waiting`);
+        }
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      error(msg);
+      if (opts.json) output({ error: msg }, true);
+      process.exitCode = 1;
+    }
+  });
+  automate.command("delete <id>").description("Delete an automation by ID").option("--json", "JSON output").action(async (id, opts) => {
+    try {
+      const store = new AutomationStore();
+      const deleted = await store.delete(id);
+      if (deleted) {
+        success(`Automation ${id} deleted`);
+      } else {
+        error(`Automation ${id} not found`);
+        process.exitCode = 1;
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      error(msg);
+      if (opts.json) output({ error: msg }, true);
+      process.exitCode = 1;
+    }
+  });
+  automate.command("pause <id>").description("Pause an automation").option("--json", "JSON output").action(async (id, opts) => {
+    try {
+      const store = new AutomationStore();
+      const updated = await store.update(id, { active: false });
+      if (updated) {
+        success(`Automation ${id} paused`);
+        output(updated, opts.json);
+      } else {
+        error(`Automation ${id} not found`);
+        process.exitCode = 1;
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      error(msg);
+      if (opts.json) output({ error: msg }, true);
+      process.exitCode = 1;
+    }
+  });
+  automate.command("resume <id>").description("Resume a paused automation").option("--json", "JSON output").action(async (id, opts) => {
+    try {
+      const store = new AutomationStore();
+      const updated = await store.update(id, { active: true });
+      if (updated) {
+        success(`Automation ${id} resumed`);
+        output(updated, opts.json);
+      } else {
+        error(`Automation ${id} not found`);
+        process.exitCode = 1;
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      error(msg);
+      if (opts.json) output({ error: msg }, true);
+      process.exitCode = 1;
+    }
+  });
+}
+
 // src/commands/skill.ts
 var import_fs = require("fs");
 var import_path = require("path");
@@ -54397,12 +55246,12 @@ Confirm? [y/N] `,
 var fs6 = __toESM(require("fs"));
 var os4 = __toESM(require("os"));
 var path4 = __toESM(require("path"));
-var crypto5 = __toESM(require("crypto"));
+var crypto6 = __toESM(require("crypto"));
 
 // package.json
 var package_default = {
   name: "@trustwallet/cli",
-  version: "0.6.10",
+  version: "0.7.0",
   description: "TWAK CLI \u2014 command-line interface for Trust Wallet Agent Kit",
   main: "dist/index.js",
   types: "dist/index.d.ts",
@@ -54502,7 +55351,7 @@ function getUserId() {
     if (fs6.existsSync(ID_FILE)) return fs6.readFileSync(ID_FILE, "utf-8").trim();
   } catch (_e6) {
   }
-  const id = crypto5.randomUUID();
+  const id = crypto6.randomUUID();
   try {
     fs6.mkdirSync(CONFIG_DIR, { recursive: true });
     fs6.writeFileSync(ID_FILE, id);
@@ -54559,6 +55408,200 @@ function registerTelemetryCommand(program3) {
   });
 }
 
+// src/commands/watch.ts
+init_dist2();
+init_dist();
+init_dist4();
+function ts3() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
+}
+function parseInterval2(value) {
+  const match = value.match(/^(\d+(?:\.\d+)?)\s*(s|m|h)?$/i);
+  if (!match) return null;
+  const num = parseFloat(match[1]);
+  if (isNaN(num)) return null;
+  const unit = (match[2] || "s").toLowerCase();
+  if (unit === "m") return num * 60;
+  if (unit === "h") return num * 3600;
+  return num;
+}
+function registerWatchCommand(program3) {
+  program3.command("watch").description("Background watcher \u2014 polls prices to trigger alerts and execute DCA/limit automations").option("--interval <duration>", "Poll interval \u2014 e.g. 30s, 5m, 1h, or plain number (seconds)", "60").option("--password <password>", "Wallet password for executing swaps").option("--auto-lock <minutes>", "Auto-lock wallet after N minutes of inactivity").option("--dry-run", "Check conditions without executing swaps").option("--json", "JSON output per tick").action(async (opts) => {
+    const intervalSec = parseInterval2(opts.interval);
+    if (intervalSec === null || intervalSec < 5) {
+      error("Interval must be at least 5 seconds (e.g. 30s, 5m, 1h)");
+      process.exitCode = 1;
+      return;
+    }
+    let client;
+    let swapClient;
+    let provider = null;
+    let executor = null;
+    let amberDomains = /* @__PURE__ */ new Map();
+    try {
+      client = await getClient();
+      swapClient = new SwapClient(client);
+      if (!opts.dryRun) {
+        await ensureTrustSDK();
+        const password = await resolvePassword(opts);
+        provider = await AgentWalletProvider.fromStorage(password);
+        if (opts.autoLock) {
+          const minutes = parseInt(opts.autoLock, 10);
+          if (isNaN(minutes) || minutes <= 0) {
+            error("--auto-lock must be a positive number of minutes");
+            process.exitCode = 1;
+            return;
+          }
+          provider.setAutoLock({
+            autoLockMinutes: minutes,
+            passwordResolver: () => resolvePassword(opts)
+          });
+        }
+        amberDomains = await getAmberDomainsByCoinId();
+        executor = new SwapExecutor(swapClient, provider, {
+          amberDomains,
+          onStatus: (msg) => {
+            info(`[${ts3()}] ${msg}`);
+          }
+        });
+      }
+    } catch (err) {
+      error(`Init failed: ${err instanceof Error ? err.message : String(err)}`);
+      process.exitCode = 1;
+      return;
+    }
+    const alertStore = new AlertStore();
+    const automationStore = new AutomationStore();
+    info(`[${ts3()}] Watcher started \u2014 polling every ${intervalSec}s${opts.dryRun ? " (dry run)" : ""}`);
+    const tick = async () => {
+      const tickResults = {
+        alerts: { checked: 0, triggered: [] },
+        automations: { executed: [], skipped: 0 }
+      };
+      try {
+        const activeAlerts = await alertStore.getActive();
+        tickResults.alerts.checked = activeAlerts.length;
+        for (const alert of activeAlerts) {
+          try {
+            const { contractAddress } = parseTokenId(alert.tokenId);
+            const price = await swapClient.getTokenPrice(alert.chainKey, contractAddress || "");
+            if (price === null) continue;
+            const triggered = alert.condition === "above" && price >= alert.targetPrice || alert.condition === "below" && price <= alert.targetPrice;
+            if (triggered) {
+              await alertStore.update(alert.id, { active: false, triggeredAt: (/* @__PURE__ */ new Date()).toISOString() });
+              const detail = { id: alert.id, tokenId: alert.tokenId, condition: alert.condition, targetPrice: alert.targetPrice, currentPrice: price };
+              tickResults.alerts.triggered.push(detail);
+              success(`[${ts3()}] ALERT TRIGGERED: ${alert.tokenId} price $${price} is ${alert.condition} $${alert.targetPrice}`);
+            }
+          } catch (err) {
+            warn(`[${ts3()}] Alert ${alert.id} check failed: ${err instanceof Error ? err.message : String(err)}`);
+          }
+        }
+        const automations = await automationStore.getActive();
+        const now = Date.now();
+        for (const auto of automations) {
+          try {
+            if (auto.expiresAt && new Date(auto.expiresAt).getTime() <= now) {
+              await automationStore.update(auto.id, { active: false });
+              dim(`[${ts3()}] Automation ${auto.id.slice(0, 8)} expired`);
+              tickResults.automations.skipped++;
+              continue;
+            }
+            if (auto.maxRuns && (auto.runCount ?? 0) >= auto.maxRuns) {
+              await automationStore.update(auto.id, { active: false });
+              dim(`[${ts3()}] Automation ${auto.id.slice(0, 8)} reached max runs (${auto.maxRuns})`);
+              tickResults.automations.skipped++;
+              continue;
+            }
+            if (auto.type === "dca") {
+              const lastRun = auto.lastRunAt ? new Date(auto.lastRunAt).getTime() : 0;
+              const intervalMs = auto.intervalMs || 0;
+              if (lastRun + intervalMs > now) {
+                tickResults.automations.skipped++;
+                continue;
+              }
+              if (opts.dryRun) {
+                dim(`[${ts3()}] DRY RUN: would swap ${auto.amount} ${auto.fromToken} -> ${auto.toToken} on ${auto.chain}`);
+                tickResults.automations.executed.push({ id: auto.id, type: "dca", dryRun: true });
+                continue;
+              }
+              info(`[${ts3()}] Executing DCA: ${auto.amount} ${auto.fromToken} -> ${auto.toToken} on ${auto.chain}`);
+              const result = await executor.execute({
+                fromChain: auto.chain,
+                fromToken: auto.fromToken,
+                toChain: auto.chain,
+                toToken: auto.toToken,
+                amount: auto.amount
+              });
+              if (result.success) {
+                await automationStore.update(auto.id, { lastRunAt: (/* @__PURE__ */ new Date()).toISOString(), runCount: (auto.runCount ?? 0) + 1 });
+                success(`[${ts3()}] DCA executed: ${result.explorerUrl}`);
+                tickResults.automations.executed.push({ id: auto.id, type: "dca", txHash: result.txHash, explorer: result.explorerUrl });
+              } else {
+                warn(`[${ts3()}] DCA ${auto.id} failed: ${result.error}`);
+              }
+            } else if (auto.type === "limit") {
+              const toTokenInfo = resolveToken(auto.toToken, auto.chain);
+              const price = await swapClient.getTokenPrice(auto.chain, toTokenInfo.address);
+              if (price === null) continue;
+              const triggered = auto.condition === "below" && price <= (auto.targetPrice || 0) || auto.condition === "above" && price >= (auto.targetPrice || 0);
+              if (!triggered) {
+                tickResults.automations.skipped++;
+                continue;
+              }
+              if (opts.dryRun) {
+                dim(`[${ts3()}] DRY RUN: limit order triggered \u2014 would swap ${auto.amount} ${auto.fromToken} -> ${auto.toToken} on ${auto.chain}`);
+                tickResults.automations.executed.push({ id: auto.id, type: "limit", dryRun: true });
+                continue;
+              }
+              info(`[${ts3()}] Limit order triggered: swapping ${auto.amount} ${auto.fromToken} -> ${auto.toToken} on ${auto.chain}`);
+              const result = await executor.execute({
+                fromChain: auto.chain,
+                fromToken: auto.fromToken,
+                toChain: auto.chain,
+                toToken: auto.toToken,
+                amount: auto.amount
+              });
+              if (result.success) {
+                await automationStore.update(auto.id, { active: false, lastRunAt: (/* @__PURE__ */ new Date()).toISOString() });
+                success(`[${ts3()}] Limit order executed: ${result.explorerUrl}`);
+                tickResults.automations.executed.push({ id: auto.id, type: "limit", txHash: result.txHash, explorer: result.explorerUrl });
+              } else {
+                warn(`[${ts3()}] Limit order ${auto.id} failed: ${result.error}`);
+              }
+            }
+          } catch (err) {
+            warn(`[${ts3()}] Automation ${auto.id} failed: ${err instanceof Error ? err.message : String(err)}`);
+          }
+        }
+      } catch (err) {
+        error(`[${ts3()}] Tick error: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      if (opts.json) {
+        output({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), ...tickResults }, true);
+      } else if (tickResults.alerts.triggered.length === 0 && tickResults.automations.executed.length === 0) {
+        dim(`[${ts3()}] Checked ${tickResults.alerts.checked} alerts, ${tickResults.automations.skipped} automations \u2014 nothing to do`);
+      }
+    };
+    await tick();
+    const timer = setInterval(tick, intervalSec * 1e3);
+    const shutdown = () => {
+      clearInterval(timer);
+      if (provider) {
+        provider.disconnect().catch(() => {
+        });
+      }
+      info(`
+[${ts3()}] Watcher stopped`);
+      process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    await new Promise(() => {
+    });
+  });
+}
+
 // src/index.ts
 var VERSION2 = package_default.version;
 var program2 = new Command();
@@ -54575,9 +55618,11 @@ registerErc20Command(program2);
 registerAlertCommand(program2);
 registerQueryCommand(program2);
 registerServeCommand(program2);
+registerAutomateCommand(program2);
 registerSkillCommand(program2);
 registerX402Command(program2);
 registerTelemetryCommand(program2);
+registerWatchCommand(program2);
 initAnalytics();
 program2.hook("preAction", (_thisCommand, actionCommand) => {
   trackEvent("twak_command", { command: actionCommand.name() });