@exponent-labs/exponent-sdk 0.1.7 → 0.9.0

package/src/client/clmm/accounts/vault.ts

@@ -0,0 +1,234 @@
+import { ClaimLimits, claimLimitsCodec } from "../types/claimLimits";
+import { Connection, PublicKey } from "@solana/web3.js";
+import { CpiAccounts, cpiAccountsCodec } from "../types/cpiAccounts";
+import { EmissionInfo, emissionInfoCodec } from "../types/emissionInfo";
+import { Number, numberCodec } from "../types/number";
+import {
+  fixCodecSize,
+  getArrayCodec,
+  getBytesCodec,
+  getStructCodec,
+  getU16Codec,
+  getU32Codec,
+  getU64Codec,
+  getU8Codec,
+  transformCodec,
+} from "@solana/codecs";
+
+export interface VaultAccountData {
+  syProgram: PublicKey;
+  mintSy: PublicKey;
+  mintYt: PublicKey;
+  mintPt: PublicKey;
+  escrowYt: PublicKey;
+  escrowSy: PublicKey;
+  yieldPosition: PublicKey;
+  addressLookupTable: PublicKey;
+  startTs: number;
+  duration: number;
+  signerSeed: PublicKey;
+  authority: PublicKey;
+  signerBump: Uint8Array;
+  lastSeenSyExchangeRate: Number;
+  allTimeHighSyExchangeRate: Number;
+  finalSyExchangeRate: Number;
+  totalSyInEscrow: bigint;
+  syForPt: bigint;
+  ptSupply: bigint;
+  treasurySy: bigint;
+  uncollectedSy: bigint;
+  treasurySyTokenAccount: PublicKey;
+  interestBpsFee: number;
+  minOpSizeStrip: bigint;
+  minOpSizeMerge: bigint;
+  status: number;
+  emissions: Array<EmissionInfo>;
+  cpiAccounts: CpiAccounts;
+  claimLimits: ClaimLimits;
+  maxPySupply: bigint;
+}
+
+export interface VaultAccount {
+  address: PublicKey;
+  data: VaultAccountData;
+}
+
+const VaultAccountDataCodec = getStructCodec([
+  ["discriminator", fixCodecSize(getBytesCodec(), 8)],
+  [
+    "syProgram",
+    transformCodec(
+      fixCodecSize(getBytesCodec(), 32),
+      (value: PublicKey) => value.toBytes(),
+      (value) => new PublicKey(value),
+    ),
+  ],
+  [
+    "mintSy",
+    transformCodec(
+      fixCodecSize(getBytesCodec(), 32),
+      (value: PublicKey) => value.toBytes(),
+      (value) => new PublicKey(value),
+    ),
+  ],
+  [
+    "mintYt",
+    transformCodec(
+      fixCodecSize(getBytesCodec(), 32),
+      (value: PublicKey) => value.toBytes(),
+      (value) => new PublicKey(value),
+    ),
+  ],
+  [
+    "mintPt",
+    transformCodec(
+      fixCodecSize(getBytesCodec(), 32),
+      (value: PublicKey) => value.toBytes(),
+      (value) => new PublicKey(value),
+    ),
+  ],
+  [
+    "escrowYt",
+    transformCodec(
+      fixCodecSize(getBytesCodec(), 32),
+      (value: PublicKey) => value.toBytes(),
+      (value) => new PublicKey(value),
+    ),
+  ],
+  [
+    "escrowSy",
+    transformCodec(
+      fixCodecSize(getBytesCodec(), 32),
+      (value: PublicKey) => value.toBytes(),
+      (value) => new PublicKey(value),
+    ),
+  ],
+  [
+    "yieldPosition",
+    transformCodec(
+      fixCodecSize(getBytesCodec(), 32),
+      (value: PublicKey) => value.toBytes(),
+      (value) => new PublicKey(value),
+    ),
+  ],
+  [
+    "addressLookupTable",
+    transformCodec(
+      fixCodecSize(getBytesCodec(), 32),
+      (value: PublicKey) => value.toBytes(),
+      (value) => new PublicKey(value),
+    ),
+  ],
+  ["startTs", getU32Codec()],
+  ["duration", getU32Codec()],
+  [
+    "signerSeed",
+    transformCodec(
+      fixCodecSize(getBytesCodec(), 32),
+      (value: PublicKey) => value.toBytes(),
+      (value) => new PublicKey(value),
+    ),
+  ],
+  [
+    "authority",
+    transformCodec(
+      fixCodecSize(getBytesCodec(), 32),
+      (value: PublicKey) => value.toBytes(),
+      (value) => new PublicKey(value),
+    ),
+  ],
+  ["signerBump", fixCodecSize(getBytesCodec(), 1)],
+  ["lastSeenSyExchangeRate", numberCodec],
+  ["allTimeHighSyExchangeRate", numberCodec],
+  ["finalSyExchangeRate", numberCodec],
+  ["totalSyInEscrow", getU64Codec()],
+  ["syForPt", getU64Codec()],
+  ["ptSupply", getU64Codec()],
+  ["treasurySy", getU64Codec()],
+  ["uncollectedSy", getU64Codec()],
+  [
+    "treasurySyTokenAccount",
+    transformCodec(
+      fixCodecSize(getBytesCodec(), 32),
+      (value: PublicKey) => value.toBytes(),
+      (value) => new PublicKey(value),
+    ),
+  ],
+  ["interestBpsFee", getU16Codec()],
+  ["minOpSizeStrip", getU64Codec()],
+  ["minOpSizeMerge", getU64Codec()],
+  ["status", getU8Codec()],
+  ["emissions", getArrayCodec(emissionInfoCodec)],
+  ["cpiAccounts", cpiAccountsCodec],
+  ["claimLimits", claimLimitsCodec],
+  ["maxPySupply", getU64Codec()],
+]);
+
+export function deserializeVaultAccount(data: Uint8Array): VaultAccountData {
+  const deserialized = VaultAccountDataCodec.decode(data);
+  const { discriminator: _, ...accountData } = deserialized;
+  return accountData as VaultAccountData;
+}
+
+export async function fetchVaultAccount(
+  connection: Connection,
+  address: PublicKey,
+): Promise<VaultAccount> {
+  const accountInfo = await connection.getAccountInfo(address);
+  if (!accountInfo) {
+    throw new Error(
+      "Vault account not found at address: " + address.toBase58(),
+    );
+  }
+  return {
+    address,
+    data: deserializeVaultAccount(accountInfo.data),
+  };
+}
+
+export async function fetchAllMaybeVaultAccounts(
+  connection: Connection,
+  addresses: PublicKey[],
+): Promise<(VaultAccount | null)[]> {
+  const accountInfos = await connection.getMultipleAccountsInfo(addresses);
+  return accountInfos.map((accountInfo, index) => {
+    if (!accountInfo) {
+      return null;
+    }
+    return {
+      address: addresses[index],
+      data: deserializeVaultAccount(accountInfo.data),
+    };
+  });
+}
+
+export async function fetchAllVaultAccounts(
+  connection: Connection,
+  addresses: PublicKey[],
+): Promise<VaultAccount[]> {
+  const maybeAccounts = await fetchAllMaybeVaultAccounts(connection, addresses);
+  const missingAddresses = maybeAccounts
+    .flatMap((account, i) => (!account ? [addresses[i].toBase58()] : []))
+    .join(", ");
+  if (missingAddresses) {
+    throw new Error(
+      "Vault account(s) not found at address(es): " + missingAddresses,
+    );
+  }
+  return maybeAccounts.filter((a): a is VaultAccount => a !== null);
+}
+
+export async function fetchProgramAccountsVault(
+  connection: Connection,
+  programId: PublicKey,
+  options?: { commitment?: "processed" | "confirmed" | "finalized" },
+): Promise<VaultAccount[]> {
+  const accounts = await connection.getProgramAccounts(programId, {
+    commitment: options?.commitment,
+    filters: [{ memcmp: { offset: 0, bytes: "cJJWPqNMczr" } }],
+  });
+  return accounts.map(({ pubkey, account }) => ({
+    address: pubkey,
+    data: deserializeVaultAccount(account.data),
+  }));
+}

