covr.Docs

Makers: get started

Assess the integration

This page is for a desk deciding whether to integrate. It says what you build, what covr runs, the exact message flow, how you get access, what capital you post, and how long it takes.

Note

Status on 16 November 2026. You can register, connect, receive every live JitoSOL call RFQ and send signed bids today. Your bids are checked like real ones and then refused, because covr's markets list only covr's own maker (practice mode). Listing other desks needs a covr release; it has no date yet (to confirm with covr). Cash-secured puts are live for customers since 7 November 2026 but are quoted only by covr's own maker: desks cannot receive put RFQs yet.

The short answer

QuestionAnswer
ProductCovered calls on JitoSOL, paid in USDC. The customer locks JitoSOL and sells you the call; you pay the premium upfront. Exercise is physical and European-style: inside a window just after expiry, you pay the strike in USDC and receive the JitoSOL.
Your interfaceOne WebSocket command socket, one read-only WebSocket feed, one HTTP read. JSON-RPC 2.0. Four methods you send, two messages you receive.
What you signEIP-712 typed data with a secp256k1 key (an Ethereum-style key). One sealed bid per RFQ, one executable quote if you win.
On-chain workOne-time setup with your Solana authority, then exercise or let release happen at expiry. You never send the fill: the customer does.
CapitalUSDC in your on-chain vault: the premium at each fill, and the strike at each exercise. No margin, no collateral of your own for calls.
PricingEntirely yours. covr sends size, strike and expiry; you return a price.
SDK@covrfun/maker-sdk 0.1.1 (TypeScript, Node 24+), plus an example bot and an example expiry keeper. Any other language can speak the protocol directly.
EffortAbout 2 to 3 engineer-weeks to a production-grade desk on the TypeScript SDK, if you already price options. A dry run against live RFQs takes about a day once covr has issued your token. See Effort.

What you build

PieceWhat it doesSDK help
ListenKeep /maker and /rfqs/<JitoSOL alias> open with your bearer token. On each rfq event, read GET /api/rfqs/<id> for the market and the customer wallet.GatewayClient
PriceRead the market account from your RPC (cache it: markets do not change except paused), run your model, round the price down to one that pays a whole number of USDC atoms.decodeMarketV3, exactPriceAtOrBelow
SignSign a 17-field bid intent in the market's own EIP-712 domain. If you win, sign a 15-field quote that adds a nonce, a validity time and the customer wallet.buildBidIntent, signIntent, buildQuote, signQuote
RespondSend the bid within 3 s of the RFQ. If awarded, send the quote (or a decline) before awardUntil, on the same socket.sendBidIntent, sendQuote, sendAwardDecline
BookBefore you sign a quote, write its nonce and the cash it could cost to durable storage. No fill message exists: find fills on chain by the position address.derivePosition, decodePositionV3; the example bot's journal
SettleAt expiry, exercise the positions worth exercising inside the market's window, with the strike in your vault. Otherwise anyone can release them after the window.exerciseV3Instructions, releaseV3Instructions; the example keeper
Set up onceRegister your two keys on chain, open your USDC vault, set exposure and per-mint limits, deposit USDC.Register and fund

What covr runs

  • The customer app, the customer's RFQ, and the customer's fill transaction. covr prepares the fill; the customer signs and sends it.
  • The gateway: RFQ broadcast, the sealed auction, ranking, awards, and checks on every signature and term before a quote reaches a customer.
  • The market listing: covr creates and rolls its JitoSOL markets. Each RFQ names its market.
  • The program, which enforces every money rule again on chain: your limits, your nonce floor, exact amounts, the exercise window.
  • Fees. Each market's fee (at most 10%) comes out of the premium you pay, on chain. You pay nothing else to covr.

Message flow

StepTime from the RFQMessageSocketReply
10 srfq event: size, strike, expiry, aliases. No market or wallet./rfqs/<alias>none
20 to 3 sGET /api/rfqs/<id>: market, customer wallet, closesAt, hardDeadlineHTTPSJSON
3before 3 sbid_intent: your price, signed. One per RFQ./maker"BID_ACCEPTED"
43 saward to the best price only/makernone
5before awardUntil (6 s)quote (signed, with nonce) or award_decline/maker, same socket"OK" or "DECLINED"
6up to validUntilThe customer signs and sends fill_v3Solanayou read it on chain
7expiry to expiry + windowexercise_v3 (you), else release_v3 (anyone) after the windowSolana

If you will not bid, you may send rfq_note with a reason the customer sees. Ranking is by price, then arrival time. A silent winner holds the award to the 6 s deadline and the customer gets no quote, so always answer an award. Full detail: RFQ lifecycle.

Access and onboarding

StepWhoWhatTime
1YouCreate a quote key (secp256k1) and a Solana authority. Registration links them permanently.minutes
2YouCheck your signer against the package's golden vectors.under an hour
3YouRegister on chain with signRegistrationGrant and registerMakerV3. About 0.003 SOL of rent.minutes
4YouMessage covr on Telegram, @malviyaop, with your quote key address, authority address, a desk name and the asset (JitoSOL). Never a private key.
5covrChecks your Maker account on chain, issues a bearer token (prefix covr_mk_) and the gateway URL. The token works after covr's next gateway restart.elapsed time, depends on covr
6YouConnect with Authorization: Bearer <token>. You now receive live RFQs and practise bids.minutes
7covrList your desk on its markets so your bids can win. Not available yet.to confirm with covr

The token is bound at covr's side to your quote key, your Solana authority and your allowed assets. A leaked token cannot bid or quote for you: every bid must be signed by your registered quote key. covr's own maker authenticates through the same token registry.

Capital you post

