Detailed Instructions

Your transaction's mempool visibility is the primary attack surface. Before signing, review the raw transaction data. The calldata field contains the function selector and arguments, which can reveal your target token, exact swap amounts, and slippage tolerance. A transaction interacting with a known DEX router like 0xEf1c6E67703c7BD7107eed8303Fbe6EC2554BF6B (Uniswap Universal Router) signals intent. Searchers parse this to model your potential profit. Check if your transaction uses a private RPC or is broadcast publicly. High-value swaps (>$50k) with tight slippage (<0.5%) are prime targets. Use a block explorer's simulation tool on a testnet transaction first to see the exact data exposed.

Tip: Consider using eth_call to simulate the transaction locally first; this does not broadcast it to the public mempool.

Detailed Instructions

Specific parameters act as MEV signals. Slippage tolerance is critical: setting it too high (e.g., 5%) invites sandwich attacks, while too low (e.g., 0.1%) risks frontrunning for failed arbitrage. Large swaps in illiquid pools create significant price impact that searchers can monetize. Analyze the token pair: swaps involving volatile or newly listed tokens are higher risk. Check the pool's liquidity on Etherscan; a pool with $100k TVL is far riskier for a $10k swap than one with $10M TVL. Use the formula (Swap Amount / Pool Reserve) * 100 to estimate your price impact. A result >1-2% is a high-risk threshold.

javascriptCopy
// Example: Calculate approximate price impact
const poolReserve = 500000; // USDC in pool
const swapAmount = 10000; // USDC you're swapping
const impact = (swapAmount / poolReserve) * 100;
console.log(`Estimated price impact: ${impact.toFixed(2)}%`);

Tip: For common pairs, use on-chain or DEX aggregator data to set dynamic, context-aware slippage.

Detailed Instructions

Use MEV simulation tools to foresee attack vectors. Platforms like Flashbots Protect RPC offer a mev_simBundle endpoint to test your transaction against historical attack patterns. The simulation checks for sandwichability by calculating if a profitable frontrun and backrun pair can be inserted around your swap. It also assesses liquidations if your transaction interacts with lending protocols. Key outputs to review: the simulated effective gas price (a large spike suggests competition from searchers) and whether your transaction would revert in a simulated adversarial environment. Compare the simulated final token output with your expected output; a large discrepancy indicates high exploit risk.

Tip: If you cannot run a simulation, manually check recent blocks for the same pool on a MEV explorer like EigenPhi to see if similar swaps were attacked.

Detailed Instructions

