@exagent/agent 0.3.5 → 0.3.7

package/src/spot/aerodrome.ts

@@ -1,158 +0,0 @@
-import { getChainConfig } from '../chains.js';
-import type { SpotDEXClient } from './client.js';
-import {
-  AERODROME_ROUTER_ABI,
-  AERODROME_DEFAULT_FACTORY,
-  type SpotSwapParams,
-  type SpotQuoteResult,
-  type SpotSwapResult,
-} from './types.js';
-
-export class AerodromeAdapter {
-  private client: SpotDEXClient;
-
-  constructor(client: SpotDEXClient) {
-    this.client = client;
-  }
-
-  async quote(params: SpotSwapParams): Promise<SpotQuoteResult> {
-    if (params.chain !== 'base') {
-      throw new Error('Aerodrome is only available on Base');
-    }
-
-    const chainConfig = getChainConfig('base')!;
-    const routerAddress = chainConfig.dexRouters.aerodrome;
-    if (!routerAddress) {
-      throw new Error('No Aerodrome router configured for Base');
-    }
-
-    const { publicClient } = this.client.getClients('base');
-
-    let bestAmountOut = 0n;
-    let bestStable = false;
-
-    // Try both stable and volatile pools
-    for (const stable of [true, false]) {
-      try {
-        const route = [
-          {
-            from: params.tokenIn,
-            to: params.tokenOut,
-            stable,
-            factory: AERODROME_DEFAULT_FACTORY,
-          },
-        ];
-
-        const amounts = await publicClient.readContract({
-          address: routerAddress,
-          abi: AERODROME_ROUTER_ABI,
-          functionName: 'getAmountsOut',
-          args: [params.amountIn, route],
-        }) as bigint[];
-
-        const amountOut = amounts[amounts.length - 1];
-        if (amountOut > bestAmountOut) {
-          bestAmountOut = amountOut;
-          bestStable = stable;
-        }
-      } catch {
-        // Pool doesn't exist for this type — skip
-      }
-    }
-
-    if (bestAmountOut === 0n) {
-      throw new Error(`No Aerodrome pool found for ${params.tokenIn}/${params.tokenOut}`);
-    }
-
-    const tokenInSymbol = await this.client.getSymbol(params.tokenIn, 'base');
-    const tokenOutSymbol = await this.client.getSymbol(params.tokenOut, 'base');
-
-    return {
-      amountOut: bestAmountOut,
-      stable: bestStable,
-      route: `${tokenInSymbol} → ${tokenOutSymbol} (${bestStable ? 'stable' : 'volatile'})`,
-    };
-  }
-
-  async swap(params: SpotSwapParams): Promise<SpotSwapResult> {
-    if (params.chain !== 'base') {
-      throw new Error('Aerodrome is only available on Base');
-    }
-
-    const chainConfig = getChainConfig('base')!;
-    const routerAddress = chainConfig.dexRouters.aerodrome;
-    if (!routerAddress) {
-      throw new Error('No Aerodrome router configured for Base');
-    }
-
-    // Get quote for pool type selection and slippage calc
-    const quoteResult = await this.quote(params);
-    const amountOutMin = (quoteResult.amountOut * BigInt(10000 - params.slippageBps)) / 10000n;
-
-    // Ensure approval
-    await this.client.ensureApproval(params.tokenIn, routerAddress, params.amountIn, 'base');
-
-    const { publicClient, walletClient } = this.client.getClients('base');
-    const recipient = params.recipient ?? this.client.address;
-
-    const route = [
-      {
-        from: params.tokenIn,
-        to: params.tokenOut,
-        stable: quoteResult.stable!,
-        factory: AERODROME_DEFAULT_FACTORY,
-      },
-    ];
-
-    // Deadline: 5 minutes from now
-    const deadline = BigInt(Math.floor(Date.now() / 1000) + 300);
-
-    try {
-      const hash = await walletClient.writeContract({
-        address: routerAddress,
-        abi: AERODROME_ROUTER_ABI,
-        functionName: 'swapExactTokensForTokens',
-        args: [params.amountIn, amountOutMin, route, recipient, deadline],
-      });
-
-      const receipt = await publicClient.waitForTransactionReceipt({ hash });
-
-      // Calculate effective price
-      const tokenInDecimals = await this.client.getDecimals(params.tokenIn, 'base');
-      const tokenOutDecimals = await this.client.getDecimals(params.tokenOut, 'base');
-      const amountInFloat = Number(params.amountIn) / 10 ** tokenInDecimals;
-      const amountOutFloat = Number(quoteResult.amountOut) / 10 ** tokenOutDecimals;
-      const effectivePrice = amountOutFloat / amountInFloat;
-
-      const gasUsed = receipt.gasUsed ?? 0n;
-      const gasPrice = receipt.effectiveGasPrice ?? 0n;
-
-      return {
-        success: true,
-        txHash: hash,
-        amountIn: params.amountIn,
-        amountOut: quoteResult.amountOut,
-        tokenIn: params.tokenIn,
-        tokenOut: params.tokenOut,
-        effectivePrice,
-        gasCost: gasUsed * gasPrice,
-        chain: 'base',
-        dex: 'aerodrome',
-      };
-    } catch (err) {
-      return {
-        success: false,
-        txHash: '0x0' as `0x${string}`,
-        amountIn: params.amountIn,
-        amountOut: 0n,
-        tokenIn: params.tokenIn,
-        tokenOut: params.tokenOut,
-        effectivePrice: 0,
-        gasCost: 0n,
-        chain: 'base',
-        dex: 'aerodrome',
-        error: (err as Error).message,
-      };
-    }
-  }
-}

