Build on ApeCover

import { ApeCover } from '@apecover/sdk';
import { Connection, Keypair } from '@solana/web3.js';

const ape = new ApeCover({
  apiKey: process.env.APECOVER_API_KEY!,   // dgn_….dgnsk_…, issued at /app
  pool: '3J31LrGG5Ko7iECH4o4QCdh7vXfShUHc2Npww2pCQPaH',                  // required: there is no "the" pool to default to
  connection: new Connection(process.env.RPC_URL!, 'confirmed'),
  signer: Keypair.fromSecretKey(secret),   // never transmitted
});

// Omitting `pool` throws here, at construction, rather than 404-ing on
// GET /pool/undefined one round trip later. A deployment may index more than
// one pool, and only you know which one you are insuring against.

const me = await ape.whoami();

if (!me.partner.earning) {
  // Approved is not the same as earning: an operator still has to run
  // register_partner before policy.partner has anything to point at.
  console.log('no revenue share yet:', me.partner.status);
}

const pool = await ape.pool();

console.log(pool.paused, pool.totalLiabilities, pool.expiryBacklog);
// Amounts are base units of pool.settlementMint. Scale by that, not by 1e9.

const quote = await ape.quote({
  tier: 'standard',
  tradeSize: 300_000_000n,        // lamports per covered trade
  tokenMint,                      // required: the entry gate is priced against it
  packSize: 10,                   // optional, defaults to a single trade
});

console.log(quote.eligible, quote.quote?.premium);

// marketCapMicroUsd is optional and is micro-USD, not lamports (1_000_000 = $1).
// Omit it and the deployment looks it up; if it cannot, the gate does not run and
// marketCap comes back null rather than silently passing.

// After your swap confirms, before you reply to the user.
const result = await ape.insureTrade({
  swapSignature,            // base58, exactly as your swap returned it
  tokenMint,
  tradeSize: fill.lamportsSpent,  // pass it: a policy bought without one is refused
  tier: 'standard',
});

if (result.status === 'insured') console.log('covered', result.trade);
else if (result.status === 'declined') console.log('no cover:', result.reason);
else console.log('sent, outcome pending', result.signature);

const { policy, signature } = await ape.buyPolicy('standard', 300_000_000n);
console.log('pack bought', policy.toBase58(), signature);

const chain = await ape.chain();
const vault = chain.vaultAddress();

const protocol = await ape.protocol();
const state = await protocol.poolState();

import { PlatformClient } from '@apecover/sdk';

const platform = new PlatformClient({ apiKey: process.env.APECOVER_API_KEY! });
const me = await platform.whoami();

const pool = await platform.pool('3J31LrGG5Ko7iECH4o4QCdh7vXfShUHc2Npww2pCQPaH');

const result = await platform.attest({
  owner, pool, policyIndex: 0n, tradeIndex: 3n, tokenMint, swapSignature,
});

if (result.status === 'refused') return result.reason;   // 200, not an error
// Deserialise, sign, send. Do not rebuild it — any change voids the attestor's signature.

import { findPool } from '@apecover/core';
import { PublicKey } from '@solana/web3.js';

const [pool] = findPool(new PublicKey(programId));

const [vault] = findVault(new PublicKey(programId), new PublicKey(pool));

const [policy] = findPolicy(
  new PublicKey(programId), new PublicKey(pool), owner.publicKey, 0n,
);

const [trade] = findTrade(new PublicKey(programId), policy, 3n);

const [exposure] = findWalletExposure(
  new PublicKey(programId), new PublicKey(pool), owner.publicKey,
);

import { findSwapCover } from '@apecover/core';
import { swapSignatureBytes } from '@apecover/common';

// swapSignatureBytes, not a bare base58 decode: it is the same decoder the program's seeds
// are derived from, and two implementations of "is this a signature" is how one swap ended
// up with two cover markers (DEG-155).
const [cover] = findSwapCover(
  new PublicKey(programId),
  new PublicKey(pool),
  swapSignatureBytes(swapSignature),
);

const [claim] = findClaim(new PublicKey(programId), trade);

import { fetchPool, quoteSingleTrade } from '@apecover/core';
import { quoteContext } from './quote';   // builds the context for one tier

const pool = await fetchPool(connection, programId);
if (pool === null) throw new Error('no pool on this cluster');

const rent = BigInt(await connection.getMinimumBalanceForRentExemption(0));
const ctx = quoteContext(pool, 1 /* Standard */, rent);

const { premium, payout } = quoteSingleTrade(ctx, 300_000_000n);

effectivePartnerFeeBps(ctx);                    // no partner → 0n
effectivePartnerFeeBps(ctx, { active: true });  // → ctx.partnerFeeBps

const result = checkEligibility(
  ctx,
  300_000_000n,      // this trade
  9_500_000_000n,    // market cap in micro-USD
  300_000_000n,      // what the policy already covers per trade
);

if (!result.eligible) console.log('would be refused:', result.reasons);

const pool = await fetchPool(connection, programId);
const used = utilizationBps(pool!);   // 4200 = 42%

import { Connection } from '@solana/web3.js';
import { fetchPool } from '@apecover/core';

const connection = new Connection(process.env.RPC_URL!, 'confirmed');
const pool = await fetchPool(connection, '${programId}');
if (pool === null) throw new Error('no pool on this cluster');

try {
  await ape.insureTrade(params);
} catch (error) {
  const declined = declineFor(error);
  if (declined === null) throw error;      // a real fault — do not swallow it
  console.log('refused:', declined.reason, declined.detail);
}

const variant = sourceVariant('Pyth');   // → the IDL variant name