Running it

# pip install requests "pyjwt[crypto]"
import json, os, time, uuid
import jwt, requests

CLIENT_ID   = os.environ["PMX_CLIENT_ID"]        # from the clientid.txt we share with you
PRIVATE_KEY = open(os.environ["PMX_PRIVATE_KEY"]).read()  # private half of the keypair you sent us
PARTICIPANT = os.environ["PMX_PARTICIPANT_ID"]   # participantId from the kyc.approved webhook
TOKEN_URL   = "https://pmx-preprod.us.auth0.com/oauth/token"
API_BASE    = "https://api.preprod.polymarketexchange.com"

SYMBOLS = ["aec-cfb-clmsn-lsu-2026-09-05"]       # the symbols you traded; shard one call per symbol
DAY     = "2026-09-14"                           # the traded day you are exporting

ROWS_KEY         = "trades"        # VERIFY with your integration lead
PAGE_TOKEN_FIELD = "pageToken"     # VERIFY with your integration lead
TIMEOUT_S        = 35              # above the 30s edge cut, so a 504 is visible rather than a hang

def access_token():
    now = int(time.time())
    assertion = jwt.encode(
        {"iss": CLIENT_ID, "sub": CLIENT_ID,
         "aud": TOKEN_URL,          # aud is the Auth0 token endpoint, NOT the API
         "iat": now, "exp": now + 240, "jti": str(uuid.uuid4())},
        PRIVATE_KEY, algorithm="RS256")
    r = requests.post(TOKEN_URL, timeout=10, data={
        "grant_type": "client_credentials",
        "client_id": CLIENT_ID,
        "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer",
        "client_assertion": assertion,
        "audience": API_BASE,       # never request scopes here; scopes are granted server-side
    })
    r.raise_for_status()
    b = r.json()
    # honour expires_in (180) minus a 30s buffer; do not hardcode 180
    return b["access_token"], now + int(b["expires_in"]) - 30

def post(path, body, tok):
    r = requests.post(f"{API_BASE}{path}", json=body, timeout=TIMEOUT_S, headers={
        "authorization": f"Bearer {tok}",
        "x-participant-id": PARTICIPANT,   # reports are account-scoped
        "content-type": "application/json",
    })
    if r.status_code == 429:
        time.sleep(float(r.headers.get("Retry-After", "5")))   # 429 carries Retry-After
        return post(path, body, tok)
    if r.status_code == 504:
        raise RuntimeError(f"504 at the edge on {path}: over 30s. Narrow the query, do not retry it.")
    r.raise_for_status()
    return r.json()

def sweep(symbol, tok, out):
    seen, page = set(), None
    while True:
        body = {"where_clause": f"symbol = '{symbol}'",   # VERIFY filter shape
                "start_time": f"{DAY}T00:00:00Z", "end_time": f"{DAY}T23:59:59Z"}
        if page:
            body[PAGE_TOKEN_FIELD] = page
        t0 = time.time()
        res = post("/v1/report/trades/search", body, tok)
        print(f"{symbol} page in {int((time.time()-t0)*1000)} ms")   # expect ~130 ms
        for row in res.get(ROWS_KEY, []):
            key = json.dumps(row, sort_keys=True)   # offset-based tokens can repeat a row
            if key in seen:
                continue
            seen.add(key)
            out.write(key + "\n")
        page = res.get("nextPageToken")
        if not page:                                # absent token is EOF; do not probe once more
            return len(seen)

tok, exp = access_token()
with open(f"trades-{DAY}.ndjson", "w") as out:
    for s in SYMBOLS:
        if time.time() > exp:
            tok, exp = access_token()
        print(s, "rows:", sweep(s, tok, out))

// npm i jose   (Node 18+ for global fetch)
import { readFileSync, writeFileSync } from "node:fs";
import { randomUUID } from "node:crypto";
import { SignJWT, importPKCS8 } from "jose";

