MEV与交易优化

// scripts/frontrun-detector.ts
import { ethers } from "ethers";
import { FlashbotsBundleProvider } from "@flashbots/ethers-provider-bundle";

class FrontRunDetector {
  private provider: ethers.WebSocketProvider;
  private wallet: ethers.Wallet;
  private flashbotsProvider: FlashbotsBundleProvider;

  // 监控的DEX路由器地址
  private monitoredDexes = [
    "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D", // Uniswap V2
    "0xd9e1cE17f2641f24aE83637ab66a2cca9C378B9F", // Sushiswap
  ];

  constructor(rpcUrl: string, privateKey: string) {
    this.provider = new ethers.WebSocketProvider(rpcUrl);
    this.wallet = new ethers.Wallet(privateKey, this.provider);
  }

  async init() {
    this.flashbotsProvider = await FlashbotsBundleProvider.create(
      this.provider,
      this.wallet,
      "https://relay.flashbots.net",
      "goerli" // or "mainnet"
    );
  }

  // 监听mempool中的待处理交易
  async monitorMempool() {
    console.log("Monitoring mempool for opportunities...");

    this.provider.on("pending", async (txHash) => {
      try {
        const tx = await this.provider.getTransaction(txHash);

        if (!tx || !tx.to) return;

        // 检查是否是DEX交易
        if (this.monitoredDexes.includes(tx.to.toLowerCase())) {
          await this.analyzeTrade(tx);
        }
      } catch (error) {
        // 交易可能已被打包，忽略错误
      }
    });
  }

  // 分析交易
  private async analyzeTrade(tx: ethers.TransactionResponse) {
    try {
      const iface = new ethers.Interface([
        "function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)",
        "function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)",
        "function swapExactTokensForTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)",
      ]);

      const decodedData = iface.parseTransaction({
        data: tx.data,
        value: tx.value
      });

      if (!decodedData) return;

      console.log("Detected swap:", {
        method: decodedData.name,
        from: tx.from,
        gasPrice: ethers.formatUnits(tx.gasPrice || 0, "gwei"),
      });

      // 评估是否值得抢跑
      const profitable = await this.evaluateFrontrun(tx, decodedData);

      if (profitable) {
        await this.executeFrontrun(tx);
      }
    } catch (error) {
      // 解析失败，可能不是swap交易
    }
  }

  // 评估抢跑是否有利可图
  private async evaluateFrontrun(
    originalTx: ethers.TransactionResponse,
    decodedData: ethers.TransactionDescription
  ): Promise<boolean> {
    // 简化的评估逻辑
    const amountIn = decodedData.args[0];
    const path = decodedData.args[1] || decodedData.args[2];

    // 检查交易大小
    const minTradeSize = ethers.parseEther("1"); // 1 ETH或等值代币
    if (amountIn < minTradeSize) {
      return false;
    }

    // 模拟交易，计算潜在利润
    // 这里需要具体的DEX合约接口来获取价格影响

    return true; // 简化示例
  }

  // 执行抢跑
  private async executeFrontrun(originalTx: ethers.TransactionResponse) {
    console.log("Executing frontrun...");

    // 创建抢跑交易
    const frontrunTx = {
      to: originalTx.to,
      data: originalTx.data,
      value: originalTx.value,
      gasPrice: (originalTx.gasPrice || 0n) + ethers.parseUnits("10", "gwei"),
      gasLimit: originalTx.gasLimit,
    };

    try {
      const tx = await this.wallet.sendTransaction(frontrunTx);
      console.log("Frontrun tx sent:", tx.hash);

      const receipt = await tx.wait();
      console.log("Frontrun successful in block:", receipt?.blockNumber);
    } catch (error: any) {
      console.error("Frontrun failed:", error.message);
    }
  }

