@exagent/agent 0.1.45 → 0.1.47

package/dist/index.js

@@ -610,6 +610,30 @@ var MarketDataService = class {
       }
     };
   }
+  /**
+   * Discover all ERC-20 token holdings for a wallet via Blockscout API.
+   * Returns token addresses with non-zero balances.
+   * Used by Frontier agents to find tokens outside the standard whitelist.
+   */
+  async discoverTokenHoldings(walletAddress) {
+    try {
+      const resp = await fetch(
+        `https://base.blockscout.com/api/v2/addresses/${walletAddress}/token-balances`,
+        { signal: AbortSignal.timeout(1e4) }
+      );
+      if (!resp.ok) return [];
+      const data = await resp.json();
+      const addresses = [];
+      for (const entry of data) {
+        if (entry.token?.type === "ERC-20" && entry.value && entry.value !== "0") {
+          addresses.push(entry.token.address.toLowerCase());
+        }
+      }
+      return addresses;
+    } catch {
+      return [];
+    }
+  }
   /**
    * Check if cached prices are still fresh
    */
@@ -2353,16 +2377,25 @@ var TradeExecutor = class {
   config;
   allowedTokens;
   configHashFn;
-  constructor(client, config, configHashFn) {
+  vaultManager;
+  constructor(client, config, configHashFn, vaultManager) {
     this.client = client;
     this.config = config;
     this.configHashFn = configHashFn;
+    this.vaultManager = vaultManager;
     this.allowedTokens = new Set(
       (config.allowedTokens || []).map((t) => t.toLowerCase())
     );
   }
   /**
-   * Execute a single trade signal
+   * Set the vault manager (allows wiring after construction)
+   */
+  setVaultManager(vm) {
+    this.vaultManager = vm;
+  }
+  /**
+   * Execute a single trade signal.
+   * Tries vault trading first if vault exists, falls back to wallet trading.
    */
   async execute(signal) {
     if (signal.action === "hold") {
@@ -2375,13 +2408,38 @@ var TradeExecutor = class {
         return { success: false, error: "Signal exceeds position limits" };
       }
       const configHash = this.configHashFn?.();
-      const result = await this.client.trade({
+      const tradeIntent = {
         tokenIn: signal.tokenIn,
         tokenOut: signal.tokenOut,
         amountIn: signal.amountIn,
         maxSlippageBps: this.config.trading?.maxSlippageBps ?? 100,
         ...configHash && { configHash }
-      });
+      };
+      if (this.vaultManager) {
+        const vaultAddress = await this.vaultManager.getVaultAddress();
+        if (vaultAddress && this.vaultManager.preferVaultTrading) {
+          const routerTrade = await this.client.buildRouterTrade(tradeIntent);
+          if (routerTrade.vaultParams) {
+            console.log(`Attempting vault trade via ${vaultAddress}`);
+            const vaultResult = await this.vaultManager.executeVaultTrade({
+              tokenIn: signal.tokenIn,
+              tokenOut: signal.tokenOut,
+              amountIn: BigInt(signal.amountIn),
+              minAmountOut: BigInt(routerTrade.minAmountOut),
+              vaultParams: routerTrade.vaultParams
+            });
+            if (vaultResult) {
+              if (vaultResult.txHash) {
+                console.log(`Vault trade executed: ${vaultResult.txHash}`);
+                return { success: true, txHash: vaultResult.txHash };
+              }
+              console.error(`Vault trade failed: ${vaultResult.error}`);
+              return { success: false, error: vaultResult.error };
+            }
+          }
+        }
+      }
+      const result = await this.client.trade(tradeIntent);
       console.log(`Trade executed: ${result.hash}`);
       return { success: true, txHash: result.hash };
     } catch (error) {
@@ -2867,9 +2925,10 @@ var VAULT_ABI = [
     outputs: [{ type: "uint256" }],
     stateMutability: "view"
   },
+  // TOKEN → base asset (fee from output)
   {
     type: "function",
-    name: "executeTrade",
+    name: "executeSwap",
     inputs: [
       { name: "tokenIn", type: "address" },
       { name: "tokenOut", type: "address" },
@@ -2877,6 +2936,44 @@ var VAULT_ABI = [
       { name: "minAmountOut", type: "uint256" },
       { name: "aggregator", type: "address" },
       { name: "swapData", type: "bytes" },
+      { name: "feeConvertAggregator", type: "address" },
+      { name: "feeSwapData", type: "bytes" },
+      { name: "deadline", type: "uint256" }
+    ],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  // Base asset → TOKEN (fee from input)
+  {
+    type: "function",
+    name: "executeSwapSimple",
+    inputs: [
+      { name: "tokenIn", type: "address" },
+      { name: "tokenOut", type: "address" },
+      { name: "amountIn", type: "uint256" },
+      { name: "minAmountOut", type: "uint256" },
+      { name: "target", type: "address" },
+      { name: "data", type: "bytes" },
+      { name: "feeConvertAggregator", type: "address" },
+      { name: "feeSwapData", type: "bytes" },
+      { name: "deadline", type: "uint256" }
+    ],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  // TOKEN → TOKEN (multi-hop via USDC, fee at midpoint)
+  {
+    type: "function",
+    name: "executeSwapMultiHop",
+    inputs: [
+      { name: "tokenIn", type: "address" },
+      { name: "tokenOut", type: "address" },
+      { name: "amountIn", type: "uint256" },
+      { name: "minAmountOut", type: "uint256" },
+      { name: "aggregator1", type: "address" },
+      { name: "swapData1", type: "bytes" },
+      { name: "aggregator2", type: "address" },
+      { name: "swapData2", type: "bytes" },
       { name: "deadline", type: "uint256" }
     ],
     outputs: [{ type: "uint256" }],
@@ -3142,8 +3239,9 @@ var VaultManager = class {
     }
   }
   /**
-   * Execute a trade through the vault (if it exists and policy allows)
-   * Returns null if should use direct trading instead
+   * Execute a trade through the vault using API-provided vaultParams.
+   * Dispatches to the correct vault function based on swapType.
+   * Returns null if vault trading shouldn't be used (no vault, policy disabled).
    */
   async executeVaultTrade(params) {
     if (!this.preferVaultTrading) {
@@ -3154,23 +3252,71 @@ var VaultManager = class {
       return null;
     }
     const deadline = params.deadline || BigInt(Math.floor(Date.now() / 1e3) + 3600);
+    const { vaultParams } = params;
     try {
-      const hash = await this.walletClient.writeContract({
-        address: vaultAddress,
-        abi: VAULT_ABI,
-        functionName: "executeTrade",
-        args: [
-          params.tokenIn,
-          params.tokenOut,
-          params.amountIn,
-          params.minAmountOut,
-          params.aggregator,
-          params.swapData,
-          deadline
-        ],
-        chain: import_chains2.base,
-        account: this.account
-      });
+      let hash;
+      switch (vaultParams.swapType) {
+        case "swap":
+          hash = await this.walletClient.writeContract({
+            address: vaultAddress,
+            abi: VAULT_ABI,
+            functionName: "executeSwap",
+            args: [
+              params.tokenIn,
+              params.tokenOut,
+              params.amountIn,
+              params.minAmountOut,
+              vaultParams.aggregator,
+              vaultParams.swapData,
+              vaultParams.feeConvertAggregator,
+              vaultParams.feeSwapData,
+              deadline
+            ],
+            chain: import_chains2.base,
+            account: this.account
+          });
+          break;
+        case "simple":
+          hash = await this.walletClient.writeContract({
+            address: vaultAddress,
+            abi: VAULT_ABI,
+            functionName: "executeSwapSimple",
+            args: [
+              params.tokenIn,
+              params.tokenOut,
+              params.amountIn,
+              params.minAmountOut,
+              vaultParams.target,
+              vaultParams.data,
+              vaultParams.feeConvertAggregator,
+              vaultParams.feeSwapData,
+              deadline
+            ],
+            chain: import_chains2.base,
+            account: this.account
+          });
+          break;
+        case "multihop":
+          hash = await this.walletClient.writeContract({
+            address: vaultAddress,
+            abi: VAULT_ABI,
+            functionName: "executeSwapMultiHop",
+            args: [
+              params.tokenIn,
+              params.tokenOut,
+              params.amountIn,
+              params.minAmountOut,
+              vaultParams.aggregator1,
+              vaultParams.swapData1,
+              vaultParams.aggregator2,
+              vaultParams.swapData2,
+              deadline
+            ],
+            chain: import_chains2.base,
+            account: this.account
+          });
+          break;
+      }
       return { usedVault: true, txHash: hash };
     } catch (error) {
       return {
@@ -7148,6 +7294,8 @@ var AgentRuntime = class {
   processAlive = true;
   riskUniverse = 0;
   allowedTokens = /* @__PURE__ */ new Set();
+  /** Frontier token discovery — cached addresses from Blockscout scan */
+  discoveredTokens = [];
   strategyContext;
   positionTracker;
   // Paper trading components (null when not in paper mode)
@@ -7311,10 +7459,16 @@ var AgentRuntime = class {
       vaultConfig
     });
     console.log(`Vault policy: ${vaultConfig.policy}`);
+    if (this.executor) {
+      this.executor.setVaultManager(this.vaultManager);
+    }
     const status = await this.vaultManager.getVaultStatus();
     if (status.hasVault) {
       console.log(`Vault exists: ${status.vaultAddress}`);
       console.log(`Vault TVL: ${Number(status.totalAssets) / 1e6} USDC`);
+      if (vaultConfig.preferVaultTrading) {
+        console.log("Vault trading enabled \u2014 trades will execute from vault");
+      }
     } else {
       console.log("No vault exists for this agent");
       if (vaultConfig.policy === "manual") {
@@ -7749,6 +7903,13 @@ var AgentRuntime = class {
       console.log("");
       this.mode = "idle";
       try {
+        if (this.riskUniverse === 4) {
+          const discovered = await this.marketData.discoverTokenHoldings(this.client.address);
+          if (discovered.length > 0) {
+            this.discoveredTokens = discovered;
+            console.log(`Frontier token discovery: ${discovered.length} token(s) found on-chain`);
+          }
+        }
         const tokens = this.getTokensToTrack();
         const initData = await this.marketData.fetchMarketData(this.client.address, tokens);
         void this.positionTracker.syncBalances(initData.balances, initData.prices);
@@ -8728,8 +8889,9 @@ This exit has been recorded in your trade history and counts toward your total P
         this.paperPortfolio.save();
       } else {
         const vaultStatus = await this.vaultManager?.getVaultStatus();
-        if (vaultStatus?.hasVault && this.vaultManager?.preferVaultTrading) {
-          console.log(`Trading through vault: ${vaultStatus.vaultAddress}`);
+        if (vaultStatus?.hasVault) {
+          const via = this.vaultManager?.preferVaultTrading ? "vault" : "wallet";
+          console.log(`Vault active: ${vaultStatus.vaultAddress} (trades execute from ${via})`);
         }
         const results = await this.executor.executeAll(filteredSignals);
         let totalFeesUSD = 0;
@@ -9101,8 +9263,14 @@ See: https://exagent.io/docs/guides/manual-exit`,
         }
       }
     }
+    for (const addr of this.discoveredTokens) {
+      if (!baseSet.has(addr)) {
+        extras.push(addr);
+        baseSet.add(addr);
+      }
+    }
     if (extras.length > 0) {
-      console.log(`Auto-tracking ${extras.length} additional token(s) from position history`);
+      console.log(`Auto-tracking ${extras.length} additional token(s) from position/discovery`);
     }
     const resolver = this.marketData.getResolver();
     const allTokens = [...base8, ...extras];
@@ -9442,7 +9610,7 @@ function loadSecureEnv(basePath, passphrase) {
 }
 
 // src/index.ts
-var AGENT_VERSION = "0.1.45";
+var AGENT_VERSION = "0.1.47";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AGENT_VERSION,

package/dist/index.mjs

@@ -62,7 +62,7 @@ import {
   tradeIdToBytes32,
   validateConfig,
   validateStrategy
-} from "./chunk-RR4RQDU3.mjs";
+} from "./chunk-ICTDJ7VX.mjs";
 export {
   AGENT_VERSION,
   AgentConfigSchema,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exagent/agent",
-  "version": "0.1.45",
+  "version": "0.1.47",
   "description": "Autonomous trading agent runtime for Exagent",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -29,7 +29,7 @@
     "clean": "rm -rf dist"
   },
   "dependencies": {
-    "@exagent/sdk": "^0.1.20",
+    "@exagent/sdk": "^0.1.21",
     "@nktkas/hyperliquid": "^0.31.0",
     "@polymarket/clob-client": "^4.0.0",
     "chalk": "^5.3.0",