package/src/client/clmm/eventRegistry.ts

@@ -0,0 +1,92 @@
+// Custom-generated file - DO NOT EDIT
+// Generated by scripts/generate-event-registry.ts (not a Codama output)
+
+import { Codec } from '@solana/codecs';
+
+import { AddFarmEvent, addFarmEventCodec } from './types/addFarmEvent';
+import { BuyPtEvent, buyPtEventCodec } from './types/buyPtEvent';
+import { BuyYtEvent, buyYtEventCodec } from './types/buyYtEvent';
+import { ClaimFarmEmissionsEvent, claimFarmEmissionsEventCodec } from './types/claimFarmEmissionsEvent';
+import { CloseMarketEvent, closeMarketEventCodec } from './types/closeMarketEvent';
+import { DepositLiquidityEvent, depositLiquidityEventCodec } from './types/depositLiquidityEvent';
+import { DepositLiquidityReturnData, depositLiquidityReturnDataCodec } from './types/depositLiquidityReturnData';
+import { MarketAccrueEmissionEvent, marketAccrueEmissionEventCodec } from './types/marketAccrueEmissionEvent';
+import { MarketCollectEmissionEvent, marketCollectEmissionEventCodec } from './types/marketCollectEmissionEvent';
+import { MarketThreeInitEvent, marketThreeInitEventCodec } from './types/marketThreeInitEvent';
+import { MergeEvent, mergeEventCodec } from './types/mergeEvent';
+import { ModifyFarmEvent, modifyFarmEventCodec } from './types/modifyFarmEvent';
+import { SellPtEvent, sellPtEventCodec } from './types/sellPtEvent';
+import { SellYtEvent, sellYtEventCodec } from './types/sellYtEvent';
+import { StripEvent, stripEventCodec } from './types/stripEvent';
+import { TradePtEvent, tradePtEventCodec } from './types/tradePtEvent';
+import { WithdrawLiquidityEvent, withdrawLiquidityEventCodec } from './types/withdrawLiquidityEvent';
+import { WithdrawLiquidityReturnData, withdrawLiquidityReturnDataCodec } from './types/withdrawLiquidityReturnData';
+import { WrapperBuyYtEvent, wrapperBuyYtEventCodec } from './types/wrapperBuyYtEvent';
+import { WrapperProvideLiquidityBaseEvent, wrapperProvideLiquidityBaseEventCodec } from './types/wrapperProvideLiquidityBaseEvent';
+import { WrapperProvideLiquidityClassicEvent, wrapperProvideLiquidityClassicEventCodec } from './types/wrapperProvideLiquidityClassicEvent';
+import { WrapperProvideLiquidityEvent, wrapperProvideLiquidityEventCodec } from './types/wrapperProvideLiquidityEvent';
+import { WrapperSellYtEvent, wrapperSellYtEventCodec } from './types/wrapperSellYtEvent';
+import { WrapperWithdrawLiquidityClassicEvent, wrapperWithdrawLiquidityClassicEventCodec } from './types/wrapperWithdrawLiquidityClassicEvent';
+import { WrapperWithdrawLiquidityEvent, wrapperWithdrawLiquidityEventCodec } from './types/wrapperWithdrawLiquidityEvent';
+
+export type EventName = 'addFarmEvent' | 'buyPtEvent' | 'buyYtEvent' | 'claimFarmEmissionsEvent' | 'closeMarketEvent' | 'depositLiquidityEvent' | 'depositLiquidityReturnData' | 'marketAccrueEmissionEvent' | 'marketCollectEmissionEvent' | 'marketThreeInitEvent' | 'mergeEvent' | 'modifyFarmEvent' | 'sellPtEvent' | 'sellYtEvent' | 'stripEvent' | 'tradePtEvent' | 'withdrawLiquidityEvent' | 'withdrawLiquidityReturnData' | 'wrapperBuyYtEvent' | 'wrapperProvideLiquidityBaseEvent' | 'wrapperProvideLiquidityClassicEvent' | 'wrapperProvideLiquidityEvent' | 'wrapperSellYtEvent' | 'wrapperWithdrawLiquidityClassicEvent' | 'wrapperWithdrawLiquidityEvent';
+export type EventData = AddFarmEvent | BuyPtEvent | BuyYtEvent | ClaimFarmEmissionsEvent | CloseMarketEvent | DepositLiquidityEvent | DepositLiquidityReturnData | MarketAccrueEmissionEvent | MarketCollectEmissionEvent | MarketThreeInitEvent | MergeEvent | ModifyFarmEvent | SellPtEvent | SellYtEvent | StripEvent | TradePtEvent | WithdrawLiquidityEvent | WithdrawLiquidityReturnData | WrapperBuyYtEvent | WrapperProvideLiquidityBaseEvent | WrapperProvideLiquidityClassicEvent | WrapperProvideLiquidityEvent | WrapperSellYtEvent | WrapperWithdrawLiquidityClassicEvent | WrapperWithdrawLiquidityEvent;
+
+export interface EventMap {
+  addFarmEvent: AddFarmEvent;
+  buyPtEvent: BuyPtEvent;
+  buyYtEvent: BuyYtEvent;
+  claimFarmEmissionsEvent: ClaimFarmEmissionsEvent;
+  closeMarketEvent: CloseMarketEvent;
+  depositLiquidityEvent: DepositLiquidityEvent;
+  depositLiquidityReturnData: DepositLiquidityReturnData;
+  marketAccrueEmissionEvent: MarketAccrueEmissionEvent;
+  marketCollectEmissionEvent: MarketCollectEmissionEvent;
+  marketThreeInitEvent: MarketThreeInitEvent;
+  mergeEvent: MergeEvent;
+  modifyFarmEvent: ModifyFarmEvent;
+  sellPtEvent: SellPtEvent;
+  sellYtEvent: SellYtEvent;
+  stripEvent: StripEvent;
+  tradePtEvent: TradePtEvent;
+  withdrawLiquidityEvent: WithdrawLiquidityEvent;
+  withdrawLiquidityReturnData: WithdrawLiquidityReturnData;
+  wrapperBuyYtEvent: WrapperBuyYtEvent;
+  wrapperProvideLiquidityBaseEvent: WrapperProvideLiquidityBaseEvent;
+  wrapperProvideLiquidityClassicEvent: WrapperProvideLiquidityClassicEvent;
+  wrapperProvideLiquidityEvent: WrapperProvideLiquidityEvent;
+  wrapperSellYtEvent: WrapperSellYtEvent;
+  wrapperWithdrawLiquidityClassicEvent: WrapperWithdrawLiquidityClassicEvent;
+  wrapperWithdrawLiquidityEvent: WrapperWithdrawLiquidityEvent;
+}
+
+export const EVENT_CODEC_REGISTRY: Record<string, {
+  name: EventName;
+  codec: Codec<any>;
+}> = {
+  '8045e48cd301ecd1': { name: 'addFarmEvent', codec: addFarmEventCodec },
+  '3e84322bdbeadda7': { name: 'buyPtEvent', codec: buyPtEventCodec },
+  'acb538b7db188240': { name: 'buyYtEvent', codec: buyYtEventCodec },
+  'b80a9f9090c2a65c': { name: 'claimFarmEmissionsEvent', codec: claimFarmEmissionsEventCodec },
+  'b981f415277d1c36': { name: 'closeMarketEvent', codec: closeMarketEventCodec },
+  'a95443aede8a107b': { name: 'depositLiquidityEvent', codec: depositLiquidityEventCodec },
+  'fbdeb7102b2885c1': { name: 'depositLiquidityReturnData', codec: depositLiquidityReturnDataCodec },
+  '3e5a51b3696e6c31': { name: 'marketAccrueEmissionEvent', codec: marketAccrueEmissionEventCodec },
+  '7d810f8be8f45243': { name: 'marketCollectEmissionEvent', codec: marketCollectEmissionEventCodec },
+  'f774c0b86af6a5b7': { name: 'marketThreeInitEvent', codec: marketThreeInitEventCodec },
+  '191e1d296c8b6704': { name: 'mergeEvent', codec: mergeEventCodec },
+  '8cba5c1204e3160e': { name: 'modifyFarmEvent', codec: modifyFarmEventCodec },
+  '678bbcd8447c6e3f': { name: 'sellPtEvent', codec: sellPtEventCodec },
+  '95931d9f94f08107': { name: 'sellYtEvent', codec: sellYtEventCodec },
+  '72bd1a8f8f32c559': { name: 'stripEvent', codec: stripEventCodec },
+  '9fe16051ffe3e9ae': { name: 'tradePtEvent', codec: tradePtEventCodec },
+  'd606a12dbf8e7cba': { name: 'withdrawLiquidityEvent', codec: withdrawLiquidityEventCodec },
+  '2a614b9d5a79bd6e': { name: 'withdrawLiquidityReturnData', codec: withdrawLiquidityReturnDataCodec },
+  '945f153663100f28': { name: 'wrapperBuyYtEvent', codec: wrapperBuyYtEventCodec },
+  '3c79a45ddc0d8ec5': { name: 'wrapperProvideLiquidityBaseEvent', codec: wrapperProvideLiquidityBaseEventCodec },
+  '57a396a2ba93eac8': { name: 'wrapperProvideLiquidityClassicEvent', codec: wrapperProvideLiquidityClassicEventCodec },
+  'd12ae34dbbd811b1': { name: 'wrapperProvideLiquidityEvent', codec: wrapperProvideLiquidityEventCodec },
+  'fc8c2dfd065e5f87': { name: 'wrapperSellYtEvent', codec: wrapperSellYtEventCodec },
+  '129ad42724179e7c': { name: 'wrapperWithdrawLiquidityClassicEvent', codec: wrapperWithdrawLiquidityClassicEventCodec },
+  '3420b4f124dd48a7': { name: 'wrapperWithdrawLiquidityEvent', codec: wrapperWithdrawLiquidityEventCodec },
+};

