How to Get Polymarket Historical Data: Rebuild Every Trade From Polygon Logs

pip install requests pandas
export POLYGON_RPC_URL="https://api-polygon-mainnet-full.n.dwellir.com/<YOUR_API_KEY>"

cargo new polymarket-fills && cd polymarket-fills
cargo add chrono num-bigint serde_json
cargo add ureq@2 --features json
export POLYGON_RPC_URL="https://api-polygon-mainnet-full.n.dwellir.com/<YOUR_API_KEY>"

mkdir polymarket-fills && cd polymarket-fills
go mod init polymarketfills  # standard library only, nothing to install
export POLYGON_RPC_URL="https://api-polygon-mainnet-full.n.dwellir.com/<YOUR_API_KEY>"

mkdir polymarket-fills && cd polymarket-fills
echo '{"type": "module"}' > package.json  # built-in fetch, nothing to install
export POLYGON_RPC_URL="https://api-polygon-mainnet-full.n.dwellir.com/<YOUR_API_KEY>"

"""Rebuild Polymarket trade history from OrderFilled logs on Polygon.

Usage:
    export POLYGON_RPC_URL="https://api-polygon-mainnet-full.n.dwellir.com/<YOUR_API_KEY>"
    python polymarket_fills.py --start 2026-11-02T12:55 --end 2026-11-02T13:20 --out fills.csv
"""
import argparse
import csv
import os
import time
from datetime import datetime, timezone

import requests

RPC_URL = os.environ["POLYGON_RPC_URL"]

# CTF Exchange and NegRisk CTF Exchange, before and after the CLOB V2 upgrade.
EXCHANGES = {
    "v1": ["0x4bfb41d5b3570defd03c39a9a4d8de6bd8b8982e",   # CTF Exchange
           "0xc5d563a36ae78145c45a50134d48a1215220f80a"],  # NegRisk CTF Exchange
    "v2": ["0xe111180000d2663c0091e4f400237545b87b996b",   # CTFExchangeV2
           "0xe2222d279d744050d28e00520010520000310f59"],  # NegRiskCtfExchangeV2
}
# keccak256 of the OrderFilled signature in each version
ORDER_FILLED = {
    "v1": "0xd0a08e8c493f9c94f29311604c9de1b4e8c8d4c06bd0c789af57f2d65bfec0f6",
    "v2": "0xd543adfd945773f1a62f74f0ee55a5e3b9b1a28262980ba90b1a89f2ea84d8ee",
}
V2_FIRST_FILL_BLOCK = 86_100_351  # 2026-04-27 20:12 UTC
V1_LAST_FILL_BLOCK = 86_126_998   # 2026-04-28 11:00 UTC
# eth_getLogs block limit: 10,000 on Dwellir Growth and Scale, 500 on Developer
MAX_BLOCK_RANGE = int(os.environ.get("MAX_BLOCK_RANGE", 10_000))
TARGET_LOGS_PER_CALL = 10_000     # keeps each response near 10 MB

session = requests.Session()


def rpc(method, params, retries=4):
    error = None
    for attempt in range(retries):
        try:
            body = session.post(RPC_URL, json={"jsonrpc": "2.0", "id": 1,
                                               "method": method, "params": params},
                                timeout=120).json()
            if "error" not in body:
                return body["result"]
            error = body["error"]
        except (requests.RequestException, ValueError) as exc:
            error = exc
        time.sleep(2 ** attempt)
    raise RuntimeError(f"{method} failed: {error}")


def block_at(ts):
    """First block with timestamp >= ts (binary search on block headers)."""
    lo, hi = 1, int(rpc("eth_blockNumber", []), 16)
    while lo < hi:
        mid = (lo + hi) // 2
        if int(rpc("eth_getBlockByNumber", [hex(mid), False])["timestamp"], 16) < ts:
            lo = mid + 1
        else:
            hi = mid
    return lo