const CLIENT_ID = process.env.PMX_CLIENT_ID!;              // from the clientid.txt we share with you
const PRIVATE_KEY = readFileSync(process.env.PMX_PRIVATE_KEY!, "utf8"); // your private key
const PARTICIPANT = process.env.PMX_PARTICIPANT_ID!;       // from the kyc.approved webhook
const TOKEN_URL = "https://pmx-preprod.us.auth0.com/oauth/token";
const API_BASE = "https://api.preprod.polymarketexchange.com";

const SYMBOLS = ["aec-cfb-clmsn-lsu-2026-09-05"];          // one call per symbol
const DAY = "2026-09-14";
const ROWS_KEY = "trades";            // VERIFY with your integration lead
const PAGE_TOKEN_FIELD = "pageToken"; // VERIFY with your integration lead
const TIMEOUT_MS = 35_000;            // above the 30s edge cut

async function accessToken(): Promise<{ token: string; expiresAt: number }> {
  const key = await importPKCS8(PRIVATE_KEY, "RS256");
  const assertion = await new SignJWT({ jti: randomUUID() })
    .setProtectedHeader({ alg: "RS256" })
    .setIssuer(CLIENT_ID).setSubject(CLIENT_ID)
    .setAudience(TOKEN_URL)            // the token endpoint, NOT the API
    .setIssuedAt().setExpirationTime("4m")
    .sign(key);
  const res = await fetch(TOKEN_URL, {
    method: "POST",
    headers: { "content-type": "application/x-www-form-urlencoded" },
    body: new URLSearchParams({
      grant_type: "client_credentials",
      client_id: CLIENT_ID,
      client_assertion_type: "urn:ietf:params:oauth:client-assertion-type:jwt-bearer",
      client_assertion: assertion,
      audience: API_BASE,              // no scope parameter; scopes are server-side grants
    }),
  });
  if (!res.ok) throw new Error(`token mint failed: ${res.status} ${await res.text()}`);
  const b = await res.json();
  // honour expires_in (180) minus a 30s buffer
  return { token: b.access_token, expiresAt: Date.now() + (b.expires_in - 30) * 1000 };
}

async function post(path: string, body: unknown, token: string): Promise<any> {
  const res = await fetch(`${API_BASE}${path}`, {
    method: "POST",
    signal: AbortSignal.timeout(TIMEOUT_MS),
    headers: {
      authorization: `Bearer ${token}`,
      "x-participant-id": PARTICIPANT,  // reports are account-scoped
      "content-type": "application/json",
    },
    body: JSON.stringify(body),
  });
  if (res.status === 429) {
    const wait = Number(res.headers.get("Retry-After") ?? 5);
    await new Promise((r) => setTimeout(r, wait * 1000));
    return post(path, body, token);
  }
  if (res.status === 504)
    throw new Error(`504 at the edge on ${path}: over 30s. Narrow the query, do not retry it.`);
  if (!res.ok) throw new Error(`${path} failed: ${res.status} ${await res.text()}`);
  return res.json();
}

const rows: string[] = [];
let { token, expiresAt } = await accessToken();
for (const symbol of SYMBOLS) {
  const seen = new Set<string>();
  let page: string | undefined;
  do {
    if (Date.now() > expiresAt) ({ token, expiresAt } = await accessToken());
    const body: Record<string, unknown> = {
      where_clause: `symbol = '${symbol}'`,            // VERIFY filter shape
      start_time: `${DAY}T00:00:00Z`, end_time: `${DAY}T23:59:59Z`,
    };
    if (page) body[PAGE_TOKEN_FIELD] = page;
    const t0 = Date.now();
    const res = await post("/v1/report/trades/search", body, token);
    console.log(`${symbol} page in ${Date.now() - t0} ms`);   // expect ~130 ms
    for (const row of res[ROWS_KEY] ?? []) {
      const key = JSON.stringify(row, Object.keys(row).sort()); // offset tokens can repeat a row
      if (!seen.has(key)) { seen.add(key); rows.push(key); }
    }
    page = res.nextPageToken;                          // absent means EOF; do not probe again
  } while (page);
  console.log(symbol, "rows:", seen.size);
}
writeFileSync(`trades-${DAY}.ndjson`, rows.join("\n") + "\n");