  // 使用Flashbots避免失败交易上链
  private async executeFrontrunWithFlashbots(
    originalTx: ethers.TransactionResponse,
    targetBlockNumber: number
  ) {
    const frontrunTx = {
      signer: this.wallet,
      transaction: {
        to: originalTx.to,
        data: originalTx.data,
        value: originalTx.value,
        gasLimit: originalTx.gasLimit,
      },
    };

    const signedBundle = await this.flashbotsProvider.signBundle([frontrunTx]);

    const simulation = await this.flashbotsProvider.simulate(
      signedBundle,
      targetBlockNumber
    );

    if ("error" in simulation) {
      console.error("Simulation error:", simulation.error);
      return;
    }

    console.log("Simulation success:", simulation);

    const bundleSubmission = await this.flashbotsProvider.sendRawBundle(
      signedBundle,
      targetBlockNumber
    );

    console.log("Bundle submitted:", bundleSubmission.bundleHash);
  }
}

// 使用示例
async function main() {
  const detector = new FrontRunDetector(
    process.env.WSS_RPC_URL!,
    process.env.PRIVATE_KEY!
  );

  await detector.init();
  await detector.monitorMempool();
}

main().catch(console.error);

// scripts/sandwich-detector.ts
import { ethers } from "ethers";

interface PendingSwap {
  hash: string;
  from: string;
  to: string;
  value: bigint;
  gasPrice: bigint;
  data: string;
  timestamp: number;
}

class SandwichDetector {
  private provider: ethers.WebSocketProvider;
  private pendingSwaps: Map<string, PendingSwap> = new Map();

  constructor(rpcUrl: string) {
    this.provider = new ethers.WebSocketProvider(rpcUrl);
  }

  async detectSandwiches() {
    this.provider.on("pending", async (txHash) => {
      try {
        const tx = await this.provider.getTransaction(txHash);
        if (!tx) return;

        // 记录swap交易
        if (this.isSwapTransaction(tx)) {
          this.pendingSwaps.set(txHash, {
            hash: txHash,
            from: tx.from,
            to: tx.to || "",
            value: tx.value,
            gasPrice: tx.gasPrice || 0n,
            data: tx.data,
            timestamp: Date.now(),
          });
        }
      } catch (error) {
        // ignore
      }
    });

    this.provider.on("block", async (blockNumber) => {
      await this.analyzeBlock(blockNumber);
    });
  }

  private isSwapTransaction(tx: ethers.TransactionResponse): boolean {
    const swapSelectors = [
      "0x38ed1739", // swapExactTokensForTokens
      "0x7ff36ab5", // swapExactETHForTokens
      "0x18cbafe5", // swapExactTokensForETH
    ];

    return swapSelectors.some(selector =>
      tx.data.toLowerCase().startsWith(selector)
    );
  }

  private async analyzeBlock(blockNumber: number) {
    const block = await this.provider.getBlock(blockNumber, true);
    if (!block || !block.transactions) return;

    const transactions = block.transactions as ethers.TransactionResponse[];

    // 检测三明治模式
    for (let i = 1; i < transactions.length - 1; i++) {
      const prev = transactions[i - 1];
      const curr = transactions[i];
      const next = transactions[i + 1];

      if (this.isSandwich(prev, curr, next)) {
        console.log("Sandwich attack detected!");
        console.log("Frontrun tx:", prev.hash);
        console.log("Victim tx:", curr.hash);
        console.log("Backrun tx:", next.hash);

        await this.calculateSandwichProfit(prev, curr, next);
      }
    }

    // 清理旧的pending交易
    this.cleanupPendingSwaps();
  }

  private isSandwich(
    tx1: ethers.TransactionResponse,
    tx2: ethers.TransactionResponse,
    tx3: ethers.TransactionResponse
  ): boolean {
    // 检查是否是同一个发送者
    if (tx1.from !== tx3.from) return false;

    // 检查是否都是swap交易
    if (!this.isSwapTransaction(tx1) ||
        !this.isSwapTransaction(tx2) ||
        !this.isSwapTransaction(tx3)) {
      return false;
    }

    // 检查Gas价格模式
    const gas1 = tx1.gasPrice || 0n;
    const gas2 = tx2.gasPrice || 0n;
    const gas3 = tx3.gasPrice || 0n;

    // 攻击者的交易通常有更高的Gas
    return gas1 > gas2 && gas3 > gas2;
  }

