PropAMMs

from datetime import timedelta

import pandas as pd
from polaris_data import PolarisClient

source = "fermiswap"
market = "ethereum"

with PolarisClient() as client:
    catalog = client.catalog(source=source, market=market)
    if not catalog["markets"]:
        raise ValueError(f"No Catalog row for {source}:{market}")

    coverage = catalog["markets"][0]
    coverage_start = pd.Timestamp(coverage["start"])
    coverage_end = pd.Timestamp(coverage["end"])
    public_cutoff = coverage["access"].get("public_cutoff_date")

    if public_cutoff:
        public_day = pd.Timestamp(public_cutoff, tz="UTC")
        start = max(coverage_start, public_day)
        end = min(coverage_end, start + timedelta(hours=1))
    else:
        end = coverage_end
        start = max(coverage_start, end - timedelta(hours=1))

    ladders = list(
        client.propamm_quote_ladders(
            source=source,
            market=market,
            from_=start.to_pydatetime(),
            to=end.to_pydatetime(),
            allow_gaps=True,
        )
    )

print(f"Loaded {len(ladders):,} quote ladders")

from decimal import Decimal

records = []
seen_event_ids = set()

for event in sorted(
    ladders,
    key=lambda row: (
        row.get("collector_timestamp", 0),
        row.get("collector_sequence", 0),
    ),
):
    values = event["data"]["values"]
    event_id = values["event_id"]
    if event_id in seen_event_ids:
        continue
    seen_event_ids.add(event_id)

    input_scale = Decimal(10) ** values["token_in_decimals"]
    output_scale = Decimal(10) ** values["token_out_decimals"]

    for quote_index, quote in enumerate(values["quotes"]):
        amount_in = Decimal(quote["amount_in"]) / input_scale
        amount_out = Decimal(quote["amount_out"]) / output_scale
        if amount_in <= 0:
            continue

        records.append(
            {
                "timestamp": pd.to_datetime(
                    event["collector_timestamp"], unit="ms", utc=True
                ),
                "source": event["source"],
                "market": market,
                "event_id": event_id,
                "block_number": values["block_number"],
                "token_in": values["token_in"],
                "token_out": values["token_out"],
                "pool": values.get("pool"),
                "quote_index": quote_index,
                "amount_in": amount_in,
                "amount_out": amount_out,
                "output_per_input": amount_out / amount_in,
            }
        )

quotes = pd.DataFrame.from_records(records)
print(quotes.head())

if quotes.empty:
    print("No quote points in the selected interval.")
else:
    latest_event_id = quotes.sort_values(
        ["timestamp", "block_number", "quote_index"]
    ).iloc[-1]["event_id"]
    curve = (
        quotes.loc[quotes["event_id"].eq(latest_event_id)]
        .sort_values("amount_in")
        .copy()
    )

    reference_rate = curve.iloc[0]["output_per_input"]
    curve["rate_change_bps"] = (
        curve["output_per_input"] / reference_rate - Decimal(1)
    ) * Decimal(10_000)

    print(
        curve[
            [
                "token_in",
                "token_out",
                "amount_in",
                "amount_out",
                "output_per_input",
                "rate_change_bps",
            ]
        ]
    )