TypeScript SDK

import anchor from '@coral-xyz/anchor';
import { Connection, Keypair } from '@solana/web3.js';
import { ShearClient } from '@shear/sdk';

const connection = new Connection(process.env.SOLANA_RPC_URL!, 'finalized');
const owner = Keypair.fromSecretKey(secretKey);
const client = new ShearClient(connection, new anchor.Wallet(owner));
const vault = client.vault();

import { Transaction, sendAndConfirmTransaction, type TransactionInstruction } from '@solana/web3.js';
import { getAssociatedTokenAddressSync } from '@solana/spl-token';
import { TSLA_X_MINT, TOKEN_2022_PROGRAM_ID, depositShares } from '@shear/sdk';

const me = owner.publicKey;
const amount = 250_000_000n; // 2.5 TSLAx
const source = getAssociatedTokenAddressSync(TSLA_X_MINT, me, false, TOKEN_2022_PROGRAM_ID);
const ixs: TransactionInstruction[] = [];

if (!(await connection.getAccountInfo(client.position(vault, me)))) {
  ixs.push(await client.instruction('createPosition', [], {
    ...client.vaultPdas(vault),
    ...client.positionPdas(vault, me),
  }));
}

const { data: v } = await client.fetchVault(vault);
if (v.active === false) {
  const pdas = client.vaultPdas(vault);
  const custody = BigInt((await connection.getTokenAccountBalance(pdas.custody)).value.amount);
  const supply = BigInt((await connection.getTokenSupply(pdas.shareMint)).value.amount);
  const minShares = depositShares(amount, custody, supply); // fewer on chain fails with Slippage (6022)
  ixs.push(await client.instruction('fundReady', [amount, minShares], {
    ...pdas,
    ...client.positionPdas(vault, me),
    source,
  }));
} else {
  const round = client.round(vault, BigInt(v.roundIndex as string));
  const minShares = 0n; // checked against the settlement snapshot; below it the deposit is refunded
  ixs.push(await client.instruction('queueDeposit', [amount, minShares], {
    ...client.vaultPdas(vault),
    ...client.roundPdas(round),
    ...client.positionPdas(vault, me, round),
    source,
  }));
}

await sendAndConfirmTransaction(connection, new Transaction().add(...ixs), [owner]);

// Vault inactive: burn shares, receive TSLAx now
await client.instruction('redeemReady', [shares, minAssets], {
  ...client.vaultPdas(vault),
  ...client.positionPdas(vault, me),
  destination: source,
});

// Round running: queue on the ticket (the context also takes deposits and source)
await client.instruction('requestWithdrawal', [shares], {
  ...client.vaultPdas(vault),
  ...client.roundPdas(round),
  ...client.positionPdas(vault, me, round),
  source,
});

import { getAssociatedTokenAddressSync } from '@solana/spl-token';
import { USDC_MINT, mulDivCeil } from '@shear/sdk';

const { data: v } = await client.fetchVault(vault);
const round = client.round(vault, BigInt(v.roundIndex as string));
const usdc = getAssociatedTokenAddressSync(USDC_MINT, me);

const quantity = 1_500_000_000n;      // 15 calls
const limitPremiumMicro = 4_250_000n; // 4.25 USDC per call
const escrow = mulDivCeil(quantity, limitPremiumMicro, 100_000_000n); // 63_750_000n = 63.75 USDC

const bid = await client.instruction('placeBid', [quantity, limitPremiumMicro], {
  ...client.vaultPdas(vault),
  ...client.roundPdas(round),
  ...client.positionPdas(vault, me, round),
  source: usdc,
});

import { getAssociatedTokenAddressSync } from '@solana/spl-token';

const config = await client.fetchAccount(client.stakeConfig(vault), 'stakeConfig');
const mint = new PublicKey(config.data.mint as string);
const shear = getAssociatedTokenAddressSync(mint, me);
const stake = client.stakePdas(vault, me);

const lock = await client.instruction('stakeBidder', [], { ...client.vaultPdas(vault), ...stake, mint, source: shear });
const ask = await client.instruction('requestUnstake', [], { vault, ...stake });
// Seven days later, with every staked bid claimed:
const back = await client.instruction('withdrawStake', [], { ...client.vaultPdas(vault), ...stake, destination: shear });