  private async calculateSandwichProfit(
    frontrun: ethers.TransactionResponse,
    victim: ethers.TransactionResponse,
    backrun: ethers.TransactionResponse
  ) {
    try {
      const frontrunReceipt = await this.provider.getTransactionReceipt(frontrun.hash);
      const backrunReceipt = await this.provider.getTransactionReceipt(backrun.hash);

      if (!frontrunReceipt || !backrunReceipt) return;

      // 分析logs来计算实际交换量
      // 这里需要解析Transfer事件

      console.log("Sandwich profit analysis:");
      console.log("Frontrun gas cost:",
        ethers.formatEther((frontrunReceipt.gasUsed * frontrun.gasPrice!) || 0));
      console.log("Backrun gas cost:",
        ethers.formatEther((backrunReceipt.gasUsed * backrun.gasPrice!) || 0));
    } catch (error) {
      console.error("Error calculating profit:", error);
    }
  }

  private cleanupPendingSwaps() {
    const now = Date.now();
    const timeout = 60000; // 1分钟

    for (const [hash, swap] of this.pendingSwaps.entries()) {
      if (now - swap.timestamp > timeout) {
        this.pendingSwaps.delete(hash);
      }
    }
  }
}

// 使用
async function main() {
  const detector = new SandwichDetector(process.env.WSS_RPC_URL!);
  await detector.detectSandwiches();
  console.log("Sandwich detector running...");
}

main().catch(console.error);

// scripts/flashbots-example.ts
import { ethers } from "ethers";
import { FlashbotsBundleProvider, FlashbotsBundleResolution } from "@flashbots/ethers-provider-bundle";

async function main() {
  const provider = new ethers.JsonRpcProvider(process.env.RPC_URL);
  const authSigner = new ethers.Wallet(process.env.PRIVATE_KEY!);
  const wallet = new ethers.Wallet(process.env.PRIVATE_KEY!, provider);

  // 连接到Flashbots relay
  const flashbotsProvider = await FlashbotsBundleProvider.create(
    provider,
    authSigner,
    "https://relay.flashbots.net",
    "mainnet"
  );

  // 获取当前区块号
  const block = await provider.getBlock("latest");
  const targetBlockNumber = block!.number + 1;

  // 创建交易
  const tokenAddress = "0x..."; // ERC20代币地址
  const token = new ethers.Contract(
    tokenAddress,
    ["function transfer(address to, uint256 amount) returns (bool)"],
    wallet
  );

  const transaction = await token.transfer.populateTransaction(
    "0xRecipientAddress",
    ethers.parseEther("100")
  );

  // 创建bundle
  const signedTransactions = await flashbotsProvider.signBundle([
    {
      signer: wallet,
      transaction: transaction,
    },
  ]);

  // 模拟bundle
  const simulation = await flashbotsProvider.simulate(
    signedTransactions,
    targetBlockNumber
  );

  console.log("Simulation result:", simulation);

  if ("error" in simulation) {
    console.error("Simulation failed:", simulation.error);
    return;
  }

  // 发送bundle
  const bundleSubmission = await flashbotsProvider.sendRawBundle(
    signedTransactions,
    targetBlockNumber
  );

  console.log("Bundle submitted:", bundleSubmission.bundleHash);

  // 等待bundle被打包
  const waitResponse = await bundleSubmission.wait();

  if (waitResponse === FlashbotsBundleResolution.BundleIncluded) {
    console.log("Bundle included in block!");
  } else if (waitResponse === FlashbotsBundleResolution.BlockPassedWithoutInclusion) {
    console.log("Bundle not included in target block");
  } else if (waitResponse === FlashbotsBundleResolution.AccountNonceTooHigh) {
    console.log("Nonce too high");
  }
}

