@exagent/agent 0.3.5 → 0.3.7

package/src/spot/types.ts

@@ -1,203 +0,0 @@
-// ─── Spot Config ────────────────────────────────────────────────
-
-export interface SpotConfig {
-  enabled: boolean;
-  chains: string[];
-  defaultChain: string;
-  maxSlippageBps: number;
-  maxSwapValueUSD: number;
-}
-
-export const DEFAULT_SPOT_CONFIG: SpotConfig = {
-  enabled: false,
-  chains: ['base'],
-  defaultChain: 'base',
-  maxSlippageBps: 50,
-  maxSwapValueUSD: 10_000,
-};
-
-// ─── Swap Params & Results ──────────────────────────────────────
-
-export interface SpotSwapParams {
-  tokenIn: `0x${string}`;
-  tokenOut: `0x${string}`;
-  amountIn: bigint;
-  slippageBps: number;
-  chain: string;
-  dex: 'uniswap' | 'aerodrome';
-  recipient?: `0x${string}`;
-}
-
-export interface SpotQuoteResult {
-  amountOut: bigint;
-  feeTier?: number;
-  stable?: boolean;
-  route: string;
-}
-
-export interface SpotSwapResult {
-  success: boolean;
-  txHash: `0x${string}`;
-  amountIn: bigint;
-  amountOut: bigint;
-  tokenIn: `0x${string}`;
-  tokenOut: `0x${string}`;
-  effectivePrice: number;
-  gasCost: bigint;
-  chain: string;
-  dex: string;
-  error?: string;
-}
-
-// ─── ABI Fragments ──────────────────────────────────────────────
-
-export const ERC20_ABI = [
-  {
-    type: 'function' as const,
-    name: 'approve' as const,
-    inputs: [
-      { name: 'spender', type: 'address' as const },
-      { name: 'amount', type: 'uint256' as const },
-    ],
-    outputs: [{ type: 'bool' as const }],
-    stateMutability: 'nonpayable' as const,
-  },
-  {
-    type: 'function' as const,
-    name: 'allowance' as const,
-    inputs: [
-      { name: 'owner', type: 'address' as const },
-      { name: 'spender', type: 'address' as const },
-    ],
-    outputs: [{ type: 'uint256' as const }],
-    stateMutability: 'view' as const,
-  },
-  {
-    type: 'function' as const,
-    name: 'balanceOf' as const,
-    inputs: [{ name: 'account', type: 'address' as const }],
-    outputs: [{ type: 'uint256' as const }],
-    stateMutability: 'view' as const,
-  },
-  {
-    type: 'function' as const,
-    name: 'decimals' as const,
-    inputs: [],
-    outputs: [{ type: 'uint8' as const }],
-    stateMutability: 'view' as const,
-  },
-  {
-    type: 'function' as const,
-    name: 'symbol' as const,
-    inputs: [],
-    outputs: [{ type: 'string' as const }],
-    stateMutability: 'view' as const,
-  },
-  {
-    type: 'function' as const,
-    name: 'transfer' as const,
-    inputs: [
-      { name: 'to', type: 'address' as const },
-      { name: 'amount', type: 'uint256' as const },
-    ],
-    outputs: [{ type: 'bool' as const }],
-    stateMutability: 'nonpayable' as const,
-  },
-] as const;
-
-export const UNISWAP_QUOTER_V2_ABI = [
-  {
-    type: 'function' as const,
-    name: 'quoteExactInputSingle' as const,
-    inputs: [
-      {
-        name: 'params',
-        type: 'tuple' as const,
-        components: [
-          { name: 'tokenIn', type: 'address' as const },
-          { name: 'tokenOut', type: 'address' as const },
-          { name: 'amountIn', type: 'uint256' as const },
-          { name: 'fee', type: 'uint24' as const },
-          { name: 'sqrtPriceLimitX96', type: 'uint160' as const },
-        ],
-      },
-    ],
-    outputs: [
-      { name: 'amountOut', type: 'uint256' as const },
-      { name: 'sqrtPriceX96After', type: 'uint160' as const },
-      { name: 'initializedTicksCrossed', type: 'uint32' as const },
-      { name: 'gasEstimate', type: 'uint256' as const },
-    ],
-    stateMutability: 'nonpayable' as const,
-  },
-] as const;
-
-export const UNISWAP_SWAP_ROUTER_ABI = [
-  {
-    type: 'function' as const,
-    name: 'exactInputSingle' as const,
-    inputs: [
-      {
-        name: 'params',
-        type: 'tuple' as const,
-        components: [
-          { name: 'tokenIn', type: 'address' as const },
-          { name: 'tokenOut', type: 'address' as const },
-          { name: 'fee', type: 'uint24' as const },
-          { name: 'recipient', type: 'address' as const },
-          { name: 'amountIn', type: 'uint256' as const },
-          { name: 'amountOutMinimum', type: 'uint256' as const },
-          { name: 'sqrtPriceLimitX96', type: 'uint160' as const },
-        ],
-      },
-    ],
-    outputs: [{ name: 'amountOut', type: 'uint256' as const }],
-    stateMutability: 'payable' as const,
-  },
-] as const;
-
-export const AERODROME_ROUTER_ABI = [
-  {
-    type: 'function' as const,
-    name: 'swapExactTokensForTokens' as const,
-    inputs: [
-      { name: 'amountIn', type: 'uint256' as const },
-      { name: 'amountOutMin', type: 'uint256' as const },
-      {
-        name: 'routes',
-        type: 'tuple[]' as const,
-        components: [
-          { name: 'from', type: 'address' as const },
-          { name: 'to', type: 'address' as const },
-          { name: 'stable', type: 'bool' as const },
-          { name: 'factory', type: 'address' as const },
-        ],
-      },
-      { name: 'to', type: 'address' as const },
-      { name: 'deadline', type: 'uint256' as const },
-    ],
-    outputs: [{ name: 'amounts', type: 'uint256[]' as const }],
-    stateMutability: 'nonpayable' as const,
-  },
-  {
-    type: 'function' as const,
-    name: 'getAmountsOut' as const,
-    inputs: [
-      { name: 'amountIn', type: 'uint256' as const },
-      {
-        name: 'routes',
-        type: 'tuple[]' as const,
-        components: [
-          { name: 'from', type: 'address' as const },
-          { name: 'to', type: 'address' as const },
-          { name: 'stable', type: 'bool' as const },
-          { name: 'factory', type: 'address' as const },
-        ],
-      },
-    ],
-    outputs: [{ name: 'amounts', type: 'uint256[]' as const }],
-    stateMutability: 'view' as const,
-  },
-] as const;
-
-export const AERODROME_DEFAULT_FACTORY: `0x${string}` = '0x420DD381b31aEf6683db6B902084cB0FFECe40Da';