# pip install requests "pyjwt[crypto]"
import json, sqlite3, sys, time
from decimal import Decimal, ROUND_HALF_EVEN
from export_trades import access_token, post   # the snippet in "Reporting and bulk export" above

DB          = "book.sqlite"     # your existing local database, written by your drop-copy consumer
DAY         = "2026-09-14"      # the traded day you are closing
SYMBOLS     = ["aec-cfb-clmsn-lsu-2026-09-05"]  # symbols you traded that day
THETA_TAKER = Decimal("0.06")   # taker Θ in force on DAY, from the published Fee Schedule. It changed
                                # on 2026-09-14; store it per effective date, never as one constant
ROWS_KEY    = "trades"          # VERIFY with your integration lead, as in the export above

db = sqlite3.connect(DB)

def checkpoint(stream):
    """A restart resumes from here. If this returns None you are genuinely cold-starting."""
    row = db.execute("SELECT resume_token FROM checkpoints WHERE stream = ?", (stream,)).fetchone()
    return row[0] if row else None

def expected_fee(contracts: Decimal, price: Decimal) -> Decimal:
    """Fee = Θ × C × p × (1 − p), banker's rounded to the cent."""
    return (THETA_TAKER * contracts * price * (Decimal(1) - price)).quantize(
        Decimal("0.01"), rounding=ROUND_HALF_EVEN)

breaks = []

if checkpoint("dropcopy") is None:
    breaks.append("no drop-copy checkpoint: this is a cold start, not a restart")

token, expires_at = access_token()
for symbol in SYMBOLS:
    if time.time() > expires_at:
        token, expires_at = access_token()

    # Your store is the record. Read it first; do not rebuild it from the anchor.
    local = db.execute(
        "SELECT price_wire, qty_wire, commission_wire, price_scale, qty_scale "
        "FROM executions WHERE traded_day = ? AND symbol = ?", (DAY, symbol)).fetchall()

    # The anchor read. Always symbol-filtered: unfiltered hits the 30s edge 504 two thirds of the time.
    anchor, page = [], None
    while True:
        body = {"where_clause": f"symbol = '{symbol}'",      # VERIFY filter shape
                "start_time": f"{DAY}T00:00:00Z", "end_time": f"{DAY}T23:59:59Z"}
        if page:
            body["pageToken"] = page                          # VERIFY field name
        res = post("/v1/report/trades/search", body, token)
        anchor.extend(res.get(ROWS_KEY, []))
        page = res.get("nextPageToken")
        if not page:                                          # absent token is EOF
            break
    # Offset-based page tokens can repeat a row within a shard.
    anchor = {json.dumps(r, sort_keys=True) for r in anchor}

    if len(local) != len(anchor):
        breaks.append(f"{symbol}: {len(local)} executions locally, {len(anchor)} in the anchor read. "
                      f"Fewer in the anchor after an overnight window is expected (history is "
                      f"archived during maintenance); more in the anchor is a consumer gap")

    for price_wire, qty_wire, commission_wire, price_scale, qty_scale in local:
        # Scales are read per instrument and multiply. Never hard-code the divisor.
        price     = Decimal(price_wire) / Decimal(price_scale)
        contracts = Decimal(qty_wire) / Decimal(qty_scale)
        # One dollar is price_scale × qty_scale notional units.
        fee       = Decimal(commission_wire) / (Decimal(price_scale) * Decimal(qty_scale))
        want      = expected_fee(contracts, price)
        if fee != want:
            breaks.append(f"{symbol}: commission {fee} != expected {want} "
                          f"(C={contracts} p={price} Θ={THETA_TAKER})")

for b in breaks:
    print("BREAK:", b, file=sys.stderr)
print(f"{DAY}: {len(breaks)} breaks across {len(SYMBOLS)} symbols")
sys.exit(1 if breaks else 0)