def get_logs(addresses, topics, start, end):
    """Yield logs for [start, end]. Shrink the range when a call fails or returns too much."""
    step, block = min(200, MAX_BLOCK_RANGE), start
    while block <= end:
        to = min(block + step - 1, end)
        try:
            logs = rpc("eth_getLogs", [{"address": addresses, "topics": topics,
                                        "fromBlock": hex(block), "toBlock": hex(to)}], retries=2)
        except RuntimeError:
            if step == 1:
                raise
            step //= 2
            continue
        yield from logs
        block = to + 1
        if len(logs) > TARGET_LOGS_PER_CALL:
            step = max(1, step // 2)
        elif len(logs) < TARGET_LOGS_PER_CALL // 4:
            step = min(MAX_BLOCK_RANGE, step * 2)


def words(data):
    raw = data[2:]
    return [int(raw[i:i + 64], 16) for i in range(0, len(raw), 64)]


def decode(log, version):
    maker = "0x" + log["topics"][2][-40:]
    taker = "0x" + log["topics"][3][-40:]
    w = words(log["data"])
    if version == "v2":
        side = "BUY" if w[0] == 0 else "SELL"
        token_id, maker_amount, taker_amount, fee = w[1], w[2], w[3], w[4]
        fee_asset = "collateral"  # V2 fees are always in pUSD
    else:
        maker_asset, taker_asset, maker_amount, taker_amount, fee = w[:5]
        side = "BUY" if maker_asset == 0 else "SELL"  # asset id 0 is collateral
        token_id = taker_asset if side == "BUY" else maker_asset
        fee_asset = "shares" if side == "BUY" else "collateral"  # V1 charges fees in proceeds
    # A BUY order pays collateral and receives outcome tokens; a SELL does the reverse.
    cash, shares = (maker_amount, taker_amount) if side == "BUY" else (taker_amount, maker_amount)
    return {
        "block": int(log["blockNumber"], 16),
        "timestamp": int(log["blockTimestamp"], 16),
        "tx_hash": log["transactionHash"],
        "log_index": int(log["logIndex"], 16),
        "version": version,
        "exchange": log["address"],
        # The taker order's fill is logged with the exchange as counterparty.
        "role": "taker" if taker == log["address"] else "maker",
        "order_hash": log["topics"][1],
        "maker": maker,
        "taker": taker,
        "side": side,
        "token_id": str(token_id),
        "price": round(cash / shares, 6) if shares else None,
        "shares": shares / 1e6,
        "collateral": cash / 1e6,  # USDC.e in V1, pUSD in V2; both 6 decimals
        "fee": fee / 1e6,
        "fee_asset": fee_asset,
    }


def fills(start_block, end_block, maker=None):
    """Yield decoded fills from every exchange version active in the range."""
    for version in ("v1", "v2"):
        lo = start_block if version == "v1" else max(start_block, V2_FIRST_FILL_BLOCK)
        hi = min(end_block, V1_LAST_FILL_BLOCK) if version == "v1" else end_block
        if lo > hi:
            continue
        topics = [ORDER_FILLED[version], None, None if maker is None else
                  "0x" + maker.lower()[2:].rjust(64, "0")]
        for log in get_logs(EXCHANGES[version], topics, lo, hi):
            yield decode(log, version)


def parse_time(value):
    return int(datetime.fromisoformat(value).replace(tzinfo=timezone.utc).timestamp())


if __name__ == "__main__":
    ap = argparse.ArgumentParser()
    ap.add_argument("--start", required=True, help="UTC, e.g. 2026-11-02T12:55")
    ap.add_argument("--end", required=True)
    ap.add_argument("--maker", help="only fills of orders signed by this wallet (maker and taker legs)")
    ap.add_argument("--out", default="fills.csv")
    args = ap.parse_args()

    start_block, end_block = block_at(parse_time(args.start)), block_at(parse_time(args.end)) - 1
    print(f"blocks {start_block:,} to {end_block:,}")
    count = 0
    with open(args.out, "w", newline="") as fh:
        writer = None
        for row in fills(start_block, end_block, args.maker):
            if writer is None:
                writer = csv.DictWriter(fh, fieldnames=row.keys())
                writer.writeheader()
            writer.writerow(row)
            count += 1
    print(f"wrote {count:,} fills to {args.out}")

//! Rebuild Polymarket trade history from OrderFilled logs on Polygon.
//!
//! Usage:
//!     export POLYGON_RPC_URL="https://api-polygon-mainnet-full.n.dwellir.com/<YOUR_API_KEY>"
//!     cargo run --release -- --start 2026-11-02T12:55 --end 2026-11-02T13:20 --out fills.csv
use std::{env, fs::File, io::BufWriter, io::Write, thread, time::Duration};

use chrono::NaiveDateTime;
use num_bigint::BigUint;
use serde_json::{json, Value};

#[derive(Clone, Copy)]
enum Version {
    V1,
    V2,
}

impl Version {
    // CTF Exchange and NegRisk CTF Exchange, before and after the CLOB V2 upgrade.
    fn exchanges(self) -> [&'static str; 2] {
        match self {
            Version::V1 => ["0x4bfb41d5b3570defd03c39a9a4d8de6bd8b8982e",  // CTF Exchange
                            "0xc5d563a36ae78145c45a50134d48a1215220f80a"], // NegRisk CTF Exchange
            Version::V2 => ["0xe111180000d2663c0091e4f400237545b87b996b",  // CTFExchangeV2
                            "0xe2222d279d744050d28e00520010520000310f59"], // NegRiskCtfExchangeV2
        }
    }

    // keccak256 of the OrderFilled signature in each version
    fn order_filled(self) -> &'static str {
        match self {
            Version::V1 => "0xd0a08e8c493f9c94f29311604c9de1b4e8c8d4c06bd0c789af57f2d65bfec0f6",
            Version::V2 => "0xd543adfd945773f1a62f74f0ee55a5e3b9b1a28262980ba90b1a89f2ea84d8ee",
        }
    }

    fn name(self) -> &'static str {
        match self {
            Version::V1 => "v1",
            Version::V2 => "v2",
        }
    }
}

