Crypto — Cookbook - ClutchCall

This page has 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. Reuse the client for every track. The client reconnects automatically.

TypeScript
Python

import { MoqtClient } from "@clutchcall/sdk/moqt";

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

from clutchcall.moqt import MoqtClient

client = MoqtClient.connect("quic://feeds.clutchcall.dev", auth_token="…")

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 object 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 }. Set your compute-unit price from the live p50. Do not guess.

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

Send the signed tx to the BDN once. The BDN dedups the tx 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. Land on the current + next leader directly from this node.

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. There is 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). It is safe to send the same signed tx again across edges. The tx lands at most once per leader within the dedup TTL. Thus a retry loop does not 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");
}

The BDN publishes a private feed (your own gossip/Geyser ingest) 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);
});

The relay holds a subscribe for a namespace that is not announced yet. Thus you can subscribe to a private feed before your ingest publishes its first slot. Frames start to flow the moment the ingest publishes. You do not need a special call. 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

​Connect to the feed relay

​Subscribe to a feed track

​Stream recent blockhash

​Track the priority-fee market

​Submit a transaction with BDN fan-out

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

​Target a specific validator leader

​Submit from code over HTTP/3

​Deduplicate your own re-submits

​Subscribe to your private feed

​Subscribe before the feed exists

​React to relay reconnects

​Tear down cleanly