package/src/client/clmm/index.ts

@@ -0,0 +1,82 @@
+import { PublicKey } from "@solana/web3.js";
+
+export const EXPONENTCLMM_PROGRAM_ID = new PublicKey(
+  "XPC1MM4dYACDfykNuXYZ5una2DsMDWL24CrYubCvarC",
+);
+
+export * from "./accounts/lpPosition";
+export * from "./accounts/marketThree";
+export * from "./accounts/vault";
+export * from "./instructions/addFarm";
+export * from "./instructions/addLiquidity";
+export * from "./instructions/addMarketEmission";
+export * from "./instructions/buyPt";
+export * from "./instructions/buyYt";
+export * from "./instructions/claimFarmEmission";
+export * from "./instructions/closeMarket";
+export * from "./instructions/depositLiquidity";
+export * from "./instructions/initializeMarket";
+export * from "./instructions/marketAccrueEmission";
+export * from "./instructions/marketCollectEmission";
+export * from "./instructions/modifyFarm";
+export * from "./instructions/modifyMarketSetting";
+export * from "./instructions/sellPt";
+export * from "./instructions/sellYt";
+export * from "./instructions/tradePt";
+export * from "./instructions/tradePtExactOut";
+export * from "./instructions/withdrawLiquidity";
+export * from "./instructions/wrapperBuyYt";
+export * from "./instructions/wrapperProvideLiquidity";
+export * from "./instructions/wrapperProvideLiquidityBase";
+export * from "./instructions/wrapperProvideLiquidityClassic";
+export * from "./instructions/wrapperSellYt";
+export * from "./instructions/wrapperWithdrawLiquidity";
+export * from "./instructions/wrapperWithdrawLiquidityClassic";
+export * from "./types/addFarmEvent";
+export * from "./types/amount";
+export * from "./types/buyPtEvent";
+export * from "./types/buyYtEvent";
+export * from "./types/claimFarmEmissionsEvent";
+export * from "./types/claimLimits";
+export * from "./types/closeMarketEvent";
+export * from "./types/configurationOptions";
+export * from "./types/cpiAccounts";
+export * from "./types/cpiCoreAccounts";
+export * from "./types/cpiInterfaceContext";
+export * from "./types/crossingSplit";
+export * from "./types/depositLiquidityEvent";
+export * from "./types/depositLiquidityReturnData";
+export * from "./types/emissionInfo";
+export * from "./types/farmEmission";
+export * from "./types/liquidityNetBalanceLimits";
+export * from "./types/lpFarm";
+export * from "./types/marketAccrueEmissionEvent";
+export * from "./types/marketAdminAction";
+export * from "./types/marketCollectEmissionEvent";
+export * from "./types/marketEmission";
+export * from "./types/marketEmissions";
+export * from "./types/marketFinancials";
+export * from "./types/marketThreeInitEvent";
+export * from "./types/mergeEvent";
+export * from "./types/modifiedTick";
+export * from "./types/modifiedTicks";
+export * from "./types/modifyFarmEvent";
+export * from "./types/number";
+export * from "./types/personalYieldTracker";
+export * from "./types/personalYieldTrackers";
+export * from "./types/principalShare";
+export * from "./types/principalShareTrackers";
+export * from "./types/sellPtEvent";
+export * from "./types/sellYtEvent";
+export * from "./types/stripEvent";
+export * from "./types/swapDirection";
+export * from "./types/tradePtEvent";
+export * from "./types/withdrawLiquidityEvent";
+export * from "./types/withdrawLiquidityReturnData";
+export * from "./types/wrapperBuyYtEvent";
+export * from "./types/wrapperProvideLiquidityBaseEvent";
+export * from "./types/wrapperProvideLiquidityClassicEvent";
+export * from "./types/wrapperProvideLiquidityEvent";
+export * from "./types/wrapperSellYtEvent";
+export * from "./types/wrapperWithdrawLiquidityClassicEvent";
+export * from "./types/wrapperWithdrawLiquidityEvent";