import { createAssociatedTokenAccountIdempotentInstruction, getAssociatedTokenAddressSync } from '@solana/spl-token';
import { TSLA_X_MINT, TOKEN_2022_PROGRAM_ID, USDC_MINT } from '@shear/sdk';

const { optionMint } = client.roundPdas(round);
const options = getAssociatedTokenAddressSync(optionMint, me);
const usdc = getAssociatedTokenAddressSync(USDC_MINT, me);
const tslax = getAssociatedTokenAddressSync(TSLA_X_MINT, me, false, TOKEN_2022_PROGRAM_ID);
const accounts = {
  ...client.vaultPdas(vault),
  ...client.roundPdas(round),
  ...client.positionPdas(vault, me, round),
};

// Bidder: refund and calls, once the round has left Auction
const claimBid = [
  createAssociatedTokenAccountIdempotentInstruction(me, options, me, optionMint),
  await client.instruction('claimBid', [], { ...accounts, refund: usdc, options }),
];

// Share owner: all credited premium
const claimPremium = await client.instruction('claimPremium', [], { ...accounts, destination: usdc });

// Call holder: burn calls for TSLAx once the round is Settled
const calls = BigInt((await connection.getTokenAccountBalance(options)).value.amount);
const claimOption = await client.instruction('claimOption', [calls], { ...accounts, options, destination: tslax });

const { data: v } = await client.fetchVault(vault);
const index = BigInt(v.roundIndex as string); // 0n before the first round

if (index > 0n) {
  const { data: r } = await client.fetchRound(client.round(vault, index));
  const phase = Object.keys(r.phase as object)[0];   // 'Auction' | 'Active' | 'Observed' | 'Settled' | 'Closed' | 'Disputed'
  const strike = BigInt(r.strike as string);         // micro-USD per whole TSLAx
  const auctionEnd = Number(r.auctionEnd as string); // Unix seconds
}

const { data: p } = await client.fetchAccount(client.position(vault, me), 'position');
const claimable = // micro-USDC
  BigInt(p.premiumCredit as string) +
  (BigInt(p.shares as string) * (BigInt(v.premiumIndex as string) - BigInt(p.premiumIndex as string)) +
    BigInt(p.premiumFraction as string)) / 10n ** 18n;

import { SHEAR_PROGRAM_ID, decodeEvent } from '@shear/sdk';

const tx = await connection.getTransaction(signature, { commitment: 'finalized', maxSupportedTransactionVersion: 0 });
const stack: string[] = [];
if (tx?.meta && tx.meta.err === null) {
  for (const line of tx.meta.logMessages ?? []) {
    const invoke = /^Program (\S+) invoke \[\d+\]$/.exec(line);
    if (invoke) { stack.push(invoke[1]!); continue; }
    if (/^Program \S+ (success|failed:.*)$/.test(line)) { stack.pop(); continue; }
    if (stack.at(-1) === SHEAR_PROGRAM_ID.toBase58() && line.startsWith('Program data: ')) {
      const event = decodeEvent(line.slice('Program data: '.length));
      if (event) console.log(event.name, event.data); // e.g. BidPlaced { round, owner, quantity, limit }
    }
  }
}

import { clearAuction, coveredPayout, MULTIPLIER_SCALE } from '@shear/sdk';

const result = clearAuction(12_050_000_000n, 1_000_000n, [
  { quantity: 8_000_000_000n, limitPremium: 4_250_000n, owner: bidderA.toBytes() },
  { quantity: 6_000_000_000n, limitPremium: 3_900_000n, owner: bidderB.toBytes() },
]);
// { clearingPremium: 3_900_000n, sold: 12_050_000_000n, allocations: [8_000_000_000n, 4_050_000_000n] }

// 10 calls, strike 262.629629 USD, close mark 280 USD, multiplier 1.0
coveredPayout(1_000_000_000n, 280_000_000n, MULTIPLIER_SCALE, 262_629_629n);
// 62_037_039n TSLAx atoms, 0.62037039 TSLAx