Generated TypeScript Client

app/generated/<program>/
├── accounts/
│   ├── <AccountName>.ts       # decoder, fetch*, size, discriminator
│   └── index.ts
├── instructions/
│   ├── <instructionName>.ts   # builder → IInstruction
│   └── index.ts
├── pdas/
│   ├── find<AccountName>Pda.ts
│   └── index.ts
├── programs/
│   └── <programName>.ts       # programId constant
├── errors/
│   └── index.ts               # typed error enum
├── types/                     # struct + enum codecs used by accounts
└── index.ts

import { fetchMarket } from '@/app/generated/perp/accounts';

const market = await fetchMarket(rpc, marketPda);
console.log(market.data.totalLongBase);   // bigint

import { findMarketPda } from '@/app/generated/perp/pdas';

const [marketPda, bump] = await findMarketPda({ marketIndex: 0 });

import { getPlaceOrderInstruction } from '@/app/generated/perp/instructions';

const ix = getPlaceOrderInstruction({
  signer: walletSigner,
  userAccount: userAccountPda,
  market: marketPda,
  oracle: priceUpdateAccount,
  orderbook: orderbookPda,
  collateralVault: market.data.collateralVault,
  feeVault: market.data.feeVault,
  params: {
    price: 0n,
    baseAmount: 1_000_000_000n,
    direction: 0,               // 0 = Long, 1 = Short
    postOnly: false,
    isMarket: true,
    maxSlippageBps: 100,
  },
});

import { getOrderFilledDecoder } from '@/app/generated/perp/types';

function parseEvent(logBase64: string) {
  const bytes = Buffer.from(logBase64, 'base64');
  // Events are prefixed with an 8-byte discriminator
  return getOrderFilledDecoder().decode(bytes.slice(8));
}

import { sendTransaction } from '@/app/lib/send-transaction';

const sig = await sendTransaction({
  rpc, rpcSubscriptions, wallet,
  instructions: [...postIxs, placeOrderIx],
  commitment: 'confirmed',
});

cd frontend
npm run codama:all

npm run codama:perp
npm run codama:delta
npm run codama:split
npm run codama:amm
npm run codama:intent
npm run codama:kusd