@exagent/agent 0.3.6 → 0.3.8

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,265 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { extname, 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 MAX_PROMPT_SIGNALS = 10;
-const SUPPORTED_FILE_EXPORTS = new Set(['name', 'description', 'category', 'venues', 'systemPrompt', 'template']);
-
-const promptSignalSchema = z.object({
-  symbol: z.string().min(1).max(80),
-  side: z.enum(['buy', 'sell', 'long', 'short']),
-  confidence: z.number().min(0).max(1).optional(),
-  reasoning: z.string().max(1000).optional(),
-  venue: z.string().min(1).max(80).optional(),
-  chain: z.string().min(1).max(80).optional(),
-  size: z.number().positive().optional(),
-  price: z.number().positive().optional(),
-  leverage: z.number().positive().max(100).optional(),
-  orderType: z.enum(['market', 'limit', 'yes', 'no']).optional(),
-}).strict();
-
-const promptSignalArraySchema = z.array(promptSignalSchema).max(MAX_PROMPT_SIGNALS);
-
-const strategyMetadataSchema = z.object({
-  name: z.string().min(1).max(120).optional(),
-  description: z.string().max(1000).optional(),
-  category: z.string().max(80).optional(),
-  venues: z.array(z.string().min(1).max(80)).max(20).optional(),
-  systemPrompt: z.string().min(1).max(12000).optional(),
-  template: z.string().min(1).max(80).optional(),
-}).strict();
-
-export async function loadStrategy(config: {
-  file?: string;
-  code?: string;
-  template?: string;
-  prompt?: {
-    name?: string;
-    systemPrompt: string;
-    venues?: string[];
-  };
-}): Promise<StrategyFunction> {
-  if (config.code?.trim()) {
-    throw new Error('Raw JavaScript strategy code is disabled. Use a template or prompt-backed strategy instead.');
-  }
-
-  if (config.file) {
-    return loadFromFile(config.file);
-  }
-
-  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`);
-    }
-    if (!template.systemPrompt.trim()) {
-      return holdStrategy;
-    }
-    return loadFromPrompt({
-      name: template.name,
-      systemPrompt: template.systemPrompt,
-      venues: template.venues,
-    });
-  }
-
-  // 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 source = readFileSync(resolved, 'utf8');
-    const metadata = extname(resolved) === '.json'
-      ? strategyMetadataSchema.parse(JSON.parse(source))
-      : parseStrategyMetadataModule(source, resolved);
-
-    if (metadata.systemPrompt?.trim()) {
-      return loadFromPrompt({
-        name: metadata.name,
-        systemPrompt: metadata.systemPrompt,
-        venues: metadata.venues,
-      });
-    }
-
-    if (metadata.template?.trim()) {
-      const template = getTemplate(metadata.template);
-      if (!template) {
-        throw new Error(`Unknown strategy template: ${metadata.template}. Available: momentum, value, arbitrage, hold`);
-      }
-      if (!template.systemPrompt.trim()) {
-        return holdStrategy;
-      }
-      return loadFromPrompt({
-        name: template.name,
-        systemPrompt: template.systemPrompt,
-        venues: metadata.venues?.length ? metadata.venues : template.venues,
-      });
-    }
-
-    throw new Error('Strategy file must define a systemPrompt or template. Executable strategy files are disabled.');
-  } catch (err) {
-    throw new Error(`Failed to load strategy from ${resolved}: ${(err as Error).message}`);
-  }
-}
-
-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 allowedVenues = config.venues?.filter(Boolean) ?? [];
-    const response = await context.llm.chat([
-      { role: 'system', content: config.systemPrompt },
-      {
-        role: 'user',
-        content: [
-          `Strategy: ${config.name || 'Prompt Strategy'}`,
-          `Allowed venues: ${allowedVenues.join(', ') || 'none configured'}`,
-          `Current prices: ${JSON.stringify(prices)}`,
-          `Open positions: ${JSON.stringify(positions)}`,
-          `Risk config: ${JSON.stringify(context.config)}`,
-          'Return ONLY a JSON array of trade intents. Do not include executable code. Do not invent fill IDs.',
-        ].join('\n'),
-      },
-    ]);
-
-    // Defense-in-depth: scrub any secrets the LLM might echo back before parsing
-    const scrubbedContent = scrubSecrets(response.content);
-
-    const jsonPayload = extractJsonArray(scrubbedContent);
-    if (!jsonPayload) {
-      context.log('Prompt strategy returned a non-JSON response; no signals emitted.');
-      return [];
-    }
-
-    try {
-      const parsed = promptSignalArraySchema.parse(JSON.parse(jsonPayload));
-      const signals: TradeSignal[] = [];
-      for (const signal of parsed) {
-        const venue = signal.venue || allowedVenues[0];
-        if (!venue) {
-          context.log(`Prompt strategy skipped ${signal.symbol}: no allowed venue configured.`);
-          continue;
-        }
-        if (allowedVenues.length > 0 && !allowedVenues.includes(venue)) {
-          context.log(`Prompt strategy skipped ${signal.symbol}: venue ${venue} is not allowed.`);
-          continue;
-        }
-
-        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,
-          chain: signal.chain,
-          size: signal.size ?? 0,
-          price,
-          fee: 0,
-          venueFillId: '',
-          venueTimestamp: '',
-          leverage: signal.leverage,
-          orderType: signal.orderType,
-        });
-      }
-      return signals;
-    } catch (err) {
-      context.log(`Prompt strategy parse failed: ${(err as Error).message}`);
-      return [];
-    }
-  };
-}
-
-function extractJsonArray(content: string): string | null {
-  const trimmed = content.trim();
-  if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
-    return trimmed;
-  }
-
-  const start = trimmed.indexOf('[');
-  const end = trimmed.lastIndexOf(']');
-  if (start === -1 || end === -1 || end <= start) {
-    return null;
-  }
-  return trimmed.slice(start, end + 1);
-}
-
-function parseStrategyMetadataModule(source: string, filePath: string): z.infer<typeof strategyMetadataSchema> {
-  const values: Record<string, unknown> = {};
-  let statement = '';
-
-  for (const rawLine of source.replace(/\r\n/g, '\n').split('\n')) {
-    const line = rawLine.trim();
-    if (!line || line.startsWith('//')) {
-      continue;
-    }
-
-    statement = statement ? `${statement}\n${rawLine}` : rawLine;
-    if (!line.endsWith(';')) {
-      continue;
-    }
-
-    const match = statement.match(/^\s*export\s+const\s+([A-Za-z_$][\w$]*)\s*=\s*([\s\S]*);\s*$/);
-    if (!match) {
-      throw new Error(`Unsupported statement in ${filePath}. Strategy files may only export JSON constants.`);
-    }
-
-    const [, name, rawValue] = match;
-    if (name === 'code') {
-      throw new Error('Raw JavaScript strategy code is disabled. Replace code with systemPrompt.');
-    }
-    if (!SUPPORTED_FILE_EXPORTS.has(name)) {
-      throw new Error(`Unsupported strategy export "${name}".`);
-    }
-
-    try {
-      values[name] = JSON.parse(rawValue.trim());
-    } catch {
-      throw new Error(`Strategy export "${name}" must be a JSON literal.`);
-    }
-
-    statement = '';
-  }
-
-  if (statement.trim()) {
-    throw new Error(`Unterminated export in ${filePath}.`);
-  }
-
-  return strategyMetadataSchema.parse(values);
-}
-
-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';
-}