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.
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
| Question | Answer |
|---|---|
| Product | Covered 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 interface | One 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 sign | EIP-712 typed data with a secp256k1 key (an Ethereum-style key). One sealed bid per RFQ, one executable quote if you win. |
| On-chain work | One-time setup with your Solana authority, then exercise or let release happen at expiry. You never send the fill: the customer does. |
| Capital | USDC 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. |
| Pricing | Entirely 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. |
| Effort | About 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
| Piece | What it does | SDK help |
|---|---|---|
| Listen | Keep /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 |
| Price | Read 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 |
| Sign | Sign 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 |
| Respond | Send 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 |
| Book | Before 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 |
| Settle | At 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 once | Register 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
| Step | Time from the RFQ | Message | Socket | Reply |
|---|---|---|---|---|
| 1 | 0 s | rfq event: size, strike, expiry, aliases. No market or wallet. | /rfqs/<alias> | none |
| 2 | 0 to 3 s | GET /api/rfqs/<id>: market, customer wallet, closesAt, hardDeadline | HTTPS | JSON |
| 3 | before 3 s | bid_intent: your price, signed. One per RFQ. | /maker | "BID_ACCEPTED" |
| 4 | 3 s | award to the best price only | /maker | none |
| 5 | before awardUntil (6 s) | quote (signed, with nonce) or award_decline | /maker, same socket | "OK" or "DECLINED" |
| 6 | up to validUntil | The customer signs and sends fill_v3 | Solana | you read it on chain |
| 7 | expiry to expiry + window | exercise_v3 (you), else release_v3 (anyone) after the window | Solana |
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
| Step | Who | What | Time |
|---|---|---|---|
| 1 | You | Create a quote key (secp256k1) and a Solana authority. Registration links them permanently. | minutes |
| 2 | You | Check your signer against the package's golden vectors. | under an hour |
| 3 | You | Register on chain with signRegistrationGrant and registerMakerV3. About 0.003 SOL of rent. | minutes |
| 4 | You | Message covr on Telegram, @malviyaop, with your quote key address, authority address, a desk name and the asset (JitoSOL). Never a private key. | |
| 5 | covr | Checks 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 |
| 6 | You | Connect with Authorization: Bearer <token>. You now receive live RFQs and practise bids. | minutes |
| 7 | covr | List 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
| What | Where | When it moves |
|---|---|---|
| Premium | Your USDC vault (a program account you own) | At each fill: the gross premium leaves your vault. The customer gets it minus the market fee. |
| Strike | The same vault | At each exercise_v3: atoms × strikeE8 / 10^(decimals + 2) USDC atoms to the customer. You receive the JitoSOL. |
| SOL | Your authority wallet | About 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.
| Work | TypeScript, with the SDK | Another language |
|---|---|---|
| Read the docs, dry-run the example bot on live RFQs | 0.5 to 1 | 0.5 to 1 |
| On-chain setup (register, vault, limits, deposit) | 0.5 to 1 | 0.5 to 1, run the SDK scripts once |
| Price adapter: RFQ to your model, exact-atom rounding | 1 to 2 | 1 to 2 |
| Gateway client: sockets, JSON-RPC, heartbeat, reconnect | 0 (GatewayClient) | 2 to 3 |
| EIP-712 signing with your KMS or HSM, low-s, golden vectors | 1 to 2 | 1 to 3 |
| Market account decoding and the signing domain | 0 (decodeMarketV3) | 1 to 2 |
| Durable nonce and cash journal, fill reconciliation from chain | 1 to 3 | 2 to 4 |
| Expiry keeper: exercise in the window, strike funding | 1 to 2 (example keeper) | 1 to 2, keep the TypeScript keeper |
| Your books, hedging, limits and alerts | 2 to 5 | 2 to 5 |
| Total | about 7 to 16 days | about 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.
- Install.
npm install @covrfun/maker-sdk ethers@6.17.0 @solana/kit@8.2.0on Node 24 or later. See Quickstart. - Keys. A quote key in your KMS or HSM and a Solana authority. See Custom signers.
- Prove your signer against the golden vectors in the package.
- Register.
signRegistrationGrant, thenregisterMakerV3, wait for finalized. See Quickstart. - Get a token from covr. See Quickstart.
- Fund.
initializeVault,initializeExposureV3,mintPolicySettingsForandinitializeMintPolicyV1,bootstrapMintUsageV1,deposit. See Register and fund. - Connect.
GatewayClient.connect(url, token)and readclient.events(). - Bid. On each
rfq:getRfq(id),decodeMarketV3, your price throughexactPriceAtOrBelow, thenbuildBidIntent,signIntentwithquoteDomain(market), andsendBidIntentbeforeclosesAt. - Quote. On
award: journal the nonce and the cash it could cost, thenbuildQuote,signQuoteandsendQuotebeforeawardUntil."OK"means the customer can now see your quote, not that it filled. - Settle. Watch the position address from
derivePositionat finalized. At expiry, exercise withexerciseV3Instructionsor let it release. See Expiry keeper.
The example bot does steps 7 to 10 with a stub price. Replace referencePremiumE18() with your model.
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:
- AsyncAPI 3.0: the RFQ WebSocket protocol (
/maker,/rfqs/<alias>, every message, close codes and limits). - OpenAPI 3.1: the HTTP routes a desk uses (
GET /api/rfqs/{id}and the public status routes).
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
- Quickstart: register and watch live RFQs in about 30 minutes.
- How an RFQ works and Capital and settlement.
- Gateway reference if you implement the protocol yourself.