Task-sized snippets for the QUIC-only Solana BDN. Feeds use the raw MoQT client (@clutchcall/sdk/moqt); transactions use the HTTP/3 submit API. There is no typed Crypto client yet — see SDK methods.

​
Connect to the feed relay

Dial the feed relay once and reuse the client for every track. It auto-reconnects. 
import { MoqtClient } from "@clutchcall/sdk/moqt";

const client = await MoqtClient.connect(
  "quic://feeds.clutchcall.dev",
  process.env.CLUTCHCALL_CREDENTIALS,
);

​
Subscribe to a feed track

Each public mainnet track lives under sol/feed/mainnet. Decode the frame payload as the track’s schema. 
const sub = client.subscribeFrame("sol/feed/mainnet", "slots", (_ts, _p, data) => {
  const { slot } = JSON.parse(new TextDecoder().decode(data));
  console.log("slot", slot);
});

​
Stream recent blockhash

The blockhash track carries { slot, blockhash, lastValidBlockHeight } — keep the latest to build transactions against a fresh blockhash. 
let recent = { blockhash: "", lastValidBlockHeight: 0 };
client.subscribeFrame("sol/feed/mainnet", "blockhash", (_ts, _p, data) => {
  recent = JSON.parse(new TextDecoder().decode(data));
});

​
Track the priority-fee market

The priorityFee track carries { slot, p50, max } — size your compute-unit price off the live p50 instead of guessing. 
client.subscribeFrame("sol/feed/mainnet", "priorityFee", (_ts, _p, data) => {
  const { p50, max } = JSON.parse(new TextDecoder().decode(data));
  console.log("priority fee µ-lamports — p50", p50, "max", max);
});

​
Submit a transaction with BDN fan-out

Hand the signed tx to the BDN once; it dedups and lands it on every edge’s nearby leaders. leader=auto resolves the schedule for you. 
curl --http3 \
  "https://crypto.clutchcall.dev/bdn/submit?leader=auto" \
  -H "Authorization: Bearer $CLUTCHCALL_CREDENTIALS" \
  -H "Content-Type: application/octet-stream" \
  --data-binary @tx.bin

​
Submit straight to the TPU (no fan-out)

Skip the mesh and land on the current + next leader from this node directly. 
curl --http3 \
  "https://crypto.clutchcall.dev/tpu?host=auto" \
  -H "Authorization: Bearer $CLUTCHCALL_CREDENTIALS" \
  -H "Content-Type: application/octet-stream" \
  --data-binary @tx.bin

​
Target a specific validator leader

Pin the land to one validator’s TPU instead of auto-resolving the schedule. 
curl --http3 \
  "https://crypto.clutchcall.dev/tpu?host=<validator-host>&port=<quic-port>" \
  -H "Authorization: Bearer $CLUTCHCALL_CREDENTIALS" \
  -H "Content-Type: application/octet-stream" \
  --data-binary @tx.bin

​
Submit from code over HTTP/3

The body is the raw signed transaction bytes — no JSON envelope. 
import os, httpx
res = httpx.post(
    "https://crypto.clutchcall.dev/bdn/submit",
    params={"leader": "auto"},
    headers={
        "Authorization": f"Bearer {os.environ['CLUTCHCALL_CREDENTIALS']}",
        "Content-Type": "application/octet-stream",
    },
    content=signed_tx,
)
print(res.json())   # {"ok": true, "sig": "…"}

​
Deduplicate your own re-submits

The BDN dedups on the first 64 bytes (the Solana signature). Re-sending the same signed tx across edges is safe — it lands at most once per leader within the dedup TTL, so a retry loop won’t double-land. 
async function submitWithRetry(tx: Uint8Array, attempts = 3) {
  for (let i = 0; i < attempts; i++) {
    const r = await fetch(`https://crypto.clutchcall.dev/bdn/submit?leader=auto`, {
      method: "POST",
      headers: {
        Authorization: `Bearer ${process.env.CLUTCHCALL_CREDENTIALS}`,
        "Content-Type": "application/octet-stream",
      },
      body: tx,
    });
    if ((await r.json()).ok) return;          // dedup makes the retry idempotent
  }
  throw new Error("tx did not land");
}

​
Subscribe to your private feed

A private feed (your own gossip/Geyser ingest) is published under sol/feed/<orgId>. Subscribe to its slots track with an org-scoped token. 
const orgNs = `sol/feed/${orgId}`;
client.subscribeFrame(orgNs, "slots", (_ts, _p, data) => {
  console.log("private slot", JSON.parse(new TextDecoder().decode(data)).slot);
});

​
Subscribe before the feed exists

The relay holds a subscribe for a namespace that hasn’t announced yet, so you can subscribe to a private feed before your ingest has published its first slot — frames start flowing the moment it does. No special call needed; just subscribe early.

​
React to relay reconnects

The client replays subscriptions automatically; use onState only for logging or to pause your own work while the link is down. 
const client = await MoqtClient.connect(
  "quic://feeds.clutchcall.dev",
  process.env.CLUTCHCALL_CREDENTIALS,
  (state, reason) => {
    if (state /* Reconnecting */) console.warn("feed relay flap:", reason);
  },
);

​
Tear down cleanly

Close a single track, or the whole client. 
const sub = client.subscribeFrame("sol/feed/mainnet", "slots", () => {});
sub.close();      // unsubscribe one track
client.close();   // tear down the session + all subscriptions