const V2_FIRST_FILL_BLOCK: u64 = 86_100_351; // 2026-04-27 20:12 UTC
const V1_LAST_FILL_BLOCK: u64 = 86_126_998; // 2026-04-28 11:00 UTC
const TARGET_LOGS_PER_CALL: usize = 10_000; // keeps each response near 10 MB

struct Rpc {
    url: String,
    agent: ureq::Agent,
}

impl Rpc {
    fn new(url: String) -> Self {
        let agent = ureq::AgentBuilder::new().timeout(Duration::from_secs(120)).build();
        Rpc { url, agent }
    }

    fn call(&self, method: &str, params: Value, retries: u32) -> Result<Value, String> {
        let body = json!({"jsonrpc": "2.0", "id": 1, "method": method, "params": params});
        let mut error = String::new();
        for attempt in 0..retries {
            let response = self.agent.post(&self.url).send_json(&body)
                .map_err(|e| e.to_string())
                .and_then(|r| r.into_json::<Value>().map_err(|e| e.to_string()));
            match response {
                Ok(mut v) if v.get("error").is_none() => return Ok(v["result"].take()),
                Ok(v) => error = v["error"].to_string(),
                Err(e) => error = e,
            }
            thread::sleep(Duration::from_secs(1 << attempt));
        }
        Err(format!("{method} failed: {error}"))
    }
}

fn hex_u64(value: &Value) -> u64 {
    u64::from_str_radix(value.as_str().unwrap_or("0x0").trim_start_matches("0x"), 16).unwrap_or(0)
}

/// First block with timestamp >= ts (binary search on block headers).
fn block_at(rpc: &Rpc, ts: u64) -> Result<u64, String> {
    let (mut lo, mut hi) = (1, hex_u64(&rpc.call("eth_blockNumber", json!([]), 4)?));
    while lo < hi {
        let mid = (lo + hi) / 2;
        let block = rpc.call("eth_getBlockByNumber", json!([format!("{mid:#x}"), false]), 4)?;
        if hex_u64(&block["timestamp"]) < ts { lo = mid + 1 } else { hi = mid }
    }
    Ok(lo)
}

/// Call `each` for every log in [start, end]. Shrink the range when a call fails or returns too much.
fn get_logs(rpc: &Rpc, addresses: &[&str], topics: &Value, start: u64, end: u64, max_range: u64,
            mut each: impl FnMut(&Value) -> std::io::Result<()>) -> Result<(), String> {
    let (mut step, mut block) = (max_range.min(200), start);
    while block <= end {
        let to = (block + step - 1).min(end);
        let filter = json!([{"address": addresses, "topics": topics,
                             "fromBlock": format!("{block:#x}"), "toBlock": format!("{to:#x}")}]);
        let logs = match rpc.call("eth_getLogs", filter, 2) {
            Ok(logs) => logs,
            Err(e) if step == 1 => return Err(e),
            Err(_) => { step /= 2; continue; }
        };
        let logs = logs.as_array().ok_or("eth_getLogs returned no list")?;
        for log in logs {
            each(log).map_err(|e| e.to_string())?;
        }
        block = to + 1;
        if logs.len() > TARGET_LOGS_PER_CALL {
            step = (step / 2).max(1);
        } else if logs.len() < TARGET_LOGS_PER_CALL / 4 {
            step = (step * 2).min(max_range);
        }
    }
    Ok(())
}

const HEADER: &str = "block,timestamp,tx_hash,log_index,version,exchange,role,order_hash,maker,taker,\
side,token_id,price,shares,collateral,fee,fee_asset";

