Receive RFQs

import json


async def receive_rfqs(ws) -> None:
    """Call after the Authentication handshake returns `session_token`."""
    await ws.send(json.dumps({
        "type": "subscribe",
        "subscriptions": [{"kind": "all"}],
    }))

    async for raw in ws:
        msg = json.loads(raw)
        mtype = msg.get("type")
        if mtype == "subscribed":
            continue
        elif mtype == "rfq":
            rfq = decode_rfq(msg["data"])
            print(
                f"RFQ {rfq.request_id} wager={rfq.wager_micros} "
                f"legs={len(rfq.legs)} expires_at={rfq.expires_at_ms}"
            )
        elif mtype == "ping":
            await ws.send(json.dumps({"type": "pong"}))

import base64
from dataclasses import dataclass
from typing import Optional
from uuid import UUID


@dataclass
class TakerMetadata:
    tier: int
    address: bytes  # 20 raw bytes


@dataclass
class RfqLeg:
    market_id: int
    start_at_ms: int
    market_kind: int          # 0=Price, 1=Mention
    direction: int            # 0=UP, 1=DOWN
    leg_index: int
    price_asset: int          # 0=BTC, 1=ETH, 2=SOL, 3=XRP, 4=HYPE; 0 on mention legs
    price_duration_secs: int  # 0 on mention legs


@dataclass
class BroadcastRfqRequest:
    request_id: UUID
    wager_micros: int
    expires_at_ms: int
    taker_metadata: Optional[TakerMetadata]
    order_type: int  # 1=IOC, 2=FOK
    legs: list[RfqLeg]


def decode_rfq(data_b64: str) -> BroadcastRfqRequest:
    pad = (-len(data_b64)) % 4
    payload = base64.b64decode(data_b64 + "=" * pad)
    if len(payload) != 256:
        raise ValueError(f"RFQ payload must be 256 bytes, got {len(payload)}")

    request_id = UUID(bytes=bytes(payload[0:16]))
    wager_micros = int.from_bytes(payload[16:24], "little")
    expires_at_ms = int.from_bytes(payload[24:32], "little")

    meta = payload[32:56]
    taker_metadata = None
    if meta[0] != 0:
        taker_metadata = TakerMetadata(tier=meta[1], address=bytes(meta[4:24]))

    order_type = payload[56]
    leg_count = payload[57]

    legs: list[RfqLeg] = []
    for i in range(leg_count):
        off = 64 + i * 24
        slot = payload[off:off + 24]
        legs.append(RfqLeg(
            market_id=int.from_bytes(slot[0:8], "little"),
            start_at_ms=int.from_bytes(slot[8:16], "little"),
            market_kind=slot[16],
            direction=slot[17],
            leg_index=slot[18],
            price_asset=slot[19],
            price_duration_secs=int.from_bytes(slot[20:24], "little"),
        ))

    return BroadcastRfqRequest(
        request_id=request_id,
        wager_micros=wager_micros,
        expires_at_ms=expires_at_ms,
        taker_metadata=taker_metadata,
        order_type=order_type,
        legs=legs,
    )