package/src/client/clmm/instructions/addFarm.ts

@@ -0,0 +1,57 @@
+import {
+  AccountMeta,
+  Keypair,
+  PublicKey,
+  TransactionInstruction,
+} from "@solana/web3.js";
+import { EXPONENTCLMM_PROGRAM_ID } from "..";
+import { getStructCodec, getU32Codec, getU64Codec } from "@solana/codecs";
+
+export interface AddFarmInstructionAccounts {
+  market: PublicKey;
+  ticks: PublicKey;
+  signer: PublicKey;
+  feePayer: PublicKey;
+  mintNew: PublicKey;
+  tokenSource: PublicKey;
+  tokenFarm: PublicKey;
+  tokenProgram: PublicKey;
+  systemProgram: PublicKey;
+  eventAuthority: PublicKey;
+  program: PublicKey;
+}
+
+export interface AddFarmInstructionArgs {
+  tokenRate: bigint;
+  untilTimestamp: number;
+}
+
+const AddFarmInstructionDataCodec = getStructCodec([
+  ["tokenRate", getU64Codec()],
+  ["untilTimestamp", getU32Codec()],
+]);
+
+export function createAddFarmInstruction(
+  accounts: AddFarmInstructionAccounts,
+  args: AddFarmInstructionArgs,
+  programId: PublicKey = EXPONENTCLMM_PROGRAM_ID,
+): TransactionInstruction {
+  const keys: AccountMeta[] = [
+    { pubkey: accounts.market, isSigner: false, isWritable: true },
+    { pubkey: accounts.ticks, isSigner: false, isWritable: true },
+    { pubkey: accounts.signer, isSigner: true, isWritable: false },
+    { pubkey: accounts.feePayer, isSigner: true, isWritable: true },
+    { pubkey: accounts.mintNew, isSigner: false, isWritable: false },
+    { pubkey: accounts.tokenSource, isSigner: false, isWritable: true },
+    { pubkey: accounts.tokenFarm, isSigner: false, isWritable: true },
+    { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false },
+    { pubkey: accounts.systemProgram, isSigner: false, isWritable: false },
+    { pubkey: accounts.eventAuthority, isSigner: false, isWritable: false },
+    { pubkey: accounts.program, isSigner: false, isWritable: false },
+  ];
+  const instructionData = Buffer.from(AddFarmInstructionDataCodec.encode(args));
+  const discriminator = Buffer.from("07", "hex");
+  const data = Buffer.concat([discriminator, instructionData]);
+
+  return new TransactionInstruction({ keys, programId, data });
+}

