Launch with a companion

import { Keypair, Transaction, VersionedTransaction } from '@solana/web3.js';
import { NO_RULES, type LaunchPrepareRequest, type LaunchPrepareResponse, type Submission, type UploadResponse } from '@bordrless/shared';

const API = 'https://bordrless.app/api';
const post = async <T,>(path: string, body: unknown): Promise<T> => {
  const res = await fetch(`${API}/${path}`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body) });
  if (!res.ok) throw new Error(await res.text());   // a 400 says why, with a code: companion_rules, max_wallet…
  return (await res.json()) as T;
};

const mint = Keypair.generate();   // save it to disk now: see "Keep the mint key" below

// 1. The image and details, pinned to IPFS.
const form = new FormData();
form.append('image', new Blob([png], { type: 'image/png' }), 'logo.png');
for (const [k, v] of Object.entries({ creator: wallet.publicKey.toBase58(), mint: mint.publicKey.toBase58(), name: 'Back', symbol: 'BACK', description: 'Buys itself back.' })) form.append(k, v);
const { uploadId } = (await (await fetch(`${API}/upload`, { method: 'POST', body: form })).json()) as UploadResponse;

// 2. The launch, with a companion: half bought back and burned, half to holders (so holder rewards on).
const request: LaunchPrepareRequest & { mint: string } = {
  creator: wallet.publicKey.toBase58(),
  mint: mint.publicKey.toBase58(),
  uploadId,
  creatorFeeBps: 100,                                   // 0, 50, 100 or 200: what the companion runs on
  devBuyLamports: '500000000',                          // held by the companion, vesting to you
  rules: { ...NO_RULES, holderFeeBuyBps: 100, holderFeeSellBps: 100 },
  companion: { split: { buybackBps: 5_000, holdersBps: 5_000, beneficiaryBps: 0 }, vestDays: 30 },   // or { template: 'buybackAndReward' }
};
const prepared = await post<LaunchPrepareResponse>('launch/prepare', request);
// prepared.transactions: "Set up the companion", "Launch BACK", "Buy BACK", in stage order.

// 3. Sign each with the wallet, then the mint where extraSigners names it; send them and follow.
const transactions = prepared.transactions.map((p) => {
  const signers = p.extraSigners.includes('mint') ? [wallet, mint] : [wallet];
  const bytes = Buffer.from(p.transaction, 'base64');
  const tx = p.version === 'legacy' ? Transaction.from(bytes) : VersionedTransaction.deserialize(bytes);
  if (tx instanceof Transaction) tx.partialSign(...signers);
  else tx.sign(signers);
  return { transaction: Buffer.from(tx.serialize()).toString('base64'), stage: p.stage, label: p.label };
});
let submission = await post<Submission>('tx/submit', { transactions, intentId: prepared.intentId });
while (submission.state === 'pending') {
  await sleep(1_000);
  submission = (await (await fetch(`${API}/tx/submission/${submission.id}`)).json()) as Submission;
}
// 'confirmed': launched. Anything else: keep the mint key.

import { type CompanionRefundResponse, type CompanionStatus } from '@bordrless/shared';
import { companion } from '@bordrless/sdk';

// The setup landed, the launch didn't: its SOL goes back to the wallet that set it up.
const status = (await (await fetch(`${API}/companion/${mint.publicKey.toBase58()}`)).json()) as CompanionStatus;
if (status.state === 'set-up') {                        // status.refundable: the lamports it returns
  const { transaction } = await post<CompanionRefundResponse>('companion/refund/prepare', { wallet: wallet.publicKey.toBase58(), mint: mint.publicKey.toBase58() });
  // sign it with the wallet, then the mint, as above, and send it to tx/submit
}

// The same with the SDK: withdraw before the launch, signed by the mint. Anyone may send it; it pays the beneficiary.
const refund = companion.refund(wallet.publicKey, mint.publicKey, wallet.publicKey);

