📈 自主交易

概述

Eliza的自主交易系统在Solana区块链上实现了自动化代币交易。该系统集成了Jupiter聚合器以实现高效的交换，实施了智能订单路由，并包含风险管理功能。

核心组件

代币提供者

管理代币信息和市场数据：

class TokenProvider {
  constructor(
    private tokenAddress: string,
    private walletProvider: WalletProvider,
  ) {
    this.cache = new NodeCache({ stdTTL: 300 }); // 5分钟缓存
  }

  async fetchPrices(): Promise<Prices> {
    const { SOL, BTC, ETH } = TOKEN_ADDRESSES;
    // 获取当前价格
    return {
      solana: { usd: "0" },
      bitcoin: { usd: "0" },
      ethereum: { usd: "0" },
    };
  }

  async getProcessedTokenData(): Promise<ProcessedTokenData> {
    return {
      security: await this.fetchTokenSecurity(),
      tradeData: await this.fetchTokenTradeData(),
      holderDistributionTrend: await this.analyzeHolderDistribution(),
      highValueHolders: await this.filterHighValueHolders(),
      recentTrades: await this.checkRecentTrades(),
      dexScreenerData: await this.fetchDexScreenerData(),
    };
  }
}

交换执行

使用Jupiter实现代币交换：

async function swapToken(
  connection: Connection,
  walletPublicKey: PublicKey,
  inputTokenCA: string,
  outputTokenCA: string,
  amount: number,
): Promise<any> {
  // 获取代币小数位
  const decimals = await getTokenDecimals(connection, inputTokenCA);
  const adjustedAmount = amount * 10 ** decimals;

  // 获取报价
  const quoteResponse = await fetch(
    `https://quote-api.jup.ag/v6/quote?inputMint=${inputTokenCA}` +
      `&outputMint=${outputTokenCA}` +
      `&amount=${adjustedAmount}` +
      `&slippageBps=50`,
  );

  // 执行交换
  const swapResponse = await fetch("https://quote-api.jup.ag/v6/swap", {
    method: "POST",
    body: JSON.stringify({
      quoteResponse: await quoteResponse.json(),
      userPublicKey: walletPublicKey.toString(),
      wrapAndUnwrapSol: true,
    }),
  });

  return swapResponse.json();
}

头寸管理

订单簿系统

interface Order {
  userId: string;
  ticker: string;
  contractAddress: string;
  timestamp: string;
  buyAmount: number;
  price: number;
}

class OrderBookProvider {
  async addOrder(order: Order): Promise<void> {
    let orderBook = await this.readOrderBook();
    orderBook.push(order);
    await this.writeOrderBook(orderBook);
  }

  async calculateProfitLoss(userId: string): Promise<number> {
    const orders = await this.getUserOrders(userId);
    return orders.reduce((total, order) => {
      const currentPrice = this.getCurrentPrice(order.ticker);
      const pl = (currentPrice - order.price) * order.buyAmount;
      return total + pl;
    }, 0);
  }
}

头寸大小计算

async function calculatePositionSize(
  tokenData: ProcessedTokenData,
  riskLevel: "LOW" | "MEDIUM" | "HIGH",
): Promise<CalculatedBuyAmounts> {
  const { liquidity, marketCap } = tokenData.dexScreenerData.pairs[0];

  // 基于流动性的影响百分比
  const impactPercentages = {
    LOW: 0.01, // 1%的流动性
    MEDIUM: 0.05, // 5%的流动性
    HIGH: 0.1, // 10%的流动性
  };

  return {
    none: 0,
    low: liquidity.usd * impactPercentages.LOW,
    medium: liquidity.usd * impactPercentages.MEDIUM,
    high: liquidity.usd * impactPercentages.HIGH,
  };
}

风险管理

代币验证

async function validateToken(token: TokenPerformance): Promise<boolean> {
  const security = await fetchTokenSecurity(token.tokenAddress);

  // 红旗检查
  if (
    security.rugPull ||
    security.isScam ||
    token.rapidDump ||
    token.suspiciousVolume ||
    token.liquidity.usd < 1000 || // 最低$1000流动性
    token.marketCap < 100000 // 最低$100k市值
  ) {
    return false;
  }

  // 持有者分布检查
  const holderData = await fetchHolderList(token.tokenAddress);
  const topHolderPercent = calculateTopHolderPercentage(holderData);
  if (topHolderPercent > 0.5) {
    // 超过50%由顶级持有者持有
    return false;
  }

  return true;
}