package/src/client/clmm/instructions/addLiquidity.ts

@@ -0,0 +1,78 @@
+import {
+  AccountMeta,
+  Keypair,
+  PublicKey,
+  TransactionInstruction,
+} from "@solana/web3.js";
+import { EXPONENTCLMM_PROGRAM_ID } from "..";
+import {
+  getOptionCodec,
+  getStructCodec,
+  getU32Codec,
+  getU64Codec,
+} from "@solana/codecs";
+
+export interface AddLiquidityInstructionAccounts {
+  owner: PublicKey;
+  market: PublicKey;
+  ticks: PublicKey;
+  lpPosition: PublicKey;
+  tokenPtSrc: PublicKey;
+  tokenSySrc: PublicKey;
+  tokenPtEscrow: PublicKey;
+  tokenSyEscrow: PublicKey;
+  addressLookupTable: PublicKey;
+  tokenProgram: PublicKey;
+  syProgram: PublicKey;
+  instructionsSysvar: PublicKey;
+  systemProgram: PublicKey;
+  rent: PublicKey;
+  eventAuthority: PublicKey;
+  program: PublicKey;
+}
+
+export interface AddLiquidityInstructionArgs {
+  maxSyInToAdd: bigint;
+  maxPtInToAdd: bigint;
+  lowerTickKeyOptional: number | null;
+  upperTickKeyOptional: number | null;
+}
+
+const AddLiquidityInstructionDataCodec = getStructCodec([
+  ["maxSyInToAdd", getU64Codec()],
+  ["maxPtInToAdd", getU64Codec()],
+  ["lowerTickKeyOptional", getOptionCodec(getU32Codec())],
+  ["upperTickKeyOptional", getOptionCodec(getU32Codec())],
+]);
+
+export function createAddLiquidityInstruction(
+  accounts: AddLiquidityInstructionAccounts,
+  args: AddLiquidityInstructionArgs,
+  programId: PublicKey = EXPONENTCLMM_PROGRAM_ID,
+): TransactionInstruction {
+  const keys: AccountMeta[] = [
+    { pubkey: accounts.owner, isSigner: true, isWritable: true },
+    { pubkey: accounts.market, isSigner: false, isWritable: true },
+    { pubkey: accounts.ticks, isSigner: false, isWritable: true },
+    { pubkey: accounts.lpPosition, isSigner: false, isWritable: true },
+    { pubkey: accounts.tokenPtSrc, isSigner: false, isWritable: true },
+    { pubkey: accounts.tokenSySrc, isSigner: false, isWritable: true },
+    { pubkey: accounts.tokenPtEscrow, isSigner: false, isWritable: true },
+    { pubkey: accounts.tokenSyEscrow, isSigner: false, isWritable: true },
+    { pubkey: accounts.addressLookupTable, isSigner: false, isWritable: false },
+    { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false },
+    { pubkey: accounts.syProgram, isSigner: false, isWritable: false },
+    { pubkey: accounts.instructionsSysvar, isSigner: false, isWritable: false },
+    { pubkey: accounts.systemProgram, isSigner: false, isWritable: false },
+    { pubkey: accounts.rent, isSigner: false, isWritable: false },
+    { pubkey: accounts.eventAuthority, isSigner: false, isWritable: false },
+    { pubkey: accounts.program, isSigner: false, isWritable: false },
+  ];
+  const instructionData = Buffer.from(
+    AddLiquidityInstructionDataCodec.encode(args),
+  );
+  const discriminator = Buffer.from("19", "hex");
+  const data = Buffer.concat([discriminator, instructionData]);
+
+  return new TransactionInstruction({ keys, programId, data });
+}

