swap_tokens_for_edu

Instructions

Implementation Reference

• src/swap.ts:1142-1244 (handler)

  Core handler function that performs the token-to-EDU swap: handles approvals, quoting via QuoterV2, executes Uniswap V3 swap to WETH9, unwraps to native EDU, and returns transaction details.

  export async function swapExactTokensForEDU(
    privateKey: string,
    tokenIn: string,
    amountIn: string,
    slippagePercentage: number = 0.5, // Default 0.5% slippage
    fee?: number
  ): Promise<{
    hash: string;
    from: string;
    amountIn: string;
    amountOut: string;
    tokenIn: string;
    tokenInSymbol: string;
  }> {
    try {
      const provider = blockchain.getProvider();
      const wallet = new ethers.Wallet(privateKey, provider);
      const fromAddress = wallet.address;
      
      // If fee is not provided, find the best route
      const route = await findBestRoute(tokenIn, CONTRACTS.WETH9);
      const fee = parseInt(route.path[0].feeTier);
      
      // Get token details
      const tokenInContract = new ethers.Contract(tokenIn, ERC20_ABI, provider);
      const tokenInDecimals = await tokenInContract.decimals();
      const tokenInSymbol = await tokenInContract.symbol();
      
      // Convert amount to token units
      const amountInWei = ethers.parseUnits(amountIn, tokenInDecimals);
      
      // Approve router to spend tokens
      const approveTx = await tokenInContract.approve(CONTRACTS.SwapRouter, amountInWei);
      await approveTx.wait();
      
      // Get quote for token to WETH (since we'll be using WETH internally)
      const quoterContract = new ethers.Contract(CONTRACTS.QuoterV2, QUOTER_ABI, provider);
      const quoteParams = {
        tokenIn,
        tokenOut: CONTRACTS.WETH9,
        amountIn: amountInWei,
        fee,
        sqrtPriceLimitX96: 0 // No price limit
      };
      
      // Use a static call to get the quote without sending a transaction
      const quoterInterface = new ethers.Interface(QUOTER_ABI);
      const calldata = quoterInterface.encodeFunctionData('quoteExactInputSingle', [quoteParams]);
      
      const result = await provider.call({
        to: CONTRACTS.QuoterV2,
        data: calldata,
      });
      
      const decodedResult = quoterInterface.decodeFunctionResult('quoteExactInputSingle', result);
      const amountOutWei = decodedResult[0]; // Get the first return value (amountOut)
      
      // Calculate minimum amount out with slippage
      const slippageFactor = 1000 - (slippagePercentage * 10); // Convert percentage to basis points
      const minAmountOut = (amountOutWei * BigInt(slippageFactor)) / BigInt(1000);
      
      // Create swap router contract
      const swapRouter = new ethers.Contract(CONTRACTS.SwapRouter, SWAP_ROUTER_ABI, wallet);
      
      // Execute swap
      const deadline = Math.floor(Date.now() / 1000) + 60 * 20; // 20 minutes from now
      
      // We need to swap to WETH and then unwrap it to ETH
      const swapParams = {
        tokenIn,
        tokenOut: CONTRACTS.WETH9,
        fee,
        recipient: CONTRACTS.SwapRouter, // Send to router for unwrapping
        deadline,
        amountIn: amountInWei,
        amountOutMinimum: minAmountOut,
        sqrtPriceLimitX96: 0 // No price limit
      };
      
      const tx = await swapRouter.exactInputSingle(swapParams);
      
      // Unwrap WETH to ETH and send to user
      await swapRouter.unwrapWETH9(minAmountOut, fromAddress);
      
      const receipt = await tx.wait();
      
      if (!receipt) {
        throw new Error('Transaction failed');
      }
      
      return {
        hash: tx.hash,
        from: fromAddress,
        amountIn,
        amountOut: ethers.formatEther(minAmountOut),
        tokenIn,
        tokenInSymbol
      };
    } catch (error) {
      console.error('Error swapping tokens for EDU:', error);
      throw error;
    }
  }

• src/index.ts:1222-1253 (registration)

  MCP CallToolRequestSchema handler case that invokes the swapExactTokensForEDU implementation with validated parameters and formats the response.

  case 'swap_tokens_for_edu': {
    if (!args.privateKey || typeof args.privateKey !== 'string') {
      throw new McpError(ErrorCode.InvalidParams, 'Private key is required');
    }
    
    if (!args.tokenIn || typeof args.tokenIn !== 'string') {
      throw new McpError(ErrorCode.InvalidParams, 'Input token address is required');
    }
    
    if (!args.amountIn || typeof args.amountIn !== 'string') {
      throw new McpError(ErrorCode.InvalidParams, 'Input amount is required');
    }
    
    const slippagePercentage = typeof args.slippagePercentage === 'number' ? args.slippagePercentage : 0.5;
    const fee = typeof args.fee === 'number' ? args.fee : 3000; // Default to 0.3%
    
    const result = await swap.swapExactTokensForEDU(
      args.privateKey,
      args.tokenIn,
      args.amountIn,
      slippagePercentage
    );
    
    return {
      content: [
        {
          type: 'text',
          text: JSON.stringify(result, null, 2),
        },
      ],
    };
  }

• src/index.ts:582-609 (schema)

  Tool schema definition in ListToolsRequestSchema response, specifying name, description, and input parameters for MCP tool invocation.

  name: 'swap_tokens_for_edu',
  description: 'Swap tokens for EDU on SailFish DEX',
  inputSchema: {
    type: 'object',
    properties: {
      privateKey: {
        type: 'string',
        description: 'Private key of the sender wallet',
      },
      tokenIn: {
        type: 'string',
        description: 'Address of the input token',
      },
      amountIn: {
        type: 'string',
        description: 'Amount of tokens to swap',
      },
      slippagePercentage: {
        type: 'number',
        description: 'Slippage tolerance percentage (default: 0.5)',
      },
      fee: {
        type: 'number',
        description: 'Fee tier (100=0.01%, 500=0.05%, 3000=0.3%, 10000=1%)',
      },
    },
    required: ['privateKey', 'tokenIn', 'amountIn'],
  },

• src/index.ts:17-18 (registration)

  Import of swap module in index.ts, providing access to swapExactTokensForEDU function for tool handlers.

  import * as swap from './swap.js';
  import * as external_market from './external_market.js';

• src/swap.ts:560-580 (helper)

  Helper function used by swapExactTokensForEDU to find the best liquidity route via subgraph queries.

  export async function findBestRoute(
    tokenA: string,
    tokenB: string
  ): Promise<routes.RouteInfo> {
    try {
      // Get the best route from the routes module
      const bestRoute = await routes.getBestRoute(tokenA, tokenB);
      
      if (!bestRoute) {
        throw new Error(`No route found for token pair ${tokenA}/${tokenB}`);
      }
      
      // Remove console.log to prevent interference with JSON parsing
      // console.log(`Found ${bestRoute.type} route for ${tokenA}/${tokenB} with fee: ${bestRoute.totalFee * 100}%`);
      
      return bestRoute;
    } catch (error) {
      console.error('Error finding best route:', error);
      throw error;
    }
  }