Index EVM DEX Swaps

Track Uniswap V3 swap events to extract real-time price data, calculate trading volumes, and analyze on-chain liquidity dynamics. Unlike centralized exchanges, DEX data is verifiable and tamper-proof, ideal for building trustless price oracles and analytics.

Use Case

DEX swap indexing unlocks powerful analytics:

Price Discovery: Extract real-time token prices from swap amounts without relying on third-party APIs
Volume Analysis: Calculate 24h trading volumes, identify trending pairs, and detect unusual activity
Liquidity Tracking: Monitor pool depth changes and identify liquidity migration patterns
MEV Detection: Analyze sandwich attacks, arbitrage opportunities, and front-running patterns by correlating swaps within blocks

Code Example

curl --compressed -X POST "https://portal.sqd.dev/datasets/ethereum-mainnet/stream" \
  -H 'Content-Type: application/json' \
  -d '{
    "type": "evm",
    "fromBlock": 12369621,
    "toBlock": 12400000,
    "fields": {
      "block": {
        "number": true,
        "timestamp": true
      },
      "log": {
        "address": true,
        "topics": true,
        "data": true,
        "transactionHash": true
      }
    },
    "logs": [{
      "topic0": ["0xc42079f94a6350d7e6235f29174924f928cc2ac818eb64fed8004e115fbcca67"]
    }]
  }'

import { DataSource } from "@subsquid/portal-client";

const dataSource = new DataSource({
  network: "ethereum-mainnet",
});

// Uniswap V3 Swap event signature
const SWAP_TOPIC = "0xc42079f94a6350d7e6235f29174924f928cc2ac818eb64fed8004e115fbcca67";

const blocks = await dataSource.getBlocks({
  from: 12369621, // Uniswap V3 deployment block
  to: 12400000,
  fields: {
    block: { number: true, timestamp: true },
    log: {
      address: true,
      topics: true,
      data: true,
      transactionHash: true,
    },
  },
  logs: [
    {
      topic0: [SWAP_TOPIC],
    },
  ],
});

// Process swaps
for (const block of blocks) {
  for (const log of block.logs) {
    const sender = `0x${log.topics[1].slice(26)}`;
    const recipient = `0x${log.topics[2].slice(26)}`;
    
    console.log({
      blockNumber: block.header.number,
      timestamp: block.header.timestamp,
      pool: log.address,
      sender,
      recipient,
      txHash: log.transactionHash,
      // Decode amounts from data field
    });
  }
}

import requests
import json

url = "https://portal.sqd.dev/datasets/ethereum-mainnet/stream"
headers = {"Content-Type": "application/json"}

# Uniswap V3 Swap event
swap_topic = "0xc42079f94a6350d7e6235f29174924f928cc2ac818eb64fed8004e115fbcca67"

payload = {
    "type": "evm",
    "fromBlock": 12369621,  # Uniswap V3 deployment
    "toBlock": 12400000,
    "fields": {
        "block": {
            "number": True,
            "timestamp": True
        },
        "log": {
            "address": True,
            "topics": True,
            "data": True,
            "transactionHash": True
        }
    },
    "logs": [{
        "topic0": [swap_topic]
    }]
}

response = requests.post(url, headers=headers, json=payload)

for line in response.text.strip().split('\n'):
    block = json.loads(line)
    for log in block.get('logs', []):
        sender = "0x" + log['topics'][1][26:]
        recipient = "0x" + log['topics'][2][26:]
        
        print({
            "blockNumber": block['header']['number'],
            "timestamp": block['header']['timestamp'],
            "pool": log['address'],
            "sender": sender,
            "recipient": recipient,
            "txHash": log['transactionHash']
        })

Try it yourself with the interactive query interface below:

Key Parameters

Parameter	Description
`topic0`	Swap event signature (`Swap(address,address,int256,int256,uint160,uint128,int24)`)
`topics[1]`	Sender address (who initiated the swap)
`topics[2]`	Recipient address (who receives the output)
`data`	Swap amounts and other parameters (amount0, amount1, sqrtPriceX96, liquidity, tick)
`address`	Pool contract address