import { Keypair } from '@solana/web3.js';
import { NO_RULES } from '@bordrless/shared';
import {
  COMPANION_DEFAULTS, COMPANION_TEMPLATES, LAUNCH_CONFIG, buildV0Transaction, companion, companionCreatorAddress,
  companionReady, decodeLaunchConfig, fetchAccount, launch, launchKeys, launchRulesFromInput,
} from '@bordrless/sdk';

const mint = Keypair.generate();                                  // keep it until the launch confirms
const config = (await fetchAccount(connection, LAUNCH_CONFIG, decodeLaunchConfig))!;
const rules = launchRulesFromInput({ ...NO_RULES, holderFeeBuyBps: 100, holderFeeSellBps: 100 });

// 1. create: the companion and its split, fixed for good. The mint signs: nobody else can make it.
const setUp = companion.create(me.publicKey, me.publicKey, mint.publicKey, {   // payer, beneficiary, mint
  split: COMPANION_TEMPLATES.buybackAndReward,
  ...COMPANION_DEFAULTS,                                          // 0.5% bounty, ≤ 1 SOL a buyback, 60 s apart, 30-day vest
  fund: config.launchFeeLamports + 50_000_000n + 890_880n,        // the launch's fee and rent, the creator address's own rent
});

// 2. launch: create_launch with the companion's creator address as the creator, sent through the companion.
const args = { name: 'Back', symbol: 'BACK', uri: 'ipfs://…', creatorFeeBps: 100, virtualQuote: config.minVirtualQuote, rules };
const create = launch.createLaunch(companionCreatorAddress(mint.publicKey), mint.publicKey, config.treasury, config.quoteMint, config.lpFeeBps, args);
const launchIx = companion.launch(me.publicKey, mint.publicKey, create, args);

// It fits only as v0 with a table holding PROTOCOL_LOOKUP_TABLE in order: Bordrless keeps one on mainnet at
// 4vxVcYLdkqT1rMfGHjAu4kMa9XSEhUdQU5ThVfU5grGQ (or make your own with createProtocolLookupTable).
const table = (await connection.getAddressLookupTable(TABLE)).value!;
if (!companionReady(table)) throw new Error('the table lacks the companion addresses');
const tx = buildV0Transaction(me.publicKey, [launchIx], blockhash, [table]);
tx.sign([me, mint]);                                              // 1,071 bytes with kit rules

// 3. dev_buy (optional; its own transaction, within 10 minutes): the companion holds it, vesting to the beneficiary.
const keys = launchKeys(mint.publicKey, config.quoteMint, config.lpFeeBps, rules);
const firstBuy = companion.devBuy(me.publicKey, keys, 500_000_000n, minOut);

import type { TransactionInstruction } from '@solana/web3.js';
import { rewardsOn } from '@bordrless/shared';
import {
  BRIDGED_SOL_MINT, companion, companionAddress, companionVested, decodeCompanion, decodeHolding, decodeLaunch,
  fetchAccount, holdingAddress, launchAddress, launchKeysOf, launchRulesInputOf,
} from '@bordrless/sdk';

const c = (await fetchAccount(connection, companionAddress(mint), decodeCompanion))!;
const l = (await fetchAccount(connection, launchAddress(mint), decodeLaunch))!;
const keys = launchKeysOf(l);
const rewards = rewardsOn(launchRulesInputOf(l.rules));
const fees = (await fetchAccount(connection, holdingAddress(BRIDGED_SOL_MINT, launchAddress(mint)), decodeHolding))?.amount ?? 0n;
const now = Math.floor(Date.now() / 1000);