/// One CSV row per OrderFilled log.
fn decode(log: &Value, version: Version) -> String {
    let topic = |i: usize| log["topics"][i].as_str().unwrap_or_default();
    let field = |name: &str| log[name].as_str().unwrap_or_default();
    let maker = format!("0x{}", &topic(2)[26..]);
    let taker = format!("0x{}", &topic(3)[26..]);
    let data = &field("data")[2..];
    let words: Vec<&str> = (0..data.len() / 64).map(|i| &data[i * 64..i * 64 + 64]).collect();
    // Amounts are 6-decimal integers; the low 128 bits of each word hold them.
    let amount = |i: usize| u128::from_str_radix(&words[i][32..], 16).unwrap_or(0);
    let is_zero = |i: usize| words[i].bytes().all(|b| b == b'0');

    let (buy, token_id, maker_amount, taker_amount, fee, fee_asset) = match version {
        // V2 fees are always in pUSD
        Version::V2 => (is_zero(0), words[1], amount(2), amount(3), amount(4), "collateral"),
        Version::V1 => {
            let buy = is_zero(0); // asset id 0 is collateral
            let token = if buy { words[1] } else { words[0] };
            // V1 charges fees in proceeds
            (buy, token, amount(2), amount(3), amount(4), if buy { "shares" } else { "collateral" })
        }
    };
    // A BUY order pays collateral and receives outcome tokens; a SELL does the reverse.
    let (cash, shares) = if buy { (maker_amount, taker_amount) } else { (taker_amount, maker_amount) };
    let price = if shares > 0 {
        ((cash as f64 / shares as f64) * 1e6).round() / 1e6
    } else {
        f64::NAN
    };
    let exchange = field("address");
    // The taker order's fill is logged with the exchange as counterparty.
    let role = if taker == exchange { "taker" } else { "maker" };
    format!(
        "{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{}",
        hex_u64(&log["blockNumber"]), hex_u64(&log["blockTimestamp"]), field("transactionHash"),
        hex_u64(&log["logIndex"]), version.name(), exchange, role, topic(1), maker, taker,
        if buy { "BUY" } else { "SELL" }, BigUint::parse_bytes(token_id.as_bytes(), 16).unwrap_or_default(),
        if price.is_nan() { String::new() } else { price.to_string() },
        shares as f64 / 1e6, cash as f64 / 1e6, fee as f64 / 1e6, fee_asset, // USDC.e in V1, pUSD in V2
    )
}

/// Write decoded fills from every exchange version active in the range.
fn fills(rpc: &Rpc, start: u64, end: u64, maker: Option<&str>, max_range: u64,
         mut each: impl FnMut(String) -> std::io::Result<()>) -> Result<(), String> {
    for version in [Version::V1, Version::V2] {
        let (lo, hi) = match version {
            Version::V1 => (start, end.min(V1_LAST_FILL_BLOCK)),
            Version::V2 => (start.max(V2_FIRST_FILL_BLOCK), end),
        };
        if lo > hi {
            continue;
        }
        let maker_topic = maker.map(|m| format!("0x{:0>64}", m.to_lowercase().trim_start_matches("0x")));
        let topics = json!([version.order_filled(), null, maker_topic]);
        get_logs(rpc, &version.exchanges(), &topics, lo, hi, max_range, |log| each(decode(log, version)))?;
    }
    Ok(())
}

fn parse_time(value: &str) -> Result<u64, String> {
    NaiveDateTime::parse_from_str(value, "%Y-%m-%dT%H:%M")
        .map(|t| t.and_utc().timestamp() as u64)
        .map_err(|e| format!("bad time {value}: {e}"))
}

fn commas(n: u64) -> String {
    let digits = n.to_string();
    let mut out = String::new();
    for (i, c) in digits.chars().enumerate() {
        if i > 0 && (digits.len() - i) % 3 == 0 {
            out.push(',');
        }
        out.push(c);
    }
    out
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // --start and --end in UTC, e.g. 2026-11-02T12:55; --maker for one wallet's orders (maker and taker legs)
    let args: Vec<String> = env::args().collect();
    let arg = |name: &str| args.iter().position(|a| a == name).and_then(|i| args.get(i + 1)).cloned();
    let (start, end) = (arg("--start").ok_or("--start is required")?, arg("--end").ok_or("--end is required")?);
    let maker = arg("--maker");
    let out = arg("--out").unwrap_or_else(|| "fills.csv".into());
    // eth_getLogs block limit: 10,000 on Dwellir Growth and Scale, 500 on Developer
    let max_range = env::var("MAX_BLOCK_RANGE").ok().and_then(|v| v.parse().ok()).unwrap_or(10_000);

    let rpc = Rpc::new(env::var("POLYGON_RPC_URL")?);
    let start_block = block_at(&rpc, parse_time(&start)?)?;
    let end_block = block_at(&rpc, parse_time(&end)?)? - 1;
    println!("blocks {} to {}", commas(start_block), commas(end_block));

    let mut writer = BufWriter::new(File::create(&out)?);
    writeln!(writer, "{HEADER}")?;
    let mut count = 0;
    fills(&rpc, start_block, end_block, maker.as_deref(), max_range, |row| {
        count += 1;
        writeln!(writer, "{row}")
    })?;
    writer.flush()?;
    println!("wrote {} fills to {out}", commas(count));
    Ok(())
}

// Rebuild Polymarket trade history from OrderFilled logs on Polygon.
//
// Usage:
//
//	export POLYGON_RPC_URL="https://api-polygon-mainnet-full.n.dwellir.com/<YOUR_API_KEY>"
//	go run . --start 2026-11-02T12:55 --end 2026-11-02T13:20 --out fills.csv
package main

