Intents and RFQs

Use this guide when you want to analyze requests for quote, solver responses, executable intents, and settlement observations. Polaris standardizes these records under market="intents" while retaining source-specific fields.

Representative coverage

This snapshot comes from the public Catalog at 2026-08-27T20:33:06.675Z. Use Catalog to confirm the current sources, bounds, and access state before querying.

Source ID	Market	Access
`lifi`	`intents`	Preview
`uniswapx`	`intents`	Preview

Choose a client method

Task	Python	TypeScript	Rust
Discover sources and bounds	`catalog(...)`	`catalog(...)`	`catalog(CatalogQuery)`
Read typed intent observations	`intents(...)`	`intents(...)`	`intents(HistoricalQuery)`
Subscribe to current updates	`stream(...)`	`stream(...)`	`stream(StreamQuery)`
Read mixed standardized events	`events(...)`	`events(...)`	`events(HistoricalQuery)`
Replay stored events	`replay(...)`	`replay(...)`	`replay(ReplayQuery)`
Inspect venue-native payloads	`raw(...)`	Not exposed	`raw(RawQuery)`

Use intents when you only need canonical IntentEvent observations. Use events or replay when intent records must remain interleaved with other standardized events. Use raw when an analysis depends on fields outside the canonical intent model. See Python SDK, TypeScript SDK, and Rust SDK for complete signatures and return behavior.

Reconstruct lifecycle summaries

Each returned row is an observation, not a complete lifecycle snapshot. Keep the stored order, retain partial rows, and select the latest non-null value when you derive a summary. The following example uses Catalog to choose a bounded six-hour window, builds an observation timeline, and reports the latest known state for each captured identifier.

from datetime import timedelta

import pandas as pd
from polaris_data import PolarisClient

source = "uniswapx"
market = "intents"

with PolarisClient() as client:
    catalog = client.catalog(source=source, market=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=6))
    else:
        end = coverage_end
        start = max(coverage_start, end - timedelta(hours=6))

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

timeline_rows = []
for observation in observations:
    data = observation.get("data", {})
    intent_id = data.get("intent_id")
    rfq_id = data.get("rfq_id")
    correlation_id = (
        f"intent:{intent_id}" if intent_id else f"rfq:{rfq_id}" if rfq_id else None
    )
    if correlation_id is None:
        continue

    timeline_rows.append(
        {
            "timestamp": observation.get(
                "collector_timestamp", observation.get("timestamp")
            ),
            "sequence": observation.get("collector_sequence", 0),
            "correlation_id": correlation_id,
            "intent_id": intent_id,
            "rfq_id": rfq_id,
            "status": data.get("status"),
            "quote_id": (data.get("quote") or {}).get("quote_id"),
            "transaction_count": len(data.get("transactions") or []),
            "settled_at": data.get("settled_at"),
        }
    )

if not timeline_rows:
    print("No identifiable intent or RFQ observations in the selected interval.")
else:
    timeline = pd.DataFrame.from_records(timeline_rows).sort_values(
        ["timestamp", "sequence"]
    )

    def latest_non_null(values):
        values = values.dropna()
        return values.iloc[-1] if not values.empty else None

    summary = (
        timeline.groupby("correlation_id", sort=False)
        .agg(
            first_seen=("timestamp", "min"),
            last_seen=("timestamp", "max"),
            observations=("timestamp", "size"),
            latest_status=("status", latest_non_null),
            latest_quote_id=("quote_id", latest_non_null),
            transaction_count=("transaction_count", "max"),
            settled_at=("settled_at", latest_non_null),
        )
        .reset_index()
    )
    summary["has_settlement"] = (
        summary["settled_at"].notna() | summary["transaction_count"].gt(0)
    )
    print(summary.sort_values("last_seen", ascending=False).head(20))

This keeps status-only and settlement-only rows instead of treating their empty arrays as deletion instructions. Retain timeline when you need the complete sequence behind a summary.

Do not infer that an RFQ and an executable intent belong to the same lifecycle only because their assets, amounts, or timestamps look similar. Correlate them only when a captured row or venue identifier establishes the relationship.

Intents and RFQs schema for canonical fields, statuses, and multi-language examples
Event envelope for stored ordering and timestamp semantics
Catalog for current source and access metadata
Events for mixed standardized event streams

By Category

By Workflow

Intents and RFQs

Representative coverage

Choose a client method

Reconstruct lifecycle summaries

​Representative coverage

​Choose a client method

​Reconstruct lifecycle summaries

​Related documentation

Representative coverage

Choose a client method

Reconstruct lifecycle summaries

Related documentation