package/src/spot/client.ts

@@ -1,138 +0,0 @@
-import {
-  createPublicClient,
-  createWalletClient,
-  http,
-  maxUint256,
-  type PublicClient,
-  type WalletClient,
-  type Transport,
-  type Chain,
-  type Account,
-} from 'viem';
-import { privateKeyToAccount } from 'viem/accounts';
-import { getChainConfig, type ChainConfig } from '../chains.js';
-import { ERC20_ABI } from './types.js';
-
-interface ChainClients {
-  publicClient: PublicClient<Transport, Chain>;
-  walletClient: WalletClient<Transport, Chain, Account>;
-  chainConfig: ChainConfig;
-}
-
-export class SpotDEXClient {
-  private account: ReturnType<typeof privateKeyToAccount>;
-  private clients: Map<string, ChainClients> = new Map();
-  private decimalsCache: Map<string, number> = new Map();
-  private symbolCache: Map<string, string> = new Map();
-
-  constructor(privateKey: string) {
-    this.account = privateKeyToAccount(privateKey as `0x${string}`);
-  }
-
-  get address(): `0x${string}` {
-    return this.account.address;
-  }
-
-  getClients(chainName: string): ChainClients {
-    const cached = this.clients.get(chainName);
-    if (cached) return cached;
-
-    const chainConfig = getChainConfig(chainName);
-    if (!chainConfig) {
-      throw new Error(`Unknown chain: ${chainName}`);
-    }
-
-    const publicClient = createPublicClient({
-      chain: chainConfig.viemChain,
-      transport: http(chainConfig.rpcUrl),
-    }) as PublicClient<Transport, Chain>;
-
-    const walletClient = createWalletClient({
-      account: this.account,
-      chain: chainConfig.viemChain,
-      transport: http(chainConfig.rpcUrl),
-    }) as WalletClient<Transport, Chain, Account>;
-
-    const entry: ChainClients = { publicClient, walletClient, chainConfig };
-    this.clients.set(chainName, entry);
-    return entry;
-  }
-
-  async getDecimals(token: `0x${string}`, chainName: string): Promise<number> {
-    const key = `${chainName}:${token}`;
-    const cached = this.decimalsCache.get(key);
-    if (cached !== undefined) return cached;
-
-    const { publicClient } = this.getClients(chainName);
-    const decimals = await publicClient.readContract({
-      address: token,
-      abi: ERC20_ABI,
-      functionName: 'decimals',
-    }) as number;
-
-    this.decimalsCache.set(key, decimals);
-    return decimals;
-  }
-
-  async getSymbol(token: `0x${string}`, chainName: string): Promise<string> {
-    const key = `${chainName}:${token}`;
-    const cached = this.symbolCache.get(key);
-    if (cached) return cached;
-
-    const { publicClient } = this.getClients(chainName);
-    const symbol = await publicClient.readContract({
-      address: token,
-      abi: ERC20_ABI,
-      functionName: 'symbol',
-    }) as string;
-
-    this.symbolCache.set(key, symbol);
-    return symbol;
-  }
-
-  async getBalance(token: `0x${string}`, chainName: string): Promise<bigint> {
-    const { publicClient } = this.getClients(chainName);
-    return await publicClient.readContract({
-      address: token,
-      abi: ERC20_ABI,
-      functionName: 'balanceOf',
-      args: [this.account.address],
-    }) as bigint;
-  }
-
-  /** Get the native token balance (ETH, POL, etc.) on a chain */
-  async getNativeBalance(chainName: string): Promise<bigint> {
-    const { publicClient } = this.getClients(chainName);
-    return await publicClient.getBalance({ address: this.account.address });
-  }
-
-  async ensureApproval(
-    token: `0x${string}`,
-    spender: `0x${string}`,
-    amount: bigint,
-    chainName: string,
-  ): Promise<`0x${string}` | null> {
-    const { publicClient, walletClient } = this.getClients(chainName);
-
-    const allowance = await publicClient.readContract({
-      address: token,
-      abi: ERC20_ABI,
-      functionName: 'allowance',
-      args: [this.account.address, spender],
-    }) as bigint;
-
-    if (allowance >= amount) return null;
-
-    // Approve max to avoid repeated approvals
-    const hash = await walletClient.writeContract({
-      address: token,
-      abi: ERC20_ABI,
-      functionName: 'approve',
-      args: [spender, maxUint256],
-    });
-
-    await publicClient.waitForTransactionReceipt({ hash });
-    console.log(`[spot] Approved ${token} for ${spender} on ${chainName} (tx: ${hash})`);
-    return hash;
-  }
-}