Based on your risk profile, route your transaction through a MEV protection service. For moderate-risk swaps, a private transaction pool like Flashbots Protect or Taichi Network obscures your transaction from the public mempool. For high-value transactions, consider using a RPC endpoint with built-in simulation and bundling, such as the Flashbots Protect RPC (https://rpc.flashbots.net). Configure your wallet or SDK to use this RPC. If using a smart contract wallet, implement commit-reveal schemes or threshold encryption for the highest security. For developers, integrate the Flashbots SDK (@flashbots/sdk) to submit bundles directly to builders.

javascriptCopy
// Example: Sending a private transaction via Flashbots RPC with ethers.js
const { FlashbotsBundleProvider } = require('@flashbots/sdk');
const provider = new ethers.providers.JsonRpcProvider('https://rpc.flashbots.net');
// ... construct signed bundle ...
const bundleSubmission = await flashbotsProvider.sendBundle(bundle, targetBlockNumber);

Tip: Remember that private pools do not guarantee inclusion; they only remove the public mempool risk. Ensure your gas price is still competitive.

Detailed Instructions

After submission, use MEV block explorers to audit the result. Tools like Etherscan's "State Changes" tab, EigenPhi, or MEV-Explore let you inspect the block your transaction landed in. Look for transactions from known searcher addresses (e.g., 0x0000000000000000000000000000000000000000 is a common placeholder) immediately before and after yours in the block ordering. Check your final execution price against the market price at that block time; a significant deviation indicates a possible sandwich. Verify the gas used and effective gas price paid; abnormally high values can signal competition. If your transaction was routed through a private service, confirm it was included in a block proposed by a trusted builder like builder0x69.

Tip: Bookmark the transaction on a MEV explorer. Reviewing a history of your own transactions builds intuition for future risk assessment.

Detailed Instructions

Slippage tolerance is your primary defense against front-running and sandwich attacks. Setting it too low causes failed transactions, while too high invites MEV extraction.

• Sub-step 1: For volatile pairs (e.g., new memecoins), analyze recent price charts and set slippage to 2-3x the typical 1-minute volatility, but cap at 5%.
• Sub-step 2: For established, liquid pairs (e.g., ETH/USDC), use a lower tolerance like 0.3-0.5%. Monitor the pending transaction pool (mempool) for competing large swaps.
• Sub-step 3: Use dynamic slippage tools if your aggregator supports them, which adjust based on real-time network conditions.

javascriptCopy
// Example: Setting slippage in an ethers.js transaction for a swap
const slippageBips = 50; // 0.5% in basis points
const amountOutMin = expectedAmountOut.mul(10000 - slippageBips).div(10000);
const tx = await router.swapExactTokensForTokens(
  amountIn,
  amountOutMin,
  path,
  to,
  deadline
);

Tip: Avoid using the default "auto" slippage on aggregators; it is often overly permissive to guarantee execution.

Detailed Instructions

Private transaction relays (e.g., Flashbots Protect, Taichi Network, bloXroute) submit your transaction directly to block builders, hiding it from searchers scanning the public mempool.

• Sub-step 1: Integrate the RPC endpoint for a private relay service like Flashbots Protect (https://rpc.flashbots.net) into your wallet (e.g., MetaMask) for the specific transaction.
• Sub-step 2: When submitting, ensure the transaction is sent as a eth_sendPrivateTransaction call. Some wallets have built-in toggles for "Private Tx".
• Sub-step 3: Verify the transaction was accepted by the relay by checking its status on a block explorer that tracks private transactions, noting it will not appear in the public pending pool.

bashCopy
# Example curl to send a raw, signed transaction via Flashbots Protect
curl -X POST https://rpc.flashbots.net \
  -H "Content-Type: application/json" \
  --data '{"jsonrpc":"2.0","method":"eth_sendPrivateTransaction","params":[{"tx": "0xSignedRawTxHex", "maxBlockNumber":"0x10A25C0"}],"id":1}'

Tip: Private transactions may have slightly higher latency and cost (priority fee paid to the builder) but eliminate front-running risk.

Detailed Instructions

Network activity directly correlates with MEV opportunity. Bots are most active during high gas price periods, which often coincide with major news or large on-chain events.

• Sub-step 1: Use gas trackers (e.g., Etherscan Gas Tracker, Blocknative Gas Estimator) to identify periods of consistently lower base fees and priority fees. Target times like weekends or US overnight hours (UTC 0:00 - 8:00).
• Sub-step 2: Avoid trading immediately following major announcements or during large NFT mint events, which flood the mempool.
• Sub-step 3: For non-urgent swaps, consider using limit orders on aggregators that support them (e.g., 1inch Limit Orders), which execute only when your price target is met without you submitting a live transaction.

Tip: Monitor the gwei value for the "SafeLow" or "Standard" priority fee tier. Consistently staying below 10-15 gwei for this tier often indicates a lower-risk environment for MEV.

Detailed Instructions

Route simulation is critical. Aggregators find the best price, but the proposed path can expose you to risky, low-liquidity pools vulnerable to manipulation.

• Sub-step 1: Before signing, examine the breakdown. Look for splits across many DEXs (5+ hops) or routes through obscure, unaudited pools, which increase failure points and MEV surface area.
• Sub-step 2: Cross-check the final quoted rate against a live market price from a trusted source like CoinGecko or Binance, accounting for your slippage tolerance. A quote more than 0.5% better than the market average can be a red flag.
• Sub-step 3: Use the aggregator's simulation feature to see the expected token balances change. For advanced users, simulate the transaction locally using Tenderly or a forked network via Foundry's cast to verify state changes.

bashCopy
# Example: Using Foundry's cast to simulate a swap call locally
cast call <RouterAddress> \
  "swapExactTokensForTokens(uint256,uint256,address[],address,uint256)" \
  <amountIn> <amountOutMin> "[<tokenIn>, <tokenOut>]" <yourAddress> <deadline> \
  --rpc-url <ALCHEMY_RPC_URL>

Tip: Favor aggregators that provide clear, auditable routing data and have a reputation for security, like 1inch or 0x API.

Detailed Instructions

Transaction batching combines multiple actions (e.g., approve and swap) into one, while nonce management controls ordering. This reduces the window of exposure and can confuse simplistic MEV bots.

• Sub-step 1: Use smart contract wallets (ERC-4337) or router contracts that batch operations. For example, perform token approval and the swap in a single multicall transaction.
• Sub-step 2: For manual nonce management, prepare a sequence of transactions (e.g., a low-value decoy followed by the main swap). Sign and submit them in rapid succession using eth_sendRawTransaction with consecutive nonces.
• Sub-step 3: Monitor the status of all transactions in your sequence. If the decoy fails, your main swap's nonce will be blocked, requiring you to override it with a higher gas price.

solidityCopy
// Example of a simple batched call via a multicall contract
function batchSwap(
    address token,
    uint256 amount,
    address router,
    bytes calldata swapCalldata
) external {
    // Batch approve and swap
    IERC20(token).approve(router, amount);
    (bool success, ) = router.call(swapCalldata);
    require(success, "Swap failed");
}

Tip: This is an advanced strategy. Incorrect nonce management can lead to stuck transactions. Use libraries like ethers.js' NonceManager for safety.