main().catch(console.error);

// scripts/mev-bot.ts
import { ethers } from "ethers";
import { FlashbotsBundleProvider } from "@flashbots/ethers-provider-bundle";

interface ArbitrageOpportunity {
  tokenIn: string;
  tokenOut: string;
  amountIn: bigint;
  expectedProfit: bigint;
  dexPath: string[];
}

class MEVBot {
  private provider: ethers.WebSocketProvider;
  private wallet: ethers.Wallet;
  private flashbotsProvider: FlashbotsBundleProvider;
  private arbitrageContract: ethers.Contract;

  // DEX路由器
  private dexRouters = {
    uniswap: "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D",
    sushiswap: "0xd9e1cE17f2641f24aE83637ab66a2cca9C378B9F",
  };

  // 监控的交易对
  private watchedPairs = [
    { token0: "WETH", token1: "USDC" },
    { token0: "WETH", token1: "USDT" },
    { token0: "WETH", token1: "DAI" },
  ];

  constructor(
    rpcUrl: string,
    privateKey: string,
    arbitrageContractAddress: string
  ) {
    this.provider = new ethers.WebSocketProvider(rpcUrl);
    this.wallet = new ethers.Wallet(privateKey, this.provider);

    this.arbitrageContract = new ethers.Contract(
      arbitrageContractAddress,
      [
        "function simpleArbitrage(address token0, address token1, uint256 amountIn, bool buyOnUniswap) external",
      ],
      this.wallet
    );
  }

  async init() {
    this.flashbotsProvider = await FlashbotsBundleProvider.create(
      this.provider,
      this.wallet,
      "https://relay.flashbots.net",
      "mainnet"
    );

    console.log("MEV Bot initialized");
  }

  async start() {
    console.log("Starting MEV Bot...");

    // 监听新区块
    this.provider.on("block", async (blockNumber) => {
      await this.scanForOpportunities(blockNumber);
    });

    // 监听mempool
    this.monitorMempool();
  }

  private async scanForOpportunities(blockNumber: number) {
    console.log(`Scanning block ${blockNumber}...`);

    for (const pair of this.watchedPairs) {
      const opportunity = await this.findArbitrageOpportunity(
        pair.token0,
        pair.token1
      );

      if (opportunity && opportunity.expectedProfit > ethers.parseEther("0.01")) {
        console.log("Opportunity found:", opportunity);
        await this.executeArbitrage(opportunity, blockNumber + 1);
      }
    }
  }

  private async findArbitrageOpportunity(
    token0: string,
    token1: string
  ): Promise<ArbitrageOpportunity | null> {
    try {
      // 获取两个DEX的价格
      const uniswapPrice = await this.getPrice(
        this.dexRouters.uniswap,
        token0,
        token1
      );
      const sushiswapPrice = await this.getPrice(
        this.dexRouters.sushiswap,
        token0,
        token1
      );

      const priceDiff = uniswapPrice > sushiswapPrice
        ? (uniswapPrice - sushiswapPrice) * 10000n / sushiswapPrice
        : (sushiswapPrice - uniswapPrice) * 10000n / uniswapPrice;

      // 价格差异需要大于0.5%
      if (priceDiff < 50n) {
        return null;
      }

      const amountIn = ethers.parseEther("1"); // 1 ETH或等值代币
      const expectedProfit = await this.calculateProfit(
        token0,
        token1,
        amountIn,
        uniswapPrice > sushiswapPrice
      );

      if (expectedProfit <= 0n) {
        return null;
      }

      return {
        tokenIn: token0,
        tokenOut: token1,
        amountIn,
        expectedProfit,
        dexPath: uniswapPrice > sushiswapPrice
          ? ["sushiswap", "uniswap"]
          : ["uniswap", "sushiswap"],
      };
    } catch (error) {
      return null;
    }
  }