package/src/spot/uniswap.ts

@@ -1,150 +0,0 @@
-import { getChainConfig } from '../chains.js';
-import type { SpotDEXClient } from './client.js';
-import {
-  UNISWAP_QUOTER_V2_ABI,
-  UNISWAP_SWAP_ROUTER_ABI,
-  type SpotSwapParams,
-  type SpotQuoteResult,
-  type SpotSwapResult,
-} from './types.js';
-
-const FEE_TIERS = [500, 3000, 10000] as const; // 0.05%, 0.3%, 1%
-
-export class UniswapAdapter {
-  private client: SpotDEXClient;
-
-  constructor(client: SpotDEXClient) {
-    this.client = client;
-  }
-
-  async quote(params: SpotSwapParams): Promise<SpotQuoteResult> {
-    const chainConfig = getChainConfig(params.chain);
-    if (!chainConfig?.uniswapQuoter) {
-      throw new Error(`No Uniswap QuoterV2 on ${params.chain}`);
-    }
-
-    const { publicClient } = this.client.getClients(params.chain);
-    let bestAmountOut = 0n;
-    let bestFeeTier = 0;
-
-    for (const fee of FEE_TIERS) {
-      try {
-        const result = await publicClient.simulateContract({
-          address: chainConfig.uniswapQuoter,
-          abi: UNISWAP_QUOTER_V2_ABI,
-          functionName: 'quoteExactInputSingle',
-          args: [
-            {
-              tokenIn: params.tokenIn,
-              tokenOut: params.tokenOut,
-              amountIn: params.amountIn,
-              fee,
-              sqrtPriceLimitX96: 0n,
-            },
-          ],
-        });
-
-        const amountOut = result.result[0];
-        if (amountOut > bestAmountOut) {
-          bestAmountOut = amountOut;
-          bestFeeTier = fee;
-        }
-      } catch {
-        // Pool doesn't exist for this fee tier — skip
-      }
-    }
-
-    if (bestAmountOut === 0n) {
-      throw new Error(`No Uniswap V3 pool found for ${params.tokenIn}/${params.tokenOut} on ${params.chain}`);
-    }
-
-    const tokenInSymbol = await this.client.getSymbol(params.tokenIn, params.chain);
-    const tokenOutSymbol = await this.client.getSymbol(params.tokenOut, params.chain);
-
-    return {
-      amountOut: bestAmountOut,
-      feeTier: bestFeeTier,
-      route: `${tokenInSymbol} → ${tokenOutSymbol} (${bestFeeTier / 10000}%)`,
-    };
-  }
-
-  async swap(params: SpotSwapParams): Promise<SpotSwapResult> {
-    const chainConfig = getChainConfig(params.chain);
-    if (!chainConfig) {
-      throw new Error(`Unknown chain: ${params.chain}`);
-    }
-
-    const routerAddress = chainConfig.dexRouters.uniswap;
-    if (!routerAddress) {
-      throw new Error(`No Uniswap router on ${params.chain}`);
-    }
-
-    // Get quote for fee tier selection and slippage calc
-    const quoteResult = await this.quote(params);
-    const amountOutMinimum = (quoteResult.amountOut * BigInt(10000 - params.slippageBps)) / 10000n;
-
-    // Ensure approval
-    await this.client.ensureApproval(params.tokenIn, routerAddress, params.amountIn, params.chain);
-
-    const { publicClient, walletClient } = this.client.getClients(params.chain);
-    const recipient = params.recipient ?? this.client.address;
-
-    try {
-      const hash = await walletClient.writeContract({
-        address: routerAddress,
-        abi: UNISWAP_SWAP_ROUTER_ABI,
-        functionName: 'exactInputSingle',
-        args: [
-          {
-            tokenIn: params.tokenIn,
-            tokenOut: params.tokenOut,
-            fee: quoteResult.feeTier!,
-            recipient,
-            amountIn: params.amountIn,
-            amountOutMinimum,
-            sqrtPriceLimitX96: 0n,
-          },
-        ],
-      });
-
-      const receipt = await publicClient.waitForTransactionReceipt({ hash });
-
-      // Calculate effective price from amounts
-      const tokenInDecimals = await this.client.getDecimals(params.tokenIn, params.chain);
-      const tokenOutDecimals = await this.client.getDecimals(params.tokenOut, params.chain);
-      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: params.chain,
-        dex: 'uniswap',
-      };
-    } 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: params.chain,
-        dex: 'uniswap',
-        error: (err as Error).message,
-      };
-    }
-  }
-}