// What is due; each checks again on chain and pays its sender c.bountyBps of what it moves.
const steps: TransactionInstruction[] = [];
if (fees > 0n) steps.push(companion.claimFees(me.publicKey, mint));
if (c.pendingBuyback > 0n && now >= c.lastBuybackAt + c.buybackInterval) steps.push(companion.buyback(me.publicKey, keys, rewards));
if (c.pendingHolders > 0n) steps.push(companion.share(me.publicKey, mint));
if (c.pendingBeneficiary > 0n) steps.push(companion.withdraw(me.publicKey, mint, c.beneficiary));
if (companionVested(c, now) > c.devReleased) steps.push(companion.release(me.publicKey, keys, rewards, c.beneficiary));
// One step a transaction, in this order (a claim fills what the others spend), each with ~600,000 compute units.

import { companionAddress, companionVested, decodeCompanion } from '@bordrless/sdk';

const c = decodeCompanion((await connection.getAccountInfo(companionAddress(mint)))!.data);
c.split;                                          // { buybackBps, holdersBps, beneficiaryBps }
c.claimedTotal; c.burnedTotal; c.sharedTotal;     // lamports claimed, tokens burned, lamports shared
c.paidBeneficiaryTotal; c.bountiesTotal;
companionVested(c, now) - c.devReleased;          // what release would send now

// Or the API: GET /api/launches/:mint answers LaunchDetail.companion (CompanionSummary), figures as strings.

import { LOTTERY_DEFAULTS, NO_RULES, type GameEnterResponse, type GameStatus, type LaunchPrepareRequest } from '@bordrless/shared';
import { LOTTERY_HOOK_PROGRAM, companion, decodeGame, fetchAccount, fetchSeedSlot, gameAddress, lotteryHook, roundOf } from '@bordrless/sdk';

// 1. The launch, through the API: the same as a companion launch, with the lottery named. No token rules (the
//    coin runs the lottery hook), a creator fee the lottery is open at, no holders' part: the pot takes its place.
const request: LaunchPrepareRequest & { mint: string } = {
  creator: wallet.publicKey.toBase58(), mint: mint.publicKey.toBase58(), uploadId, creatorFeeBps: 100, rules: NO_RULES,
  companion: { split: { buybackBps: 3_000, holdersBps: 0, beneficiaryBps: 0 }, game: LOTTERY_DEFAULTS },
  // LOTTERY_DEFAULTS: 6-hour rounds, 70% of the fee to the pot, drawn from 0.5 SOL paying the whole pot, 8 claims of 10 min.
};
// prepared.transactions: "Set up the lottery" (create, prepare, create_game; the mint signs), "Launch", "Buy".
// 400 companion_rules says what the program would refuse; 503 lottery_off: no lottery config at that fee yet.

// 2. The token page's figures: GET /api/companion/:mint?wallet=<holder> -> CompanionStatus.game (GameStatus):
//    the pot, the round and its end, the tickets, the holder's tickets and odds, the draws (each with its ORAO request).
const status = (await (await fetch(`${API}/companion/${mint.publicKey.toBase58()}?wallet=${holder}`)).json()) as { game: GameStatus | null };

// 3. A holder's own entry (their tokens registered as this round's tickets; a trade this round does it too):
const { transactions } = await post<GameEnterResponse>('game/enter/prepare', { wallet: holder, mint: mint.publicKey.toBase58() });
// or with the builders: lotteryHook.enter(mint, holder), sent by anyone.

// 4. Crank a draw (anyone; docs/games.md "A keeper's loop"): once the round ends, draw from the newest slot hash,
//    sent at once without preflight (it must land within 3 slots: StaleSeed otherwise, send again), then reveal
//    ORAO's answer and claim the prize for the winner found among the holdings.
const g = (await fetchAccount(connection, gameAddress(mint.publicKey), decodeGame))!;
if (g.status === 'idle') {
  const at = await fetchSeedSlot(connection);
  const draw = companion.draw(me.publicKey, mint.publicKey, LOTTERY_HOOK_PROGRAM, roundOf(now, g.roundSecs) - 1, at, oraoTreasury, g.paidSeed);
}