  private async getPrice(
    router: string,
    token0: string,
    token1: string
  ): Promise<bigint> {
    const routerContract = new ethers.Contract(
      router,
      [
        "function getAmountsOut(uint amountIn, address[] memory path) view returns (uint[] memory amounts)",
      ],
      this.provider
    );

    const amounts = await routerContract.getAmountsOut(
      ethers.parseEther("1"),
      [token0, token1]
    );

    return amounts[1];
  }

  private async calculateProfit(
    token0: string,
    token1: string,
    amountIn: bigint,
    buyOnUniswap: boolean
  ): Promise<bigint> {
    // 简化的利润计算
    // 实际应该考虑滑点、Gas费用等

    const buyRouter = buyOnUniswap
      ? this.dexRouters.uniswap
      : this.dexRouters.sushiswap;
    const sellRouter = buyOnUniswap
      ? this.dexRouters.sushiswap
      : this.dexRouters.uniswap;

    const buyAmount = await this.getAmountOut(buyRouter, token0, token1, amountIn);
    const sellAmount = await this.getAmountOut(sellRouter, token1, token0, buyAmount);

    const gasCost = ethers.parseEther("0.005"); // 估算Gas费用

    return sellAmount > amountIn + gasCost ? sellAmount - amountIn - gasCost : 0n;
  }

  private async getAmountOut(
    router: string,
    tokenIn: string,
    tokenOut: string,
    amountIn: bigint
  ): Promise<bigint> {
    const routerContract = new ethers.Contract(
      router,
      [
        "function getAmountsOut(uint amountIn, address[] memory path) view returns (uint[] memory amounts)",
      ],
      this.provider
    );

    const amounts = await routerContract.getAmountsOut(amountIn, [
      tokenIn,
      tokenOut,
    ]);

    return amounts[1];
  }

  private async executeArbitrage(
    opportunity: ArbitrageOpportunity,
    targetBlock: number
  ) {
    console.log("Executing arbitrage...");

    try {
      const buyOnUniswap = opportunity.dexPath[0] === "uniswap";

      const transaction = await this.arbitrageContract.simpleArbitrage.populateTransaction(
        opportunity.tokenIn,
        opportunity.tokenOut,
        opportunity.amountIn,
        buyOnUniswap
      );

      // 使用Flashbots发送
      const signedBundle = await this.flashbotsProvider.signBundle([
        {
          signer: this.wallet,
          transaction: transaction,
        },
      ]);

      const simulation = await this.flashbotsProvider.simulate(
        signedBundle,
        targetBlock
      );

      if ("error" in simulation) {
        console.error("Simulation failed:", simulation.error);
        return;
      }

      console.log("Simulation successful, submitting bundle...");

      const bundleSubmission = await this.flashbotsProvider.sendRawBundle(
        signedBundle,
        targetBlock
      );

      console.log("Bundle submitted:", bundleSubmission.bundleHash);

      const resolution = await bundleSubmission.wait();
      console.log("Bundle resolution:", resolution);
    } catch (error: any) {
      console.error("Arbitrage execution failed:", error.message);
    }
  }

  private monitorMempool() {
    // 监听待处理交易，寻找sandwich机会
    this.provider.on("pending", async (txHash) => {
      // 实现sandwich检测逻辑
    });
  }
}

// 启动MEV Bot
async function main() {
  const bot = new MEVBot(
    process.env.WSS_RPC_URL!,
    process.env.PRIVATE_KEY!,
    process.env.ARBITRAGE_CONTRACT!
  );

  await bot.init();
  await bot.start();

  console.log("MEV Bot is running...");
}

main().catch(console.error);

// scripts/mev-analytics.ts
import { ethers } from "ethers";

interface MEVTransaction {
  blockNumber: number;
  txIndex: number;
  hash: string;
  from: string;
  to: string;
  value: bigint;
  gasPrice: bigint;
  gasUsed: bigint;
  type: "frontrun" | "sandwich" | "arbitrage" | "liquidation";
  profit?: bigint;
}

class MEVAnalytics {
  private provider: ethers.JsonRpcProvider;
  private mevTransactions: MEVTransaction[] = [];