package/src/store.ts

@@ -1,50 +0,0 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
-import { dirname } from 'node:path';
-import type { StrategyStore } from '@exagent/sdk';
-
-export class FileStore implements StrategyStore {
-  private data: Record<string, unknown> = {};
-  private filePath: string;
-
-  constructor(filePath: string = 'data/strategy-store.json') {
-    this.filePath = filePath;
-    this.load();
-  }
-
-  private load(): void {
-    try {
-      if (existsSync(this.filePath)) {
-        const raw = readFileSync(this.filePath, 'utf-8');
-        this.data = JSON.parse(raw);
-      }
-    } catch {
-      this.data = {};
-    }
-  }
-
-  private flush(): void {
-    const dir = dirname(this.filePath);
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
-    }
-    writeFileSync(this.filePath, JSON.stringify(this.data, null, 2));
-  }
-
-  get<T>(key: string): T | undefined {
-    return this.data[key] as T | undefined;
-  }
-
-  set<T>(key: string, value: T): void {
-    this.data[key] = value;
-    this.flush();
-  }
-
-  delete(key: string): void {
-    delete this.data[key];
-    this.flush();
-  }
-
-  keys(): string[] {
-    return Object.keys(this.data);
-  }
-}

package/src/strategy/index.ts

@@ -1,2 +0,0 @@
-export { loadStrategy, validateStrategy } from './loader.js';
-export { getTemplate, listTemplates } from './templates.js';