package/src/client/clmm/instructions/addMarketEmission.ts

@@ -0,0 +1,50 @@
+import {
+  AccountMeta,
+  Keypair,
+  PublicKey,
+  TransactionInstruction,
+} from "@solana/web3.js";
+import { CpiAccounts, cpiAccountsCodec } from "../types/cpiAccounts";
+import { EXPONENTCLMM_PROGRAM_ID } from "..";
+import { getStructCodec } from "@solana/codecs";
+
+export interface AddMarketEmissionInstructionAccounts {
+  market: PublicKey;
+  signer: PublicKey;
+  feePayer: PublicKey;
+  mintNew: PublicKey;
+  tokenEmission: PublicKey;
+  tokenProgram: PublicKey;
+  systemProgram: PublicKey;
+}
+
+export interface AddMarketEmissionInstructionArgs {
+  cpiAccounts: CpiAccounts;
+}
+
+const AddMarketEmissionInstructionDataCodec = getStructCodec([
+  ["cpiAccounts", cpiAccountsCodec],
+]);
+
+export function createAddMarketEmissionInstruction(
+  accounts: AddMarketEmissionInstructionAccounts,
+  args: AddMarketEmissionInstructionArgs,
+  programId: PublicKey = EXPONENTCLMM_PROGRAM_ID,
+): TransactionInstruction {
+  const keys: AccountMeta[] = [
+    { pubkey: accounts.market, isSigner: false, isWritable: true },
+    { pubkey: accounts.signer, isSigner: true, isWritable: false },
+    { pubkey: accounts.feePayer, isSigner: true, isWritable: true },
+    { pubkey: accounts.mintNew, isSigner: false, isWritable: false },
+    { pubkey: accounts.tokenEmission, isSigner: false, isWritable: true },
+    { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false },
+    { pubkey: accounts.systemProgram, isSigner: false, isWritable: false },
+  ];
+  const instructionData = Buffer.from(
+    AddMarketEmissionInstructionDataCodec.encode(args),
+  );
+  const discriminator = Buffer.from("08", "hex");
+  const data = Buffer.concat([discriminator, instructionData]);
+
+  return new TransactionInstruction({ keys, programId, data });
+}