The Swap event signature varies by DEX. Uniswap V3 uses a different signature than Uniswap V2 or other DEXs.

Expected Output

{
  "header": {
    "number": 12369650,
    "timestamp": 1620054321
  },
  "logs": [
    {
      "address": "0x8ad599c3a0ff1de082011efddc58f1908eb6e6d8",
      "topics": [
        "0xc42079f94a6350d7e6235f29174924f928cc2ac818eb64fed8004e115fbcca67",
        "0x00000000000000000000000068b3465833fb72a70ecdf485e0e4c7bd8665fc45",
        "0x00000000000000000000000028c6c06298d514db089934071355e5743bf21d60"
      ],
      "data": "0x...",
      "transactionHash": "0x123..."
    }
  ]
}

Track Specific Pool

Monitor swaps for a specific trading pair:

curl --compressed -X POST "https://portal.sqd.dev/datasets/ethereum-mainnet/stream" \
  -H 'Content-Type: application/json' \
  -d '{
    "type": "evm",
    "fromBlock": 18000000,
    "toBlock": 18010000,
    "fields": {
      "log": {
        "address": true,
        "topics": true,
        "data": true
      }
    },
    "logs": [{
      "address": ["0x8ad599c3A0ff1De082011EFDDc58f1908eb6e6D8"],
      "topic0": ["0xc42079f94a6350d7e6235f29174924f928cc2ac818eb64fed8004e115fbcca67"]
    }]
  }'

const USDC_WETH_POOL = "0x8ad599c3A0ff1De082011EFDDc58f1908eb6e6D8"; // Uniswap V3 USDC/WETH

const blocks = await dataSource.getBlocks({
  from: 18000000,
  to: 18010000,
  fields: {
    log: { address: true, topics: true, data: true },
  },
  logs: [
    {
      address: [USDC_WETH_POOL],
      topic0: ["0xc42079f94a6350d7e6235f29174924f928cc2ac818eb64fed8004e115fbcca67"],
    },
  ],
});

usdc_weth_pool = "0x8ad599c3A0ff1De082011EFDDc58f1908eb6e6D8"

payload = {
    "type": "evm",
    "fromBlock": 18000000,
    "toBlock": 18010000,
    "fields": {
        "log": {
            "address": True,
            "topics": True,
            "data": True
        }
    },
    "logs": [{
        "address": [usdc_weth_pool],
        "topic0": ["0xc42079f94a6350d7e6235f29174924f928cc2ac818eb64fed8004e115fbcca67"]
    }]
}

Uniswap V2 Swaps

For Uniswap V2, use the V2 Swap event signature:

// Uniswap V2 Swap event: Swap(address,uint256,uint256,uint256,uint256,address)
const V2_SWAP_TOPIC = "0xd78ad95fa46c994b6551d0da85fc275fe613ce37657fb8d5e3d130840159d822";

const blocks = await dataSource.getBlocks({
  from: 18000000,
  to: 18010000,
  fields: {
    log: { address: true, topics: true, data: true },
  },
  logs: [
    {
      topic0: [V2_SWAP_TOPIC],
    },
  ],
});

Different DEX protocols use different event signatures. Check the contract ABI to find the correct signature for your target DEX.

Decode Swap Amounts and Calculate Prices

The real value in DEX data comes from decoding swap amounts to calculate prices. Here’s how to extract and interpret Uniswap V3 swap data:

import { ethers } from "ethers";

// Uniswap V3 Swap event ABI
const swapEventAbi = [
  "event Swap(address indexed sender, address indexed recipient, int256 amount0, int256 amount1, uint160 sqrtPriceX96, uint128 liquidity, int24 tick)"
];

const iface = new ethers.Interface(swapEventAbi);