package/src/strategy/loader.ts

@@ -1,191 +0,0 @@
-import { existsSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { z } from 'zod';
-import type { StrategyFunction, StrategyContext, TradeSignal } from '@exagent/sdk';
-import { getTemplate } from './templates.js';
-import { scrubSecrets } from '../scrub-secrets.js';
-
-const promptSignalSchema = z.object({
-  symbol: z.string().min(1),
-  side: z.enum(['buy', 'sell', 'long', 'short']),
-  confidence: z.number().min(0).max(1).optional(),
-  reasoning: z.string().optional(),
-  venue: z.string().optional(),
-  chain: z.string().optional(),
-  size: z.number().positive().optional(),
-  price: z.number().positive().optional(),
-  fee: z.number().min(0).optional(),
-  venueFillId: z.string().optional(),
-  venueTimestamp: z.string().optional(),
-  leverage: z.number().positive().optional(),
-  orderType: z.string().optional(),
-});
-
-const promptSignalArraySchema = z.array(promptSignalSchema);
-
-export async function loadStrategy(config: {
-  file?: string;
-  code?: string;
-  template?: string;
-  prompt?: {
-    name?: string;
-    systemPrompt: string;
-    venues?: string[];
-  };
-}): Promise<StrategyFunction> {
-  if (config.file) {
-    return loadFromFile(config.file);
-  }
-
-  if (config.code) {
-    return loadFromCode(config.code);
-  }
-
-  if (config.prompt) {
-    return loadFromPrompt(config.prompt);
-  }
-
-  if (config.template) {
-    const template = getTemplate(config.template);
-    if (!template) {
-      throw new Error(`Unknown strategy template: ${config.template}. Available: momentum, value, arbitrage, hold`);
-    }
-    return loadFromCode(template.code);
-  }
-
-  // Default: hold strategy (no trades)
-  return holdStrategy;
-}
-
-async function loadFromFile(filePath: string): Promise<StrategyFunction> {
-  const resolved = resolve(filePath);
-  if (!existsSync(resolved)) {
-    throw new Error(`Strategy file not found: ${resolved}`);
-  }
-
-  try {
-    const mod = await import(resolved);
-    const fn = mod.default || mod.strategy;
-
-    if (typeof fn !== 'function') {
-      if (typeof mod.code === 'string' && mod.code.trim()) {
-        return loadFromCode(mod.code);
-      }
-
-      if (typeof mod.systemPrompt === 'string' && mod.systemPrompt.trim()) {
-        const venues = Array.isArray(mod.venues)
-          ? mod.venues.filter((venue: unknown): venue is string => typeof venue === 'string')
-          : undefined;
-        const name = typeof mod.name === 'string' ? mod.name : undefined;
-        return loadFromPrompt({
-          name,
-          systemPrompt: mod.systemPrompt,
-          venues,
-        });
-      }
-
-      if (typeof mod.template === 'string' && mod.template.trim()) {
-        const template = getTemplate(mod.template);
-        if (!template) {
-          throw new Error(`Unknown strategy template: ${mod.template}. Available: momentum, value, arbitrage, hold`);
-        }
-        return loadFromCode(template.code);
-      }
-
-      throw new Error(`Strategy file must export a default function, 'strategy' function, 'code' string, 'systemPrompt' string, or 'template' string`);
-    }
-
-    return fn as StrategyFunction;
-  } catch (err) {
-    throw new Error(`Failed to load strategy from ${resolved}: ${(err as Error).message}`);
-  }
-}
-
-async function loadFromCode(code: string): Promise<StrategyFunction> {
-  // Templates return a factory function as a string
-  // We wrap it in a module and evaluate
-  const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;
-  const fn = new AsyncFunction('context', code) as StrategyFunction;
-  return fn;
-}
-
-function loadFromPrompt(config: {
-  name?: string;
-  systemPrompt: string;
-  venues?: string[];
-}): StrategyFunction {
-  return async (context: StrategyContext): Promise<TradeSignal[]> => {
-    const prices = context.market.getPrices();
-    const positions = context.position.openPositions.map((position) => ({
-      token: position.token,
-      quantity: position.quantity,
-      costBasisPerUnit: position.costBasisPerUnit,
-      venue: position.venue,
-      chain: position.chain,
-    }));
-
-    const response = await context.llm.chat([
-      { role: 'system', content: config.systemPrompt },
-      {
-        role: 'user',
-        content: [
-          `Strategy: ${config.name || 'Prompt Strategy'}`,
-          `Allowed venues: ${(config.venues || []).join(', ') || 'any'}`,
-          `Current prices: ${JSON.stringify(prices)}`,
-          `Open positions: ${JSON.stringify(positions)}`,
-          `Risk config: ${JSON.stringify(context.config)}`,
-          'Return ONLY a JSON array of trade signals.',
-        ].join('\n'),
-      },
-    ]);
-
-    // Defense-in-depth: scrub any secrets the LLM might echo back before parsing
-    const scrubbedContent = scrubSecrets(response.content);
-
-    const match = scrubbedContent.match(/\[[\s\S]*\]/);
-    if (!match) {
-      context.log('Prompt strategy returned a non-JSON response; no signals emitted.');
-      return [];
-    }
-
-    try {
-      const parsed = promptSignalArraySchema.parse(JSON.parse(match[0]));
-      const signals: TradeSignal[] = [];
-      for (const signal of parsed) {
-        const price = signal.price ?? prices[signal.symbol.toUpperCase()];
-        if (!price || price <= 0) {
-          context.log(`Prompt strategy skipped ${signal.symbol}: no usable price in response or market cache.`);
-          continue;
-        }
-
-        signals.push({
-          symbol: signal.symbol,
-          side: signal.side,
-          confidence: signal.confidence ?? 0.5,
-          reasoning: signal.reasoning,
-          venue: signal.venue || config.venues?.[0] || 'manual',
-          chain: signal.chain,
-          size: signal.size ?? 1,
-          price,
-          fee: signal.fee ?? 0,
-          venueFillId: signal.venueFillId ?? '',
-          venueTimestamp: signal.venueTimestamp ?? new Date().toISOString(),
-          leverage: signal.leverage,
-          orderType: signal.orderType,
-        });
-      }
-      return signals;
-    } catch (err) {
-      context.log(`Prompt strategy parse failed: ${(err as Error).message}`);
-      return [];
-    }
-  };
-}
-
-const holdStrategy: StrategyFunction = async (_context: StrategyContext): Promise<TradeSignal[]> => {
-  return []; // No trades — hold position
-};
-
-export function validateStrategy(fn: unknown): fn is StrategyFunction {
-  return typeof fn === 'function';
-}