import (
	"bufio"
	"bytes"
	"encoding/json"
	"flag"
	"fmt"
	"log"
	"math"
	"math/big"
	"net/http"
	"os"
	"strconv"
	"strings"
	"time"
)

// CTF Exchange and NegRisk CTF Exchange, before and after the CLOB V2 upgrade.
var exchanges = map[string][]string{
	"v1": {"0x4bfb41d5b3570defd03c39a9a4d8de6bd8b8982e", // CTF Exchange
		"0xc5d563a36ae78145c45a50134d48a1215220f80a"}, // NegRisk CTF Exchange
	"v2": {"0xe111180000d2663c0091e4f400237545b87b996b", // CTFExchangeV2
		"0xe2222d279d744050d28e00520010520000310f59"}, // NegRiskCtfExchangeV2
}

// keccak256 of the OrderFilled signature in each version
var orderFilled = map[string]string{
	"v1": "0xd0a08e8c493f9c94f29311604c9de1b4e8c8d4c06bd0c789af57f2d65bfec0f6",
	"v2": "0xd543adfd945773f1a62f74f0ee55a5e3b9b1a28262980ba90b1a89f2ea84d8ee",
}

const (
	v2FirstFillBlock  = 86_100_351 // 2026-04-27 20:12 UTC
	v1LastFillBlock   = 86_126_998 // 2026-04-28 11:00 UTC
	targetLogsPerCall = 10_000     // keeps each response near 10 MB
	header            = "block,timestamp,tx_hash,log_index,version,exchange,role,order_hash,maker,taker,side,token_id,price,shares,collateral,fee,fee_asset"
)

var (
	rpcURL = os.Getenv("POLYGON_RPC_URL")
	client = &http.Client{Timeout: 120 * time.Second}
	// eth_getLogs block limit: 10,000 on Dwellir Growth and Scale, 500 on Developer
	maxBlockRange = envInt("MAX_BLOCK_RANGE", 10_000)
)

type Log struct {
	Address         string   `json:"address"`
	Topics          []string `json:"topics"`
	Data            string   `json:"data"`
	BlockNumber     string   `json:"blockNumber"`
	BlockTimestamp  string   `json:"blockTimestamp"`
	TransactionHash string   `json:"transactionHash"`
	LogIndex        string   `json:"logIndex"`
}

func rpc(method string, params any, retries int, result any) error {
	body, _ := json.Marshal(map[string]any{"jsonrpc": "2.0", "id": 1, "method": method, "params": params})
	var err error
	for attempt := 0; attempt < retries; attempt++ {
		err = post(body, result)
		if err == nil {
			return nil
		}
		time.Sleep(time.Second << attempt)
	}
	return fmt.Errorf("%s failed: %w", method, err)
}

func post(body []byte, result any) error {
	resp, err := client.Post(rpcURL, "application/json", bytes.NewReader(body))
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	var out struct {
		Result json.RawMessage `json:"result"`
		Error  json.RawMessage `json:"error"`
	}
	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
		return err
	}
	if out.Error != nil {
		return fmt.Errorf("%s", out.Error)
	}
	return json.Unmarshal(out.Result, result)
}

func hexInt(s string) uint64 {
	n, _ := strconv.ParseUint(strings.TrimPrefix(s, "0x"), 16, 64)
	return n
}

// blockAt returns the first block with timestamp >= ts (binary search on block headers).
func blockAt(ts uint64) uint64 {
	var head string
	must(rpc("eth_blockNumber", []any{}, 4, &head))
	lo, hi := uint64(1), hexInt(head)
	for lo < hi {
		mid := (lo + hi) / 2
		var block struct{ Timestamp string }
		must(rpc("eth_getBlockByNumber", []any{fmt.Sprintf("%#x", mid), false}, 4, &block))
		if hexInt(block.Timestamp) < ts {
			lo = mid + 1
		} else {
			hi = mid
		}
	}
	return lo
}

// getLogs calls each for every log in [start, end]. It shrinks the range when a call fails or returns too much.
func getLogs(addresses []string, topics []any, start, end uint64, each func(Log)) error {
	step, block := min(200, maxBlockRange), start
	for block <= end {
		to := min(block+step-1, end)
		filter := map[string]any{"address": addresses, "topics": topics,
			"fromBlock": fmt.Sprintf("%#x", block), "toBlock": fmt.Sprintf("%#x", to)}
		var logs []Log
		if err := rpc("eth_getLogs", []any{filter}, 2, &logs); err != nil {
			if step == 1 {
				return err
			}
			step /= 2
			continue
		}
		for _, l := range logs {
			each(l)
		}
		block = to + 1
		if len(logs) > targetLogsPerCall {
			step = max(1, step/2)
		} else if len(logs) < targetLogsPerCall/4 {
			step = min(maxBlockRange, step*2)
		}
	}
	return nil
}