for (const block of blocks) {
  for (const log of block.logs) {
    const decoded = iface.parseLog({
      topics: log.topics,
      data: log.data,
    });
    
    const amount0 = decoded.args.amount0;
    const amount1 = decoded.args.amount1;
    const sqrtPriceX96 = decoded.args.sqrtPriceX96;
    
    // Calculate the actual price from sqrtPriceX96
    // price = (sqrtPriceX96 / 2^96)^2
    const price = (Number(sqrtPriceX96) / (2 ** 96)) ** 2;
    
    // Determine swap direction and calculate effective price
    const isBuyingToken0 = amount0 < 0n;
    const effectivePrice = isBuyingToken0
      ? Math.abs(Number(amount1)) / Math.abs(Number(amount0))
      : Math.abs(Number(amount0)) / Math.abs(Number(amount1));
    
    console.log({
      pool: log.address,
      blockNumber: block.header.number,
      timestamp: block.header.timestamp,
      amount0: amount0.toString(),
      amount1: amount1.toString(),
      currentPrice: price,
      effectivePrice: effectivePrice,
      liquidity: decoded.args.liquidity.toString(),
      tick: decoded.args.tick,
    });
  }
}

from eth_abi import decode

# Decode data field (amounts and other params)
# Uniswap V3: (int256 amount0, int256 amount1, uint160 sqrtPriceX96, uint128 liquidity, int24 tick)
types = ['int256', 'int256', 'uint160', 'uint128', 'int24']

for line in response.text.strip().split('\n'):
    block = json.loads(line)
    for log in block.get('logs', []):
        decoded = decode(types, bytes.fromhex(log['data'][2:]))
        amount0, amount1, sqrtPriceX96, liquidity, tick = decoded
        
        print({
            "amount0": amount0,
            "amount1": amount1,
            "sqrtPriceX96": sqrtPriceX96,
            "liquidity": liquidity,
            "tick": tick
        })

Advanced Analysis: Detecting MEV Sandwich Attacks

Sandwich attacks are a common MEV strategy where an attacker places trades before and after a victim’s transaction to profit from price impact. By analyzing swap sequences within blocks, you can detect these patterns:

// Query swaps with transaction details to detect sandwich attacks
const blocks = await dataSource.getBlocks({
  from: 18000000,
  to: 18010000,
  fields: {
    block: { number: true, timestamp: true },
    transaction: { hash: true, from: true, to: true, transactionIndex: true },
    log: { address: true, topics: true, data: true, transactionHash: true, logIndex: true },
  },
  logs: [{ topic0: [SWAP_TOPIC] }],
  includeAllBlocks: false,
});

// Detect sandwich attacks by analyzing swap sequences
for (const block of blocks) {
  // Group swaps by pool address
  const poolSwaps = new Map();
  
  for (const log of block.logs) {
    const tx = block.transactions.find(t => t.hash === log.transactionHash);
    if (!tx) continue;
    
    if (!poolSwaps.has(log.address)) {
      poolSwaps.set(log.address, []);
    }
    
    poolSwaps.get(log.address).push({
      txIndex: tx.transactionIndex,
      txHash: tx.hash,
      trader: tx.from,
      log: log,
    });
  }
  
  // Check for sandwich pattern: same trader with swaps before and after victim
  for (const [pool, swaps] of poolSwaps) {
    if (swaps.length < 3) continue;
    
    swaps.sort((a, b) => a.txIndex - b.txIndex);
    
    for (let i = 0; i < swaps.length - 2; i++) {
      const first = swaps[i];
      const middle = swaps[i + 1];
      const last = swaps[i + 2];
      
      // Sandwich pattern: same trader surrounds victim's trade
      if (first.trader === last.trader && middle.trader !== first.trader) {
        console.log({
          block: block.header.number,
          pool: pool,
          attacker: first.trader,
          victim: middle.trader,
          frontrunTx: first.txHash,
          victimTx: middle.txHash,
          backrunTx: last.txHash,
        });
      }
    }
  }
}

MEV detection requires analyzing transaction ordering within blocks. Make sure to request transaction fields and transactionIndex to properly sequence trades.

