# Quickstart

Go from nothing to watching real RFQs arrive. You register your maker on chain, get a gateway token from covr, and run the example bot in dry-run mode. Dry run signs bids locally and sends nothing.

**Time:** about 30 minutes, plus covr's reply with your token.

> [!NOTE]
> **Status today (16 November 2026)**
>
> - Your desk can register on chain, connect to the gateway, receive live JitoSOL call RFQs and send signed bids.
> - It **cannot win customer orders yet**. Every bid runs in practice mode: fully checked, then refused with `Bid intent verified but not entered: this market does not list this maker yet`.
> - Why: covr's gateway lists only covr's own maker on each market, and covr's customer page accepts quotes only from covr's maker. Opening both to other desks needs a covr release, not a setting covr can switch on. Its date is to confirm with covr.
> - Cash-secured puts are live for customers since 7 November 2026, quoted only by covr's own maker. Desks cannot receive put RFQs yet. See [Cash-secured puts](https://docs.covr.markets/concepts/puts.md).
> - A new gateway token takes effect when covr restarts its gateway.
> - The program refuses any JitoSOL order worth more than 50 SOL of stake-pool value.

## What you need

| Item | Notes |
| --- | --- |
| Node.js 24 or later | [nodejs.org](https://nodejs.org) |
| A Solana mainnet RPC | Your own provider. You need its HTTPS URL and its WebSocket URL. It must serve finalized reads. |
| About 0.02 SOL | In your authority wallet. At current rent, registering costs about 0.003 SOL and the rest of setup about 0.01 SOL, plus fees. |
| Two keys | Below. |

## 1. Choose your keys

| Key | What it is | Signs |
| --- | --- | --- |
| **Quote key** | An Ethereum-style secp256k1 key, `0x…` address | Bids and quotes. Keep it in a KMS or HSM in production. |
| **Authority** | A Solana keypair | Setup, deposits, cancellation, exercise. Keep it well guarded. |

> [!WARNING]
> Registration links these two keys forever. Neither can be changed later. Use the keys you will run in production.

## 2. Install

Start in a new, empty folder.

```sh
mkdir covr-maker && cd covr-maker
npm init -y && npm pkg set type=module
npm install @covrfun/maker-sdk ethers@6.17.0 @solana/kit@8.2.0 @solana-program/token@0.16.1
npm install -D tsx@4.20.6
```

> [!NOTE]
> Pin `ethers` and `@solana/kit` to the versions the SDK depends on, so your code and the SDK share one copy.

## 3. Check your signer

Before your keys sign anything, prove your signing stack matches covr's. The package ships signed test vectors made with a public throwaway key. Digests must match exactly, and each signature must recover to the vector key. [Custom signers](https://docs.covr.markets/guides/custom-signer.md) has a script that checks both.

## 4. Register your maker

Registration is one transaction. Your quote key signs a grant and your authority sends it. You need three small files.

`keys.ts` loads your two keys:

```ts
import { readFile } from 'node:fs/promises';
import { Wallet } from 'ethers';
import { createKeyPairSignerFromBytes } from '@solana/kit';

// Your Solana authority: a keypair JSON file in the solana-keygen format.
export const authority = await createKeyPairSignerFromBytes(
  Uint8Array.from(JSON.parse(await readFile(process.env.AUTHORITY_KEYPAIR!, 'utf8'))),
);

// Your quote key. A Wallet keeps this short. In production, use a KMS adapter (see Custom signers).
export const quoteSigner = new Wallet(process.env.MAKER_QUOTE_KEY!);
```

`send.ts` signs instructions with your authority and waits for **finalized**:

```ts
// send.ts: one helper the guides reuse. Your authority pays fees and signs.
import {
  appendTransactionMessageInstructions, createSolanaRpc, createSolanaRpcSubscriptions,
  createTransactionMessage, getSignatureFromTransaction, pipe, sendAndConfirmTransactionFactory,
  setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash,
  signTransactionMessageWithSigners, assertIsTransactionWithBlockhashLifetime,
  type Instruction, type KeyPairSigner,
} from '@solana/kit';

const rpc = createSolanaRpc(process.env.RPC_URL!);
const rpcSubscriptions = createSolanaRpcSubscriptions(process.env.RPC_WS_URL!);
const sendAndConfirm = sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions });

export async function send(authority: KeyPairSigner, ...instructions: Instruction[]) {
  const { value: blockhash } = await rpc.getLatestBlockhash({ commitment: 'finalized' }).send();
  const message = pipe(
    createTransactionMessage({ version: 0 }),
    m => setTransactionMessageFeePayerSigner(authority, m),
    m => setTransactionMessageLifetimeUsingBlockhash(blockhash, m),
    m => appendTransactionMessageInstructions(instructions, m),
  );
  const tx = await signTransactionMessageWithSigners(message);
  assertIsTransactionWithBlockhashLifetime(tx);
  await sendAndConfirm(tx, { commitment: 'finalized' });
  return getSignatureFromTransaction(tx);
}
```

`register.ts` registers your maker:

```ts
import { signRegistrationGrant, registerMakerV3 } from '@covrfun/maker-sdk';
import { authority, quoteSigner } from './keys.ts';
import { send } from './send.ts';

const makerEthAddress = quoteSigner.address;

// The quote key grants your authority the right to register it. Checked locally before sending.
const grant = await signRegistrationGrant(quoteSigner, authority.address);
const { maker, instruction } = await registerMakerV3({
  authority: authority.address, makerEthAddress, signature: grant.signature,
});
console.log('registered', { maker, makerEthAddress, authority: authority.address }, await send(authority, instruction));
```

Run it:

```sh
AUTHORITY_KEYPAIR=./authority.json MAKER_QUOTE_KEY=0x<quote private key> \
RPC_URL=https://<your rpc> RPC_WS_URL=wss://<your rpc> \
npx tsx register.ts
```

## 5. Get your gateway token

Register your maker first (step 4). Then ask for access. Message us on Telegram: [@malviyaop](https://t.me/malviyaop). Send:

| What | Format | Why |
| --- | --- | --- |
| Your quote key address | `0x` and 40 hex digits | Your token acts only as this key. |
| Your Solana authority address | base58 | It must match the authority in your on-chain Maker account. |
| A desk name | 1 to 64 characters: letters, digits, spaces, `.`, `_`, `-`. Start with a letter or digit. | covr's label for your token in its own logs. Not secret. |
| The asset | JitoSOL | The only asset desks can quote. |

Never send a private key.

covr checks your Maker account on chain and sends you the gateway URL and a bearer token. Keep the token secret. covr's gateway loads tokens only when it starts, so your token works after covr's next gateway restart. Until then, connecting fails with `4401`.

## 6. Dry run the example bot

Copy the bot out of the package and run it. With no `MAKER_QUOTE_KEY` it signs with a throwaway key and only logs.

```sh
cp -r node_modules/@covrfun/maker-sdk/examples/maker ./maker
GATEWAY_WS_URL=wss://<provided by covr> \
GATEWAY_TOKEN=<your token> \
RPC_URL=https://<your rpc> \
SPREAD_BPS=500 \
npx tsx maker/index.ts
```

For each JitoSOL RFQ the bot reads the RFQ and its market, prices it with a placeholder, signs a bid and logs it:

```text
DRY_RUN would send bid_intent {"auctionId":"…","maker":"0x…","price":"…", …}
```

Note one `market` address from these lines. You need it for the mint policy in setup.

If the socket closes straight away, check the close code:

| Code | Meaning | Fix |
| --- | --- | --- |
| `4401` | Missing or unknown token | Check `GATEWAY_TOKEN`. |
| `4403` | Your token does not allow this asset | Message us on Telegram: [@malviyaop](https://t.me/malviyaop), and ask for JitoSOL on your token. |
| `4429` | Too many connections or frames | Stop other bots using this desk, then retry with backoff. |

## Next steps

1. [Register and fund](https://docs.covr.markets/guides/register-and-fund.md): finish setup steps 2 to 8.
2. Replace the pricing stub: `referencePremiumE18()` in `maker/index.ts`.
3. [Run the example bot](https://docs.covr.markets/guides/run-the-example-bot.md) live, in practice mode.
4. Work through the [Go-live checklist](https://docs.covr.markets/guides/go-live-checklist.md).

---

Source: https://docs.covr.markets/quickstart · Part of covr Docs, https://docs.covr.markets/llms.txt