func decode(l Log, version string) []string {
	maker := "0x" + l.Topics[2][26:]
	taker := "0x" + l.Topics[3][26:]
	raw := l.Data[2:]
	word := func(i int) *big.Int {
		n, _ := new(big.Int).SetString(raw[i*64:i*64+64], 16)
		return n
	}
	var buy bool
	var tokenID, makerAmount, takerAmount, fee *big.Int
	var feeAsset string
	if version == "v2" {
		buy = word(0).Sign() == 0
		tokenID, makerAmount, takerAmount, fee = word(1), word(2), word(3), word(4)
		feeAsset = "collateral" // V2 fees are always in pUSD
	} else {
		makerAsset, takerAsset := word(0), word(1)
		buy = makerAsset.Sign() == 0 // asset id 0 is collateral
		makerAmount, takerAmount, fee = word(2), word(3), word(4)
		tokenID, feeAsset = makerAsset, "collateral"
		if buy {
			tokenID, feeAsset = takerAsset, "shares" // V1 charges fees in proceeds
		}
	}
	// A BUY order pays collateral and receives outcome tokens; a SELL does the reverse.
	cash, shares, side := makerAmount, takerAmount, "BUY"
	if !buy {
		cash, shares, side = takerAmount, makerAmount, "SELL"
	}
	price := ""
	if shares.Sign() > 0 {
		price = num(math.Round(float(cash)/float(shares)*1e6) / 1e6)
	}
	role := "maker"
	if taker == l.Address { // the taker order's fill is logged with the exchange as counterparty
		role = "taker"
	}
	return []string{
		strconv.FormatUint(hexInt(l.BlockNumber), 10), strconv.FormatUint(hexInt(l.BlockTimestamp), 10),
		l.TransactionHash, strconv.FormatUint(hexInt(l.LogIndex), 10), version, l.Address, role,
		l.Topics[1], maker, taker, side, tokenID.String(), price,
		num(float(shares) / 1e6), num(float(cash) / 1e6), // USDC.e in V1, pUSD in V2; both 6 decimals
		num(float(fee) / 1e6), feeAsset,
	}
}

// fills calls each with every decoded fill from the exchange versions active in the range.
func fills(start, end uint64, maker string, each func([]string)) error {
	for _, version := range []string{"v1", "v2"} {
		lo, hi := start, min(end, v1LastFillBlock)
		if version == "v2" {
			lo, hi = max(start, v2FirstFillBlock), end
		}
		if lo > hi {
			continue
		}
		topics := []any{orderFilled[version], nil, nil}
		if maker != "" {
			topics[2] = "0x" + fmt.Sprintf("%064s", strings.TrimPrefix(strings.ToLower(maker), "0x"))
		}
		if err := getLogs(exchanges[version], topics, lo, hi, func(l Log) { each(decode(l, version)) }); err != nil {
			return err
		}
	}
	return nil
}

func main() {
	start := flag.String("start", "", "UTC, e.g. 2026-11-02T12:55")
	end := flag.String("end", "", "UTC")
	maker := flag.String("maker", "", "only fills of orders signed by this wallet (maker and taker legs)")
	out := flag.String("out", "fills.csv", "output CSV")
	flag.Parse()

	startBlock, endBlock := blockAt(parseTime(*start)), blockAt(parseTime(*end))-1
	fmt.Printf("blocks %s to %s\n", commas(startBlock), commas(endBlock))

	file, err := os.Create(*out)
	must(err)
	w := bufio.NewWriter(file)
	fmt.Fprintln(w, header)
	count := uint64(0)
	must(fills(startBlock, endBlock, *maker, func(row []string) {
		fmt.Fprintln(w, strings.Join(row, ",")) // no field contains a comma
		count++
	}))
	must(w.Flush())
	must(file.Close())
	fmt.Printf("wrote %s fills to %s\n", commas(count), *out)
}

func parseTime(value string) uint64 {
	t, err := time.Parse("2006-01-02T15:04", value)
	must(err)
	return uint64(t.Unix())
}

func float(n *big.Int) float64 { f, _ := new(big.Float).SetInt(n).Float64(); return f }

func num(f float64) string { return strconv.FormatFloat(f, 'f', -1, 64) }

func commas(n uint64) string {
	s := strconv.FormatUint(n, 10)
	for i := len(s) - 3; i > 0; i -= 3 {
		s = s[:i] + "," + s[i:]
	}
	return s
}

func envInt(name string, fallback uint64) uint64 {
	if n, err := strconv.ParseUint(os.Getenv(name), 10, 64); err == nil {
		return n
	}
	return fallback
}

func must(err error) {
	if err != nil {
		log.Fatal(err)
	}
}