package/src/spot/index.ts

@@ -1,11 +0,0 @@
-export { SpotDEXClient } from './client.js';
-export { UniswapAdapter } from './uniswap.js';
-export { AerodromeAdapter } from './aerodrome.js';
-export { SpotSwapManager } from './swap-manager.js';
-export type {
-  SpotConfig,
-  SpotSwapParams,
-  SpotQuoteResult,
-  SpotSwapResult,
-} from './types.js';
-export { DEFAULT_SPOT_CONFIG } from './types.js';

package/src/spot/swap-manager.ts

@@ -1,219 +0,0 @@
-import { getChainConfig } from '../chains.js';
-import { SpotDEXClient } from './client.js';
-import { UniswapAdapter } from './uniswap.js';
-import { AerodromeAdapter } from './aerodrome.js';
-import type { SpotConfig, SpotSwapParams, SpotQuoteResult, SpotSwapResult } from './types.js';
-
-/** Well-known token symbols → addresses per chain */
-const TOKEN_ALIASES: Record<string, Record<string, `0x${string}`>> = {
-  base: {
-    ETH: '0x4200000000000000000000000000000000000006',
-    WETH: '0x4200000000000000000000000000000000000006',
-    USDC: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
-    USDbC: '0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA',
-    DAI: '0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb',
-  },
-  ethereum: {
-    ETH: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
-    WETH: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
-    USDC: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
-    USDT: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
-    DAI: '0x6B175474E89094C44Da98b954EedeAC495271d0F',
-  },
-  arbitrum: {
-    ETH: '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1',
-    WETH: '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1',
-    USDC: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
-    'USDC.e': '0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8',
-    USDT: '0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9',
-  },
-  polygon: {
-    POL: '0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270',
-    WPOL: '0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270',
-    WMATIC: '0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270',
-    USDC: '0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359',
-    'USDC.e': '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174',
-    USDT: '0xc2132D05D31c914a87C6611C10748AEb04B58e8F',
-  },
-};
-
-export class SpotSwapManager {
-  private dexClient: SpotDEXClient;
-  private uniswap: UniswapAdapter;
-  private aerodrome: AerodromeAdapter;
-  private config: SpotConfig;
-
-  constructor(privateKey: string, config: SpotConfig) {
-    this.config = config;
-    this.dexClient = new SpotDEXClient(privateKey);
-    this.uniswap = new UniswapAdapter(this.dexClient);
-    this.aerodrome = new AerodromeAdapter(this.dexClient);
-  }
-
-  get client(): SpotDEXClient {
-    return this.dexClient;
-  }
-
-  /** Resolve a token symbol or address to a hex address */
-  resolveToken(tokenOrSymbol: string, chain: string): `0x${string}` {
-    if (tokenOrSymbol.startsWith('0x') && tokenOrSymbol.length === 42) {
-      return tokenOrSymbol as `0x${string}`;
-    }
-
-    const chainAliases = TOKEN_ALIASES[chain];
-    if (chainAliases) {
-      const upper = tokenOrSymbol.toUpperCase();
-      const address = chainAliases[upper] ?? chainAliases[tokenOrSymbol];
-      if (address) return address;
-    }
-
-    // Try WETH/USDC from chain config
-    const chainConfig = getChainConfig(chain);
-    if (chainConfig) {
-      const upper = tokenOrSymbol.toUpperCase();
-      if (upper === 'WETH' || upper === 'ETH') return chainConfig.wethAddress;
-      if (upper === 'USDC') return chainConfig.usdcAddress;
-    }
-
-    throw new Error(`Cannot resolve token "${tokenOrSymbol}" on ${chain}. Provide contract address.`);
-  }
-
-  /** Select DEX: explicit choice, or auto-detect */
-  private selectDex(chain: string, dex?: string): 'uniswap' | 'aerodrome' {
-    if (dex) return dex as 'uniswap' | 'aerodrome';
-
-    // Prefer Aerodrome on Base (lower fees, deeper liquidity for common pairs)
-    const chainConfig = getChainConfig(chain);
-    if (chain === 'base' && chainConfig?.dexRouters.aerodrome) {
-      return 'aerodrome';
-    }
-    return 'uniswap';
-  }
-
-  async getQuote(params: {
-    tokenIn: string;
-    tokenOut: string;
-    amountIn: bigint;
-    chain?: string;
-    dex?: string;
-  }): Promise<SpotQuoteResult> {
-    const chain = params.chain ?? this.config.defaultChain;
-    const dex = this.selectDex(chain, params.dex);
-
-    const swapParams: SpotSwapParams = {
-      tokenIn: this.resolveToken(params.tokenIn, chain),
-      tokenOut: this.resolveToken(params.tokenOut, chain),
-      amountIn: params.amountIn,
-      slippageBps: this.config.maxSlippageBps,
-      chain,
-      dex,
-    };
-
-    if (dex === 'aerodrome') {
-      return this.aerodrome.quote(swapParams);
-    }
-    return this.uniswap.quote(swapParams);
-  }
-
-  async executeSwap(params: {
-    tokenIn: string;
-    tokenOut: string;
-    amountIn: bigint;
-    chain?: string;
-    dex?: string;
-    slippageBps?: number;
-  }): Promise<SpotSwapResult> {
-    const chain = params.chain ?? this.config.defaultChain;
-    const dex = this.selectDex(chain, params.dex);
-
-    // Enforce max swap value cap
-    // amountIn is in token decimals — we need to estimate USD value.
-    // For stablecoins (6 decimals), amountIn / 1e6 ≈ USD value.
-    // For non-stables, we can't precisely compute USD without a price feed,
-    // so we use a conservative estimate: assume the token could be worth up to $100k/unit.
-    // The risk manager's filterSignals() already checks signal-level USD values before
-    // we get here, so this is a belt-and-suspenders check using the config cap.
-    const tokenInAddress = this.resolveToken(params.tokenIn, chain);
-    try {
-      const decimals = await this.dexClient.getDecimals(tokenInAddress, chain);
-      const amountFloat = Number(params.amountIn) / 10 ** decimals;
-      // For stablecoins, 1 token ≈ $1. For others, this is approximate.
-      // A more precise check would need a price oracle, but the runtime's risk filter
-      // already validates USD values before calling executeSwap().
-      if (amountFloat > this.config.maxSwapValueUSD) {
-        return {
-          success: false,
-          txHash: '0x0' as `0x${string}`,
-          amountIn: params.amountIn,
-          amountOut: 0n,
-          tokenIn: '0x0' as `0x${string}`,
-          tokenOut: '0x0' as `0x${string}`,
-          effectivePrice: 0,
-          gasCost: 0n,
-          chain,
-          dex,
-          error: `Swap value ${amountFloat.toFixed(2)} tokens exceeds max $${this.config.maxSwapValueUSD}. Reduce size or increase maxSwapValueUSD.`,
-        };
-      }
-    } catch {
-      // If we can't check decimals, proceed — let the swap itself validate
-    }
-
-    if (!this.config.chains.includes(chain)) {
-      return {
-        success: false,
-        txHash: '0x0' as `0x${string}`,
-        amountIn: params.amountIn,
-        amountOut: 0n,
-        tokenIn: '0x0' as `0x${string}`,
-        tokenOut: '0x0' as `0x${string}`,
-        effectivePrice: 0,
-        gasCost: 0n,
-        chain,
-        dex,
-        error: `Chain "${chain}" not enabled in spot config (enabled: ${this.config.chains.join(', ')})`,
-      };
-    }
-
-    // Pre-check native gas balance — swaps revert with opaque errors if wallet has 0 gas
-    const MIN_GAS_WEI = 100_000_000_000_000n; // 0.0001 ETH/POL
-    try {
-      const nativeBalance = await this.dexClient.getNativeBalance(chain);
-      if (nativeBalance < MIN_GAS_WEI) {
-        const chainConfig = getChainConfig(chain);
-        const nativeName = chainConfig?.nativeCurrency ?? 'ETH';
-        return {
-          success: false,
-          txHash: '0x0' as `0x${string}`,
-          amountIn: params.amountIn,
-          amountOut: 0n,
-          tokenIn: '0x0' as `0x${string}`,
-          tokenOut: '0x0' as `0x${string}`,
-          effectivePrice: 0,
-          gasCost: 0n,
-          chain,
-          dex,
-          error: `Insufficient ${nativeName} for gas on ${chain}. Balance: ${nativeBalance} wei. Need at least 0.0001 ${nativeName}. Bridge gas to ${chain} before swapping.`,
-        };
-      }
-    } catch {
-      // Non-critical — proceed and let the swap itself surface the error
-    }
-
-    const swapParams: SpotSwapParams = {
-      tokenIn: this.resolveToken(params.tokenIn, chain),
-      tokenOut: this.resolveToken(params.tokenOut, chain),
-      amountIn: params.amountIn,
-      slippageBps: params.slippageBps ?? this.config.maxSlippageBps,
-      chain,
-      dex,
-    };
-
-    console.log(`[spot] Swapping on ${dex}/${chain}: ${params.tokenIn} → ${params.tokenOut} (${params.amountIn})`);
-
-    if (dex === 'aerodrome') {
-      return this.aerodrome.swap(swapParams);
-    }
-    return this.uniswap.swap(swapParams);
-  }
-}