  constructor(rpcUrl: string) {
    this.provider = new ethers.JsonRpcProvider(rpcUrl);
  }

  async analyzeBlocks(startBlock: number, endBlock: number) {
    console.log(`Analyzing blocks ${startBlock} to ${endBlock}...`);

    for (let i = startBlock; i <= endBlock; i++) {
      await this.analyzeBlock(i);
    }

    this.generateReport();
  }

  private async analyzeBlock(blockNumber: number) {
    const block = await this.provider.getBlock(blockNumber, true);
    if (!block || !block.transactions) return;

    const txs = block.transactions as ethers.TransactionResponse[];

    for (let i = 0; i < txs.length; i++) {
      const mevType = await this.detectMEVType(txs, i);

      if (mevType) {
        const receipt = await this.provider.getTransactionReceipt(txs[i].hash);

        this.mevTransactions.push({
          blockNumber,
          txIndex: i,
          hash: txs[i].hash,
          from: txs[i].from,
          to: txs[i].to || "",
          value: txs[i].value,
          gasPrice: txs[i].gasPrice || 0n,
          gasUsed: receipt?.gasUsed || 0n,
          type: mevType,
        });
      }
    }
  }

  private async detectMEVType(
    txs: ethers.TransactionResponse[],
    index: number
  ): Promise<MEVTransaction["type"] | null> {
    // 检测sandwich
    if (index > 0 && index < txs.length - 1) {
      if (this.isSandwich(txs[index - 1], txs[index], txs[index + 1])) {
        return "sandwich";
      }
    }

    // 检测arbitrage
    if (await this.isArbitrage(txs[index])) {
      return "arbitrage";
    }

    // 检测liquidation
    if (await this.isLiquidation(txs[index])) {
      return "liquidation";
    }

    return null;
  }

  private isSandwich(
    tx1: ethers.TransactionResponse,
    tx2: ethers.TransactionResponse,
    tx3: ethers.TransactionResponse
  ): boolean {
    return tx1.from === tx3.from &&
           (tx1.gasPrice || 0n) > (tx2.gasPrice || 0n) &&
           (tx3.gasPrice || 0n) > (tx2.gasPrice || 0n);
  }

  private async isArbitrage(tx: ethers.TransactionResponse): Promise<boolean> {
    // 检查是否包含多次swap
    // 简化检测逻辑
    return false;
  }

  private async isLiquidation(tx: ethers.TransactionResponse): Promise<boolean> {
    // 检查是否调用了liquidation函数
    return tx.data.includes("0xbd6d894d"); // liquidate selector
  }

  private generateReport() {
    console.log("\n=== MEV Analysis Report ===\n");

    const typeCount = this.mevTransactions.reduce((acc, tx) => {
      acc[tx.type] = (acc[tx.type] || 0) + 1;
      return acc;
    }, {} as Record<string, number>);

    console.log("MEV Transaction Types:");
    for (const [type, count] of Object.entries(typeCount)) {
      console.log(`  ${type}: ${count}`);
    }

    const totalGasUsed = this.mevTransactions.reduce(
      (sum, tx) => sum + (tx.gasUsed * tx.gasPrice),
      0n
    );

    console.log(`\nTotal Gas Spent: ${ethers.formatEther(totalGasUsed)} ETH`);
    console.log(`Total MEV Transactions: ${this.mevTransactions.length}`);

    // 导出数据
    const fs = require("fs");
    fs.writeFileSync(
      "mev-report.json",
      JSON.stringify(this.mevTransactions, (_, v) =>
        typeof v === "bigint" ? v.toString() : v
      , 2)
    );

    console.log("\nDetailed report saved to mev-report.json");
  }
}

async function main() {
  const analytics = new MEVAnalytics(process.env.RPC_URL!);

  const latestBlock = await analytics["provider"].getBlockNumber();
  await analytics.analyzeBlocks(latestBlock - 100, latestBlock);
}

main().catch(console.error);