package/src/client/clmm/instructions/buyPt.ts

@@ -0,0 +1,73 @@
+import {
+  AccountMeta,
+  Keypair,
+  PublicKey,
+  TransactionInstruction,
+} from "@solana/web3.js";
+import { EXPONENTCLMM_PROGRAM_ID } from "..";
+import {
+  getF64Codec,
+  getOptionCodec,
+  getStructCodec,
+  getU64Codec,
+  getU8Codec,
+} from "@solana/codecs";
+
+export interface BuyPtInstructionAccounts {
+  buyer: PublicKey;
+  market: PublicKey;
+  tokenSyTrader: PublicKey;
+  tokenPtTrader: PublicKey;
+  tokenSyEscrow: PublicKey;
+  tokenPtEscrow: PublicKey;
+  addressLookupTable: PublicKey;
+  tokenProgram: PublicKey;
+  syProgram: PublicKey;
+  ticks: PublicKey;
+  tokenFeeTreasurySy: PublicKey;
+  tokenFeeTreasuryPt: PublicKey;
+  eventAuthority: PublicKey;
+  program: PublicKey;
+}
+
+export interface BuyPtInstructionArgs {
+  minPtAmount: bigint;
+  baseAmount: bigint;
+  priceSpotLimit: number | null;
+  mintSyRemAccountsUntil: number;
+}
+
+const BuyPtInstructionDataCodec = getStructCodec([
+  ["minPtAmount", getU64Codec()],
+  ["baseAmount", getU64Codec()],
+  ["priceSpotLimit", getOptionCodec(getF64Codec())],
+  ["mintSyRemAccountsUntil", getU8Codec()],
+]);
+
+export function createBuyPtInstruction(
+  accounts: BuyPtInstructionAccounts,
+  args: BuyPtInstructionArgs,
+  programId: PublicKey = EXPONENTCLMM_PROGRAM_ID,
+): TransactionInstruction {
+  const keys: AccountMeta[] = [
+    { pubkey: accounts.buyer, isSigner: true, isWritable: true },
+    { pubkey: accounts.market, isSigner: false, isWritable: true },
+    { pubkey: accounts.tokenSyTrader, isSigner: false, isWritable: true },
+    { pubkey: accounts.tokenPtTrader, isSigner: false, isWritable: true },
+    { pubkey: accounts.tokenSyEscrow, isSigner: false, isWritable: true },
+    { pubkey: accounts.tokenPtEscrow, isSigner: false, isWritable: true },
+    { pubkey: accounts.addressLookupTable, isSigner: false, isWritable: false },
+    { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false },
+    { pubkey: accounts.syProgram, isSigner: false, isWritable: false },
+    { pubkey: accounts.ticks, isSigner: false, isWritable: true },
+    { pubkey: accounts.tokenFeeTreasurySy, isSigner: false, isWritable: true },
+    { pubkey: accounts.tokenFeeTreasuryPt, isSigner: false, isWritable: true },
+    { pubkey: accounts.eventAuthority, isSigner: false, isWritable: false },
+    { pubkey: accounts.program, isSigner: false, isWritable: false },
+  ];
+  const instructionData = Buffer.from(BuyPtInstructionDataCodec.encode(args));
+  const discriminator = Buffer.from("0e", "hex");
+  const data = Buffer.concat([discriminator, instructionData]);
+
+  return new TransactionInstruction({ keys, programId, data });
+}