Detailed Instructions

First, define a standardized swap transaction to ensure consistent measurement. This involves selecting a specific token pair (e.g., 1 ETH to USDC), a fixed input amount, and the target blockchain (e.g., Ethereum Mainnet). Record the current market mid-price from a trusted source like a major DEX to establish a baseline for price impact. This baseline is crucial for later calculating slippage and effective execution price.

• Sub-step 1: Choose a high-liquidity pair like WETH/USDC.
• Sub-step 2: Set a fixed input amount (e.g., 1 ETH) that is significant enough to test routing but not cause extreme market impact.
• Sub-step 3: Note the current spot price from a source like the Uniswap V3 pool to use as your reference price.

Tip: Use a block explorer to verify the on-chain spot price at the block height you intend to test, as CEX prices can diverge.

Detailed Instructions

Call the aggregator's quote endpoint (e.g., /swap/v1/quote for 1inch) with your standardized parameters. The response contains the expected output amount, the transaction data, and the proposed route. Critically analyze the route complexity, noting the number of hops, DEXs involved (e.g., Uniswap V3, Curve, Balancer), and any cross-protocol splits. A more complex route may introduce latency. Use the data field to understand the calldata size, which affects gas costs and broadcast time.

• Sub-step 1: Make an API call to the aggregator's quote endpoint with your token addresses, amount, and chain ID.
• Sub-step 2: Parse the response to extract the toAmount, protocols array, and tx.data.
• Sub-step 3: Count the number of hops in the protocols field to gauge routing complexity.

javascriptCopy
// Example fetch to 1inch API
const quote = await fetch(`https://api.1inch.io/v5.0/1/quote?fromTokenAddress=0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2&toTokenAddress=0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48&amount=1000000000000000000`);
const data = await quote.json();
console.log('Expected Output:', data.toTokenAmount);
console.log('Route Steps:', data.protocols.length);

Tip: Compare quotes from multiple aggregators (e.g., 1inch, 0x, Paraswap) simultaneously to benchmark their initial routing efficiency.

Detailed Instructions

Using the transaction data from the quote, broadcast the swap. Programmatically record four critical timestamps: t_submit (when sendTransaction is called), t_pending (when txHash is received), t_mined (when the transaction is included in a block), and t_confirmed (after N block confirmations). The interval between t_submit and t_mined is the total execution latency. This includes time for the aggregator's backend to finalize the route, your node to propagate the TX, and the network to mine it. Use an RPC provider with websocket support to listen for pendingTransaction and block events.

• Sub-step 1: Sign and send the transaction using the data from the aggregator's quote.
• Sub-step 2: Immediately record Date.now() as t_submit upon calling sendTransaction.
• Sub-step 3: Listen for the transactionHash event to record t_pending.
• Sub-step 4: Poll or use a websocket to capture the block number when the transaction is mined for t_mined.

Tip: For a more accurate network propagation measure, also record the time difference between t_pending and when the transaction first appears in your node's mempool.

Detailed Instructions

Once the transaction is confirmed, fetch the transaction receipt and event logs. The key metric is realized slippage, calculated as (Expected Output - Actual Output) / Expected Output. The actual output is found in the swap event logs (e.g., the amountOut in a Swap event). Compare this to the aggregator's quoted toAmount. Also, calculate the effective execution price (input amount / actual output). Analyze if the aggregator's gas estimation was accurate by comparing estimated vs. actual gas used. High variance can indicate poor simulation. Finally, compute the total effective cost, which includes gas fees and slippage.

• Sub-step 1: Use eth_getTransactionReceipt to get gas used and log events.
• Sub-step 2: Decode the relevant Swap event to find the exact amountOut received.
• Sub-step 3: Calculate slippage: ((quote.toTokenAmount - actualAmountOut) / quote.toTokenAmount) * 100.
• Sub-step 4: Compare gasUsed from the receipt to the estimatedGas in the original quote.

Tip: Negative slippage (getting more than quoted) is possible in volatile markets but rare; consistently positive slippage suggests the quote engine is overly optimistic.

Detailed Instructions

A true test of execution speed is performance under network stress. Repeat the measurement process during periods of high gas prices (e.g., >100 Gwei) and high mempool congestion. Monitor tools like Etherscan's Gas Tracker or Blocknative's Mempool Explorer. The critical observation is the increase in latency (t_submit to t_mined) and the potential for quote expiration or transaction failure. Some aggregators may dynamically adjust strategies or fail to provide a valid quote under these conditions. This stress test reveals the resilience of the aggregator's transaction simulation and gas estimation algorithms.

• Sub-step 1: Identify a period of network congestion using a gas price oracle or mempool data.
• Sub-step 2: Repeat steps 1-4, noting the current base fee and priority fee used.
• Sub-step 3: Observe if the aggregator's API response time increases or if quotes fail.
• Sub-step 4: Check for a higher rate of transaction reverts due to outdated quotes ("price moved").

Tip: To simulate stress reliably, you can schedule tests during predictable high-activity events like a major NFT mint or token launch.