Advanced Analysis: Multi-Hop Swaps and Arbitrage

Many swaps route through multiple pools via aggregators like 1inch or Uniswap’s Universal Router. By combining swap events with traces, you can reconstruct complete arbitrage paths and calculate profitability:

// Query both swap events and traces to reconstruct multi-hop routes
const blocks = await dataSource.getBlocks({
  from: 18000000,
  to: 18010000,
  fields: {
    block: { number: true, timestamp: true },
    transaction: { hash: true, from: true, to: true },
    log: { address: true, topics: true, data: true, transactionHash: true },
    trace: { callFrom: true, callTo: true, callValue: true, transactionHash: true },
  },
  logs: [{ topic0: [SWAP_TOPIC] }],
  traces: [{ type: ["call"] }],
});

// Group swaps by transaction to identify arbitrage opportunities
const swapsByTx = new Map();
for (const block of blocks) {
  for (const log of block.logs) {
    if (!swapsByTx.has(log.transactionHash)) {
      swapsByTx.set(log.transactionHash, {
        swaps: [],
        traces: [],
        tx: block.transactions.find(t => t.hash === log.transactionHash),
      });
    }
    swapsByTx.get(log.transactionHash).swaps.push(log);
  }
  
  // Add traces for each transaction
  for (const trace of block.traces) {
    if (swapsByTx.has(trace.transactionHash)) {
      swapsByTx.get(trace.transactionHash).traces.push(trace);
    }
  }
}

// Analyze multi-hop swaps and detect circular arbitrage
for (const [txHash, data] of swapsByTx) {
  if (data.swaps.length > 1) {
    const pools = data.swaps.map(s => s.address);
    const uniquePools = new Set(pools);
    
    // Circular arbitrage: starts and ends with same token
    if (uniquePools.size >= 3) {
      console.log({
        txHash,
        trader: data.tx?.from,
        pools: pools,
        hopCount: data.swaps.length,
        type: 'potential-arbitrage',
      });
    }
  }
}

Combine swap events with traces to capture the full execution path, including intermediate token approvals and transfers that don’t emit swap events.

Performance Tips

Filter by pool address: Query specific high-volume pools (USDC/WETH, WETH/USDT) instead of all swaps
Use block ranges: Process 10k-50k block batches for optimal throughput
Batch decode: Decode multiple events in parallel rather than sequentially
Cache pool metadata: Store token decimals and symbols to avoid repeated lookups
Combine with traces: Track multi-hop swaps and MEV activity by analyzing call traces alongside events

Query Event Logs

General event log querying

Query Traces

Track multi-hop swaps with traces

Track NFT Transfers

Monitor NFT marketplace activity

API Reference

View complete API docs

Overview

Portal API reference

Working with Portal API

Local Setup

Supported Networks

Use Case

Code Example

Key Parameters

Expected Output

Track Specific Pool

Uniswap V2 Swaps

Decode Swap Amounts and Calculate Prices

Advanced Analysis: Detecting MEV Sandwich Attacks

Advanced Analysis: Multi-Hop Swaps and Arbitrage

Performance Tips

Query Event Logs

Query Traces

Track NFT Transfers

API Reference

​Use Case

​Code Example

​Key Parameters

​Expected Output

​Track Specific Pool

​Uniswap V2 Swaps

​Decode Swap Amounts and Calculate Prices

​Advanced Analysis: Detecting MEV Sandwich Attacks

​Advanced Analysis: Multi-Hop Swaps and Arbitrage

​Performance Tips

​Related Examples

Query Event Logs

Query Traces

Track NFT Transfers

API Reference

Use Case

Code Example

Key Parameters

Expected Output

Track Specific Pool

Uniswap V2 Swaps

Decode Swap Amounts and Calculate Prices

Advanced Analysis: Detecting MEV Sandwich Attacks

Advanced Analysis: Multi-Hop Swaps and Arbitrage

Performance Tips

Related Examples