Building a Simple Arbitrage Bot for DEXs

Detailed Instructions

Price monitoring is the core function of the arbitrage bot. You must fetch real-time price data for the same token pair (e.g., WETH/USDC) from multiple DEXs like Uniswap V3, SushiSwap, and Balancer. This involves querying the on-chain liquidity pools to calculate the effective price, factoring in fees and slippage.

• Sub-step 1: Set up WebSocket or RPC listeners to subscribe to new block events on Ethereum Mainnet (Chain ID: 1) or other supported chains.
• Sub-step 2: For each monitored pool, call the getReserves() function on the pair contract to obtain the current token reserves.
• Sub-step 3: Calculate the implied price using the reserve ratio. For a constant product AMM, price = reserve_tokenB / reserve_tokenA.
• Sub-step 4: Store and compare prices in a local database, flagging instances where the price difference exceeds your predefined profit threshold (e.g., 0.5%).

Tip: Use multicall contracts (e.g., MakerDAO's Multicall2) to batch read calls and reduce RPC load and latency, which is critical for speed.

Detailed Instructions

Once a price discrepancy is detected, you must perform arbitrage path calculation. This involves simulating the trade to account for all costs and ensure a net positive gain. The simplest path is a direct two-pool swap (Buy on DEX A, Sell on DEX B), but you may need a multi-hop route through a bridge token like WETH.

• Sub-step 1: For each opportunity, simulate the swap using the getAmountsOut function of the router contract (e.g., Uniswap V2 Router 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D).
• Sub-step 2: Account for all transaction costs, including DEX swap fees (typically 0.3% or 0.05% for V3), network gas fees (estimate using eth_gasPrice), and your bot's operational overhead.
• Sub-step 3: Calculate the net profit in a stable denomination (e.g., USD). The formula is: Profit = Output_Amount - Input_Amount - Total_Costs. Only proceed if profit > your minimum (e.g., $10).
• Sub-step 4: Determine the optimal gas price using a service like Etherscan's Gas Tracker to balance speed and cost, aiming for a base fee + priority fee that ensures inclusion in the next 1-2 blocks.

Tip: Implement a circuit breaker that discards opportunities if the calculated profit margin is below 0.1% after costs, as these are often unprofitable due to price movement.

Detailed Instructions

Transaction construction must be fast and atomic to avoid front-running and sandwich attacks. The entire arbitrage sequence should be executed within a single transaction using a smart contract, often called a flash loan arbitrage contract, to avoid capital risk.

• Sub-step 1: If using a flash loan, initiate a loan from a provider like Aave (LendingPool address: 0x7d2768dE32b0b80b7a3454c06BdAc94A69DDc7A9) for the required input amount. The entire logic must be in the executeOperation callback.
• Sub-step 2: Encode the swap calls. For example, to swap on Uniswap V2, you would encode a call to swapExactTokensForTokens.

solidityCopy
// Example encoded call for a swap
bytes memory data = abi.encodeWithSelector(
    IUniswapV2Router02.swapExactTokensForTokens.selector,
    1000000000000000000, // amountIn (1 ETH)
    0, // amountOutMin (calculated earlier)
    path, // address[] e.g., [WETH, USDC]
    address(this), // to
    block.timestamp + 300 // deadline
);

• Sub-step 3: Sign the transaction using your bot's private key (securely stored in an environment variable) with a high nonce to ensure it's processed immediately.
• Sub-step 4: Broadcast via a reliable node provider (e.g., Alchemy, Infura) using eth_sendRawTransaction.

Tip: Use a private transaction pool (e.g., Flashbots RPC) to submit your transaction directly to miners/validators, mitigating front-running by keeping it out of the public mempool.

Detailed Instructions

Post-trade verification is critical to ensure the bot's actions were successful and profitable. You must listen for transaction receipts and parse logs to confirm the expected amounts were received and to update your accounting.

• Sub-step 1: Monitor the transaction hash for confirmation. Poll eth_getTransactionReceipt until it returns a status of 0x1 (success). A status of 0x0 indicates a revert, requiring error analysis.
• Sub-step 2: Parse the transaction logs to extract the actual amountOut events. Compare this to your simulated profit. A significant deviation may indicate slippage or being out-prioritized by another bot.
• Sub-step 3: If a flash loan was used, verify the loan was repaid by checking the final balance of your contract. The contract should end with a positive balance representing the profit.
• Sub-step 4: Securely transfer profits to your treasury wallet (e.g., 0xYourTreasuryAddress) by calling a withdrawProfit function in your contract. Update your internal ledger and database with the trade details: timestamp, pair, profit, gas used, and net ROI.
• Sub-step 5: Implement alerting for failed transactions or profitability below a certain threshold. Use tools like Discord webhooks or PagerDuty to notify you of critical issues.

Tip: Maintain a fallback RPC endpoint (e.g., a secondary Infura project ID) to switch to if your primary node provider fails during this critical verification phase.

Detailed Instructions

Begin by creating a new Node.js project and installing core dependencies. The most critical package is ethers.js v6, which provides the interface for connecting to the Ethereum blockchain and interacting with smart contracts. You'll also need axios or a similar HTTP client for fetching price data from DEX APIs and dotenv for managing private keys and RPC URLs securely.

• Sub-step 1: Run npm init -y to create a package.json file.
• Sub-step 2: Install dependencies: npm install ethers@6 axios dotenv.
• Sub-step 3: Create a .env file to store your sensitive data: PRIVATE_KEY=your_wallet_private_key, INFURA_URL=https://mainnet.infura.io/v3/YOUR_API_KEY.
• Sub-step 4: Set up the basic project structure with index.js as the main entry point and a config.js file for constants like DEX router addresses (e.g., Uniswap V2: 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D).

Tip: Never commit your .env file to version control. Use a .gitignore file to exclude it.

Detailed Instructions

This step involves creating the foundational objects that allow your bot to read blockchain data and send transactions. You will instantiate a JSON-RPC Provider using a service like Infura or Alchemy to connect to the network. Then, you'll create a Wallet object from your private key, which is linked to the provider for signing.

• Sub-step 1: Import ethers and load environment variables in your main script.
• Sub-step 2: Create the provider: const provider = new ethers.JsonRpcProvider(process.env.INFURA_URL);.
• Sub-step 3: Create the wallet: const wallet = new ethers.Wallet(process.env.PRIVATE_KEY, provider);. This wallet will be used to pay for gas and sign arbitrage transactions.
• Sub-step 4: Verify the connection by fetching the wallet's balance: const balance = await provider.getBalance(wallet.address); console.log(Balance: ${ethers.formatEther(balance)} ETH);.

Tip: For mainnet testing, start with a Sepolia testnet provider and use test ETH to avoid losing real funds during development.

Detailed Instructions

The core arbitrage logic starts here. You need to fetch the exchange rate for a specific token pair (e.g., WETH/USDC) from at least two DEXs, such as Uniswap V2 and Sushiswap. This involves interacting with the DEX's router contract to get quotes or directly reading the reserves from the pair contract.

• Sub-step 1: Define the token addresses. For example, use WETH (0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2) and USDC (0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48).
• Sub-step 2: Create contract instances for the DEX routers using the ABI and address. For a simple quote, you can call the getAmountsOut function.

javascriptCopy
const uniswapRouter = new ethers.Contract(UNISWAP_V2_ROUTER, ['function getAmountsOut(uint amountIn, address[] memory path) view returns (uint[] memory amounts)'], provider);
const amounts = await uniswapRouter.getAmountsOut(ethers.parseEther('1'), [WETH, USDC]);
const uniswapPrice = amounts[1]; // Output amount in USDC

• Sub-step 3: Repeat Sub-step 2 for a second DEX (e.g., Sushiswap Router: 0xd9e1cE17f2641f24aE83637ab66a2cca9C378B9F).
• Sub-step 4: Calculate the price difference percentage. An opportunity exists if the difference exceeds your minimum profit threshold (e.g., 0.5%) after accounting for gas fees.

Detailed Instructions

Once a profitable opportunity is identified, your bot must execute a swap transaction. This involves constructing the transaction data for the swapExactTokensForTokens function on the DEX router with the more favorable price. You must set a slippage tolerance and ensure the transaction is sent with appropriate gas settings.

• Sub-step 1: Calculate the exact input amount you wish to trade, starting with a small test amount (e.g., 0.01 WETH).
• Sub-step 2: Define the path (token addresses array) and the minimum amount of output tokens you will accept, applying your slippage (e.g., 0.5%): minAmountOut = expectedOutput * 0.995.
• Sub-step 3: Connect the router contract with your wallet to create a signer contract: const routerWithSigner = uniswapRouter.connect(wallet);.
• Sub-step 4: Call the swap function and wait for confirmation.

javascriptCopy
const tx = await routerWithSigner.swapExactTokensForTokens(
    ethers.parseEther('0.01'), // amountIn
    minAmountOut, // amountOutMin
    [WETH, USDC], // path
    wallet.address, // to
    Math.floor(Date.now() / 1000) + 120 // deadline (2 minutes)
);
const receipt = await tx.wait();
console.log(`Transaction mined in block ${receipt.blockNumber}`);

• Sub-step 5: Implement error handling (try/catch) for failed transactions and revert conditions.

Tip: Always use a deadline parameter to prevent pending transactions from being executed at unfavorable prices much later.

Detailed Instructions

A functional bot runs continuously. You need to implement a polling loop that checks prices at regular intervals (e.g., every 10 seconds). Additionally, you should track the bot's starting capital and profit/loss over time to evaluate its performance.

• Sub-step 1: Wrap the price fetching and execution logic (Steps 3 & 4) inside an async function like checkAndExecuteArbitrage().
• Sub-step 2: Use setInterval to call this function periodically: setInterval(checkAndExecuteArbitrage, 10000);.
• Sub-step 3: Initialize variables to track the wallet's balance in the quote token (e.g., USDC) before starting the loop.
• Sub-step 4: After each successful trade, calculate the profit by comparing the new USDC balance to the previous one. Log the result: console.log(Profit this trade: ${profit} USDC);.
• Sub-step 5: Add a cooldown mechanism or a rate-limiting condition to prevent excessive API calls or rapid-fire transactions that could fail due to nonce issues.

Tip: Consider moving to an event-driven architecture using WebSocket providers to listen for new blocks instead of polling, which is more efficient and faster.