Detailed Instructions

Start by concretely defining the parameters of your intended swap. This creates a fixed scenario to test different execution paths against.

• Trade Size: Determine the exact input amount (e.g., 10 ETH). Large trades are more sensitive to slippage and liquidity fragmentation.
• Token Pair: Identify the specific tokens (e.g., WETH to USDC). Check if they are common blue-chips or more obscure, long-tail assets.
• Target Chain: Note the blockchain network (e.g., Ethereum Mainnet, Arbitrum). Liquidity and aggregator support vary.
• Urgency: Decide if the trade is time-sensitive (needs execution in the next block) or can afford to wait for potential better rates.

javascriptCopy
// Example parameters object for analysis
const tradeParams = {
  inputToken: 'WETH',
  outputToken: 'USDC',
  inputAmount: '10000000000000000000', // 10 ETH in wei
  chainId: 1, // Ethereum Mainnet
  slippageTolerance: 0.5 // 0.5%
};

Tip: For complex, multi-leg trades (e.g., ETH -> AAVE -> GHO), an aggregator's pathfinding is almost always superior.

Detailed Instructions

Query the leading DEXes for your token pair to understand the best possible single-source execution. This is your control benchmark.

• Identify Top Liquidity Pools: For major pairs, check Uniswap V3, Curve (for stables/pegged assets), and Balancer. Use their official interfaces or subgraphs.
• Simulate the Swap: Use the quoteExactInputSingle function on Uniswap V3's Quoter contract (address: 0xb27308f9F90D607463bb33eA1BeBb41C27CE5AB6) to get an expected output amount without executing a transaction.
• Calculate Implied Costs: Factor in the quoted output, the DEX's specific fee tier (e.g., 0.05%, 0.3%, 1%), and estimated network gas for a swap.
• Record the Result: Note the final expected received amount and the total cost (fee + gas).

solidityCopy
// Example call to Uniswap V3 Quoter
// Returns amountOut for a given amountIn
IQuoter(0xb27308f9F90D607463bb33eA1BeBb41C27CE5AB6).quoteExactInputSingle(
    IQuoter.QuoteExactInputSingleParams({
        tokenIn: address(WETH),
        tokenOut: address(USDC),
        fee: 3000, // 0.3% pool
        amountIn: 10 ether,
        sqrtPriceLimitX96: 0
    })
);

Tip: For stablecoin swaps, always check Curve or a specialized DEX first, as they often offer the best native rates.

Detailed Instructions

Aggregators source liquidity across dozens of pools and DEXes. You must compare their proposals to find the optimal one.

• Call Aggregator Endpoints: Use the public APIs of services like 1inch, 0x (Matcha), ParaSwap, and CowSwap (for batch auctions). Pass your predefined tradeParams.
• Parse the Response: Extract the critical data: outputAmount, the breakdown of protocols and pools used in the route, and the estimated gasCost.
• Check for Slippage Protection: See if the quote is using on-chain oracles for protection against MEV and slippage (e.g., 1inch's Fusion mode, 0x's slippageLimit parameter).
• Calculate Net Received: Subtract the estimated gas cost (converted to the output token) from the quoted outputAmount to get a net value for comparison.

bashCopy
# Example curl to 1inch API for a quote
curl 'https://api.1inch.io/v5.0/1/quote?\
fromTokenAddress=0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2&\
toTokenAddress=0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48&\
amount=10000000000000000000'

Tip: Aggregator APIs often have rate limits. For production use, consider using their SDKs or official node packages for reliable integration.

Detailed Instructions

An aggregator's marginally better rate may not justify its use. Perform a holistic analysis.

• Quantify Price Improvement: Calculate the percentage increase in net output vs. your best direct DEX benchmark. Is it >0.3%? For small trades, gas costs may erase gains.
• Assess Route Complexity: A route splitting across 5 protocols and 7 hops carries more execution risk than a single Uniswap swap. Check for bridge hops (e.g., via Synapse, Stargate) in cross-chain aggregator quotes, which add significant latency and trust assumptions.
• Review Smart Contract Risk: Interacting with an aggregator's router contract (e.g., 1inch: 0x1111111254EEB25477B68fb85Ed929f73A960582) adds a layer of dependency. Verify its audit status and the token approval policy (infinite vs. periodic allowances).
• Consider Time Sensitivity: If the market is moving fast, the multi-step aggregator route may fail or result in worse execution than a faster, direct swap.

Tip: For large, non-urgent trades on Ethereum, consider using a batch auction DEX like CowSwap, which can provide MEV protection and often better prices via its coincidence of wants mechanism.

Detailed Instructions

After selecting your approach, execute the trade and use a block explorer to audit the result.

• Initiate the Swap: If using an aggregator, you will typically send a transaction to their router contract with the calldata provided by their API. For a direct DEX, interact with the pool's contract directly.
• Monitor Transaction Lifecycle: Watch for confirmation. For complex aggregator routes, the transaction may involve multiple internal DELEGATECALL operations. Use Tenderly or a similar debugger to trace it.
• Verify Final Output: Once confirmed, compare the actual outputAmount of tokens received in your wallet to the quoted amount. Calculate the execution slippage: ((quoted - actual) / quoted) * 100.
• Post-Trade Analysis: Was the gas estimate accurate? Did the transaction include any unexpected internal transfers or fee deductions? Record this data to inform your next trade.

javascriptCopy
// Example: Listening for the Transfer event of the output token
usdcContract.on('Transfer', (from, to, value, event) => {
    if (to === myAddress) {
        console.log(`Received ${ethers.formatUnits(value, 6)} USDC`);
        // Compare to quoted amount
    }
});

Tip: Always simulate the transaction via eth_call or Tenderly before sending, especially for aggregator routes, to catch potential reverts or unexpected state changes.