/**
 * Rebuild Polymarket trade history from OrderFilled logs on Polygon.
 *
 * Usage (Node.js 22.18 or later runs TypeScript directly):
 *   export POLYGON_RPC_URL="https://api-polygon-mainnet-full.n.dwellir.com/<YOUR_API_KEY>"
 *   node polymarket_fills.ts --start 2026-11-02T12:55 --end 2026-11-02T13:20 --out fills.csv
 */
import { createWriteStream } from "node:fs";
import { once } from "node:events";
import { parseArgs } from "node:util";

const RPC_URL = process.env.POLYGON_RPC_URL!;

type Version = "v1" | "v2";

// CTF Exchange and NegRisk CTF Exchange, before and after the CLOB V2 upgrade.
const EXCHANGES: Record<Version, string[]> = {
  v1: ["0x4bfb41d5b3570defd03c39a9a4d8de6bd8b8982e",  // CTF Exchange
       "0xc5d563a36ae78145c45a50134d48a1215220f80a"], // NegRisk CTF Exchange
  v2: ["0xe111180000d2663c0091e4f400237545b87b996b",  // CTFExchangeV2
       "0xe2222d279d744050d28e00520010520000310f59"], // NegRiskCtfExchangeV2
};
// keccak256 of the OrderFilled signature in each version
const ORDER_FILLED: Record<Version, string> = {
  v1: "0xd0a08e8c493f9c94f29311604c9de1b4e8c8d4c06bd0c789af57f2d65bfec0f6",
  v2: "0xd543adfd945773f1a62f74f0ee55a5e3b9b1a28262980ba90b1a89f2ea84d8ee",
};
const V2_FIRST_FILL_BLOCK = 86_100_351; // 2026-04-27 20:12 UTC
const V1_LAST_FILL_BLOCK = 86_126_998;  // 2026-04-28 11:00 UTC
// eth_getLogs block limit: 10,000 on Dwellir Growth and Scale, 500 on Developer
const MAX_BLOCK_RANGE = Number(process.env.MAX_BLOCK_RANGE ?? 10_000);
const TARGET_LOGS_PER_CALL = 10_000;    // keeps each response near 10 MB

interface Log {
  address: string;
  topics: string[];
  data: string;
  blockNumber: string;
  blockTimestamp: string;
  transactionHash: string;
  logIndex: string;
}

const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));

async function rpc<T>(method: string, params: unknown[], retries = 4): Promise<T> {
  let error: unknown;
  for (let attempt = 0; attempt < retries; attempt++) {
    try {
      const res = await fetch(RPC_URL, {
        method: "POST",
        headers: { "content-type": "application/json" },
        body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
        signal: AbortSignal.timeout(120_000),
      });
      const body = await res.json();
      if (!("error" in body)) return body.result as T;
      error = JSON.stringify(body.error);
    } catch (exc) {
      error = exc;
    }
    await sleep(1000 * 2 ** attempt);
  }
  throw new Error(`${method} failed: ${error}`);
}

/** First block with timestamp >= ts (binary search on block headers). */
async function blockAt(ts: number): Promise<number> {
  let lo = 1;
  let hi = Number(await rpc<string>("eth_blockNumber", []));
  while (lo < hi) {
    const mid = Math.floor((lo + hi) / 2);
    const block = await rpc<{ timestamp: string }>("eth_getBlockByNumber", ["0x" + mid.toString(16), false]);
    if (Number(block.timestamp) < ts) lo = mid + 1;
    else hi = mid;
  }
  return lo;
}

/** Yield logs for [start, end]. Shrink the range when a call fails or returns too much. */
async function* getLogs(addresses: string[], topics: (string | null)[], start: number, end: number) {
  let step = Math.min(200, MAX_BLOCK_RANGE);
  let block = start;
  while (block <= end) {
    const to = Math.min(block + step - 1, end);
    let logs: Log[];
    try {
      logs = await rpc<Log[]>("eth_getLogs", [{ address: addresses, topics,
        fromBlock: "0x" + block.toString(16), toBlock: "0x" + to.toString(16) }], 2);
    } catch (exc) {
      if (step === 1) throw exc;
      step = Math.floor(step / 2);
      continue;
    }
    yield* logs;
    block = to + 1;
    if (logs.length > TARGET_LOGS_PER_CALL) step = Math.max(1, Math.floor(step / 2));
    else if (logs.length < TARGET_LOGS_PER_CALL / 4) step = Math.min(MAX_BLOCK_RANGE, step * 2);
  }
}