WhatWhereWhen it moves
PremiumYour USDC vault (a program account you own)At each fill: the gross premium leaves your vault. The customer gets it minus the market fee.
StrikeThe same vaultAt each exercise_v3: atoms × strikeE8 / 10^(decimals + 2) USDC atoms to the customer. You receive the JitoSOL.
SOLYour authority walletAbout 0.012 SOL of rent once for setup, about 0.004 SOL of rent per exercise (two fresh customer token accounts), plus fees.
  • Most you can lose on a position: the premium you paid. You choose whether to exercise.
  • No escrow per position. The program does not set the strike aside. You decide how much to keep in the vault: fully funded, or topped up before expiry. A flash exercise can pay the strike from the JitoSOL itself, but needs your own swap route and builders.
  • Your limits. Exposure across markets, per-fill size, reserved collateral and strike per mint, and an optional lifetime premium budget. All on chain, all set by you.
  • Program limit. One JitoSOL order can be worth at most 50 SOL of stake-pool value. Larger fills fail.
  • Withdrawals are yours at any time, and are not checked against open strikes. Stop quoting first.

Effort

For a desk that already prices options and runs a trading stack. Estimates are engineer-days for one engineer who knows Solana basics.

WorkTypeScript, with the SDKAnother language
Read the docs, dry-run the example bot on live RFQs0.5 to 10.5 to 1
On-chain setup (register, vault, limits, deposit)0.5 to 10.5 to 1, run the SDK scripts once
Price adapter: RFQ to your model, exact-atom rounding1 to 21 to 2
Gateway client: sockets, JSON-RPC, heartbeat, reconnect0 (GatewayClient)2 to 3
EIP-712 signing with your KMS or HSM, low-s, golden vectors1 to 21 to 3
Market account decoding and the signing domain0 (decodeMarketV3)1 to 2
Durable nonce and cash journal, fill reconciliation from chain1 to 32 to 4
Expiry keeper: exercise in the window, strike funding1 to 2 (example keeper)1 to 2, keep the TypeScript keeper
Your books, hedging, limits and alerts2 to 52 to 5
Totalabout 7 to 16 daysabout 11 to 23 days

Difficulty: moderate. The protocol is small and the SDK covers the parts that are easy to get wrong. The real work is elsewhere:

  • 3 s to bid, including the snapshot read and a market read from your RPC. Cache decoded markets.
  • Exact amounts. The premium and the strike must each be a whole number of USDC atoms, or the fill fails. Use exactPriceAtOrBelow.
  • No fill message. You learn fills only from chain, so a durable journal of signed quotes is required.
  • Your own keeper. You must exercise inside each market's window (60 to 3,600 s), with the strike in your vault.
  • Two keys for life. The quote key and the authority are linked at registration and cannot be changed.

Not included above: time waiting for covr (token issue, then desk listing). Flash exercise adds about 3 to 5 days: you need your own swap route and instruction builders.

First quote in 10 steps

With @covrfun/maker-sdk. Steps 1 to 8 work today. Steps 9 and 10 run only once covr lists your desk; until then step 8 ends in the practice-mode refusal.

  1. Install. npm install @covrfun/maker-sdk ethers@6.17.0 @solana/kit@8.2.0 on Node 24 or later. See Quickstart.
  2. Keys. A quote key in your KMS or HSM and a Solana authority. See Custom signers.
  3. Prove your signer against the golden vectors in the package.
  4. Register. signRegistrationGrant, then registerMakerV3, wait for finalized. See Quickstart.
  5. Get a token from covr. See Quickstart.
  6. Fund. initializeVault, initializeExposureV3, mintPolicySettingsFor and initializeMintPolicyV1, bootstrapMintUsageV1, deposit. See Register and fund.
  7. Connect. GatewayClient.connect(url, token) and read client.events().
  8. Bid. On each rfq: getRfq(id), decodeMarketV3, your price through exactPriceAtOrBelow, then buildBidIntent, signIntent with quoteDomain(market), and sendBidIntent before closesAt.
  9. Quote. On award: journal the nonce and the cash it could cost, then buildQuote, signQuote and sendQuote before awardUntil. "OK" means the customer can now see your quote, not that it filled.
  10. Settle. Watch the position address from derivePosition at finalized. At expiry, exercise with exerciseV3Instructions or let it release. See Expiry keeper.

The example bot does steps 7 to 10 with a stub price. Replace referencePremiumE18() with your model.

ts
import {
  GatewayClient, decodeMarketV3, quoteDomain, atomsFromWire, exactPriceAtOrBelow,
  buildBidIntent, signIntent, defaultIntentValidUntil,
} from '@covrfun/maker-sdk';

const client = await GatewayClient.connect(GATEWAY_URL, GATEWAY_TOKEN);
for await (const ev of client.events()) {
  if (ev.type !== 'rfq') continue;
  const snap = await client.getRfq(ev.id);
  const market = await decodeMarketV3(snap.market, await readFinalized(snap.market)); // your RPC, cached
  const atoms = atomsFromWire(snap.request.quantity, market.collateralDecimals);
  const price = exactPriceAtOrBelow(yourModelPriceE18(snap.request, market), atoms, market.collateralDecimals);
  if (price === 0n) continue;
  const unsigned = buildBidIntent(snap, { maker: QUOTE_KEY_ADDRESS, price, validUntil: defaultIntentValidUntil(snap) });
  await client.sendBidIntent(await signIntent(signer, quoteDomain(market), unsigned));
}

readFinalized and yourModelPriceE18 are yours. Handle award events as in step 9.

Machine-readable specs

Generated from covr's source by a script, and checked against it so they cannot drift silently:

Each file names the covr source commit it was generated from. The prose pages remain the reference for behaviour the schemas cannot express: timing, ranking, award passing and practice mode.

Next