@trustwallet/cli 0.6.11 → 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;
@@ -14582,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(","));
@@ -15625,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}"`);
           }
         }
@@ -15645,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;
@@ -22368,6 +22414,9 @@ 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());
@@ -25268,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) {
@@ -25365,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");
 }
@@ -39471,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;
@@ -45628,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();
@@ -54426,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 {
@@ -54465,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
     };
@@ -54496,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");
@@ -54713,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.11",
+  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",
@@ -54818,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);
@@ -54875,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();
@@ -54891,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() });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trustwallet/cli",
-  "version": "0.6.11",
+  "version": "0.7.0",
   "description": "TWAK CLI — command-line interface for Trust Wallet Agent Kit",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -27,17 +27,17 @@
     "ora": "5.4.1",
     "tsup": "8.5.1",
     "typescript": "5.7.3",
-    "@twak/core": "0.6.11",
-    "@twak/mcp": "0.6.11",
-    "@twak/security": "0.6.11",
-    "@twak/storage": "0.6.11",
-    "@twak/actions": "0.6.11",
-    "@twak/swap": "0.6.11",
-    "@twak/transactions": "0.6.11",
-    "@twak/wallet": "0.6.11",
-    "@twak/wallet-core": "0.6.11",
-    "@twak/blockchain": "0.6.11",
-    "@twak/walletconnect": "0.6.11"
+    "@twak/blockchain": "0.7.0",
+    "@twak/core": "0.7.0",
+    "@twak/mcp": "0.7.0",
+    "@twak/security": "0.7.0",
+    "@twak/storage": "0.7.0",
+    "@twak/swap": "0.7.0",
+    "@twak/transactions": "0.7.0",
+    "@twak/wallet": "0.7.0",
+    "@twak/wallet-core": "0.7.0",
+    "@twak/actions": "0.7.0",
+    "@twak/walletconnect": "0.7.0"
   },
   "publishConfig": {
     "access": "public"