function decode(log: Log, version: Version) {
  const maker = "0x" + log.topics[2].slice(-40);
  const taker = "0x" + log.topics[3].slice(-40);
  const raw = log.data.slice(2);
  const w = Array.from({ length: raw.length / 64 }, (_, i) => BigInt("0x" + raw.slice(i * 64, i * 64 + 64)));
  let side: "BUY" | "SELL", tokenId: bigint, makerAmount: bigint, takerAmount: bigint, fee: bigint;
  let feeAsset: "collateral" | "shares";
  if (version === "v2") {
    side = w[0] === 0n ? "BUY" : "SELL";
    [tokenId, makerAmount, takerAmount, fee] = [w[1], w[2], w[3], w[4]];
    feeAsset = "collateral"; // V2 fees are always in pUSD
  } else {
    const [makerAsset, takerAsset] = [w[0], w[1]];
    [makerAmount, takerAmount, fee] = [w[2], w[3], w[4]];
    side = makerAsset === 0n ? "BUY" : "SELL"; // asset id 0 is collateral
    tokenId = side === "BUY" ? takerAsset : makerAsset;
    feeAsset = side === "BUY" ? "shares" : "collateral"; // V1 charges fees in proceeds
  }
  // A BUY order pays collateral and receives outcome tokens; a SELL does the reverse.
  const [cash, shares] = side === "BUY" ? [makerAmount, takerAmount] : [takerAmount, makerAmount];
  return {
    block: Number(log.blockNumber),
    timestamp: Number(log.blockTimestamp),
    tx_hash: log.transactionHash,
    log_index: Number(log.logIndex),
    version,
    exchange: log.address,
    // The taker order's fill is logged with the exchange as counterparty.
    role: taker === log.address ? "taker" : "maker",
    order_hash: log.topics[1],
    maker,
    taker,
    side,
    token_id: tokenId.toString(),
    price: shares ? Math.round((Number(cash) / Number(shares)) * 1e6) / 1e6 : null,
    shares: Number(shares) / 1e6,
    collateral: Number(cash) / 1e6, // USDC.e in V1, pUSD in V2; both 6 decimals
    fee: Number(fee) / 1e6,
    fee_asset: feeAsset,
  };
}

/** Yield decoded fills from every exchange version active in the range. */
async function* fills(startBlock: number, endBlock: number, maker?: string) {
  for (const version of ["v1", "v2"] as const) {
    const lo = version === "v1" ? startBlock : Math.max(startBlock, V2_FIRST_FILL_BLOCK);
    const hi = version === "v1" ? Math.min(endBlock, V1_LAST_FILL_BLOCK) : endBlock;
    if (lo > hi) continue;
    const makerTopic = maker ? "0x" + maker.toLowerCase().slice(2).padStart(64, "0") : null;
    for await (const log of getLogs(EXCHANGES[version], [ORDER_FILLED[version], null, makerTopic], lo, hi)) {
      yield decode(log, version);
    }
  }
}

const parseTime = (value: string) => Date.parse(value + "Z") / 1000;

const { values: args } = parseArgs({
  options: {
    start: { type: "string" }, // UTC, e.g. 2026-11-02T12:55
    end: { type: "string" },
    maker: { type: "string" }, // only fills of orders signed by this wallet (maker and taker legs)
    out: { type: "string", default: "fills.csv" },
  },
});
if (!args.start || !args.end) throw new Error("--start and --end are required");

const startBlock = await blockAt(parseTime(args.start));
const endBlock = (await blockAt(parseTime(args.end))) - 1;
console.log(`blocks ${startBlock.toLocaleString("en-US")} to ${endBlock.toLocaleString("en-US")}`);

const out = createWriteStream(args.out!);
let count = 0;
for await (const row of fills(startBlock, endBlock, args.maker)) {
  if (count === 0) out.write(Object.keys(row).join(",") + "\n");
  if (!out.write(Object.values(row).map((v) => v ?? "").join(",") + "\n")) await once(out, "drain");
  count++;
}
out.end();
await once(out, "finish");
console.log(`wrote ${count.toLocaleString("en-US")} fills to ${args.out}`);

python polymarket_fills.py --start 2026-11-02T12:55 --end 2026-11-02T13:20 --out fills.csv

cargo run --release -- --start 2026-11-02T12:55 --end 2026-11-02T13:20 --out fills.csv

go run . --start 2026-11-02T12:55 --end 2026-11-02T13:20 --out fills.csv

node polymarket_fills.ts --start 2026-11-02T12:55 --end 2026-11-02T13:20 --out fills.csv

python polymarket_fills.py --start 2026-10-29T00:00 --end 2026-11-02T13:00 \
  --maker 0x55941ce9f9029293c4c5385fcfcec36e41dfb390 --out wallet.csv

cargo run --release -- --start 2026-10-29T00:00 --end 2026-11-02T13:00 \
  --maker 0x55941ce9f9029293c4c5385fcfcec36e41dfb390 --out wallet.csv

go run . --start 2026-10-29T00:00 --end 2026-11-02T13:00 \
  --maker 0x55941ce9f9029293c4c5385fcfcec36e41dfb390 --out wallet.csv

node polymarket_fills.ts --start 2026-10-29T00:00 --end 2026-11-02T13:00 \
  --maker 0x55941ce9f9029293c4c5385fcfcec36e41dfb390 --out wallet.csv