交易管理

interface TradeManager {
    async executeTrade(params: {
        inputToken: string,
        outputToken: string,
        amount: number,
        slippage: number
    }): Promise<string>;

    async monitorPosition(params: {
        tokenAddress: string,
        entryPrice: number,
        stopLoss: number,
        takeProfit: number
    }): Promise<void>;

    async closePosition(params: {
        tokenAddress: string,
        amount: number
    }): Promise<string>;
}

市场分析

价格数据收集

async function collectMarketData(
  tokenAddress: string,
): Promise<TokenTradeData> {
  return {
    price: await fetchCurrentPrice(tokenAddress),
    volume_24h: await fetch24HourVolume(tokenAddress),
    price_change_24h: await fetch24HourPriceChange(tokenAddress),
    liquidity: await fetchLiquidity(tokenAddress),
    holder_data: await fetchHolderData(tokenAddress),
    trade_history: await fetchTradeHistory(tokenAddress),
  };
}

技术分析

function analyzeMarketConditions(tradeData: TokenTradeData): MarketAnalysis {
  return {
    trend: analyzePriceTrend(tradeData.price_history),
    volume_profile: analyzeVolumeProfile(tradeData.volume_history),
    liquidity_depth: analyzeLiquidityDepth(tradeData.liquidity),
    holder_behavior: analyzeHolderBehavior(tradeData.holder_data),
  };
}

交易执行

交换实现

async function executeSwap(
  runtime: IAgentRuntime,
  input: {
    tokenIn: string;
    tokenOut: string;
    amountIn: number;
    slippage: number;
  },
): Promise<string> {
  // 准备交易
  const { swapTransaction } = await getSwapTransaction(input);

  // 签署交易
  const keypair = getKeypairFromPrivateKey(
    runtime.getSetting("SOLANA_PRIVATE_KEY") ??
      runtime.getSetting("WALLET_PRIVATE_KEY"),
  );
  transaction.sign([keypair]);

  // 执行交换
  const signature = await connection.sendTransaction(transaction);

  // 确认交易
  await connection.confirmTransaction({
    signature,
    blockhash: latestBlockhash.blockhash,
    lastValidBlockHeight: latestBlockhash.lastValidBlockHeight,
  });

  return signature;
}

DAO集成

async function executeSwapForDAO(
  runtime: IAgentRuntime,
  params: {
    inputToken: string;
    outputToken: string;
    amount: number;
  },
): Promise<string> {
  const authority = getAuthorityKeypair(runtime);
  const [statePDA, walletPDA] = await derivePDAs(authority);

  // 准备指令数据
  const instructionData = prepareSwapInstruction(params);

  // 通过DAO执行交换
  return invokeSwapDao(
    connection,
    authority,
    statePDA,
    walletPDA,
    instructionData,
  );
}

监控与安全

健康检查

async function performHealthChecks(): Promise<HealthStatus> {
  return {
    connection: await checkConnectionStatus(),
    wallet: await checkWalletBalance(),
    orders: await checkOpenOrders(),
    positions: await checkPositions(),
  };
}

安全限制

const SAFETY_LIMITS = {
  MAX_POSITION_SIZE: 0.1, // 10%的投资组合
  MAX_SLIPPAGE: 0.05, // 5%的滑点
  MIN_LIQUIDITY: 1000, // 最低$1000流动性
  MAX_PRICE_IMPACT: 0.03, // 3%的价格影响
  STOP_LOSS: 0.15, // 15%的止损
};

错误处理

交易错误

async function handleTransactionError(
  error: Error,
  transaction: Transaction,
): Promise<void> {
  if (error.message.includes("insufficient funds")) {
    await handleInsufficientFunds();
  } else if (error.message.includes("slippage tolerance exceeded")) {
    await handleSlippageError(transaction);
  } else {
    await logTransactionError(error, transaction);
  }
}

恢复程序

async function recoverFromError(
  error: Error,
  context: TradingContext,
): Promise<void> {
  // 停止所有活跃交易
  await stopActiveTrades();

  // 关闭高风险头寸
  await closeRiskyPositions();

  // 重置系统状态
  await resetTradingState();

  // 通知管理员
  await notifyAdministrators(error, context);
}

---