@exponent-labs/exponent-sdk 0.9.2 → 0.9.3

package/src/CodamaEventDecoder.ts

@@ -1,151 +0,0 @@
-import { Codec, getBase58Encoder } from "@solana/codecs"
-import { CompiledInstruction, MessageAccountKeys, PublicKey } from "@solana/web3.js"
-
-// Discriminator for Anchor's auto-generated __event_cpi instruction: sha256("global:__event_cpi")[0..8]
-// This is a fixed constant across all Anchor programs that use emit_cpi!().
-// Every emit_cpi!() call produces a self-CPI instruction whose data starts with these 8 bytes,
-// followed by the event discriminator (8 bytes) and the borsh-encoded event payload.
-// See:
-// https://github.com/solana-foundation/anchor/blob/7dba2009682143bca9452d987d191a8c1b74843d/lang/attribute/event/src/lib.rs#L157
-// https://github.com/solana-foundation/anchor/blob/master/lang/src/event.rs#L3
-const EVENT_IX_TAG = Buffer.from([0xe4, 0x45, 0xa5, 0x2e, 0x51, 0xcb, 0x9a, 0x1d])
-
-export type GenericEvent = {
-  name: string
-  data: unknown
-}
-
-type OnErrorHandler = (error: Error) => void | Promise<void>
-
-type EventRegistry = Record<
-  string,
-  {
-    name: string
-    codec: Codec<any>
-  }
->
-
-/**
- * Codama-based event decoder that uses generated event codecs.
- * Replaces Anchor-based EventDecoderV2 with zero Anchor dependencies.
- *
- * @example
- * ```ts
- * import { EVENT_CODEC_REGISTRY } from './client/core/eventRegistry';
- * const decoder = new CodamaEventDecoder(programId, EVENT_CODEC_REGISTRY);
- * const events = decoder.parseEvents(instructions, accountKeys);
- * ```
- */
-export class CodamaEventDecoder {
-  private programId: PublicKey
-  private eventRegistry: EventRegistry
-  private onError?: OnErrorHandler
-
-  constructor(programId: PublicKey, eventRegistry: EventRegistry, params?: { onError?: OnErrorHandler }) {
-    this.programId = programId
-    this.eventRegistry = eventRegistry
-    this.onError = params?.onError
-  }
-
-  private getEventDataFromIxn(
-    ixnData: string | Uint8Array,
-    ixnIdx: number,
-  ): { discriminator: string; eventData: Uint8Array } {
-    const encodedLog =
-      typeof ixnData === "string" ? Buffer.from(getBase58Encoder().encode(ixnData)) : Buffer.from(ixnData)
-
-    // First 8 bytes should be the event instruction tag
-    const ixTag = encodedLog.subarray(0, 8)
-    if (!ixTag.equals(EVENT_IX_TAG)) {
-      throw new Error("Event instruction tag not found", {
-        cause: { ixnData, instructionIndex: ixnIdx },
-      })
-    }
-
-    // Next 8 bytes are the event discriminator
-    const discriminatorBytes = encodedLog.subarray(8, 16)
-    // Convert to hex since that's how we store keys in the registry
-    const discriminatorHex = Buffer.from(discriminatorBytes).toString("hex")
-
-    // Remaining bytes are the event data payload
-    const eventDataBytes = encodedLog.subarray(16)
-
-    return {
-      discriminator: discriminatorHex,
-      eventData: eventDataBytes,
-    }
-  }
-
-  private parseEvent(ixnData: string | Uint8Array, ixnIdx: number): GenericEvent | null {
-    try {
-      const { discriminator, eventData } = this.getEventDataFromIxn(ixnData, ixnIdx)
-
-      // Look up the event definition in the registry
-      const eventDef = this.eventRegistry[discriminator]
-      if (!eventDef) {
-        throw new Error(`Unknown event discriminator: ${discriminator}`, {
-          cause: { discriminator, instructionIndex: ixnIdx },
-        })
-      }
-
-      // Decode using the Codama-generated codec
-
-      const decodedData = eventDef.codec.decode(eventData)
-      // TODO: We could probably return a better type here, make the data not 'unkown'
-      return {
-        name: eventDef.name,
-        data: decodedData,
-      }
-    } catch (error) {
-      this.onError?.(error as Error)
-      return null
-    }
-  }
-
-  /**
-   * Check if an instruction belongs to the specified program
-   */
-  static ixnHasProgramId(
-    instruction: CompiledInstruction,
-    accountKeys: MessageAccountKeys,
-    programId: PublicKey,
-  ): boolean {
-    const programPubkey = accountKeys.get(instruction.programIdIndex)
-    if (!!programPubkey && programPubkey.equals(programId)) {
-      return true
-    }
-
-    return false
-  }
-
-  /**
-   * Check if a transaction contains any instruction from the specified program
-   * Use this to filter transactions before applying event decoding for performance
-   */
-  static txnHasProgramId(
-    instructions: CompiledInstruction[],
-    accountKeys: MessageAccountKeys,
-    programId: PublicKey,
-  ): boolean {
-    return instructions.some((ixn) => {
-      return CodamaEventDecoder.ixnHasProgramId(ixn, accountKeys, programId)
-    })
-  }
-
-  /**
-   * Parse events from transaction instructions
-   * @param instructions - Compiled instructions from a transaction
-   * @param accountKeys - Account keys from the transaction
-   * @returns Array of decoded events
-   */
-  parseEvents(instructions: CompiledInstruction[], accountKeys: MessageAccountKeys): GenericEvent[] {
-    return instructions
-      .map((ixn, ixnIdx) => {
-        if (CodamaEventDecoder.ixnHasProgramId(ixn, accountKeys, this.programId)) {
-          return this.parseEvent(ixn.data, ixnIdx) || null
-        }
-        return null
-      })
-      .filter((ev): ev is GenericEvent => !!ev)
-  }
-}

package/src/addressLookupTableUtil.ts

@@ -1,110 +0,0 @@
-import {
-  CpiAccountIndex,
-  CpiAccountIndexes,
-  ExponentCoreCpiIndexes,
-  MarketCpiCoreIndexes,
-} from "@exponent-labs/exponent-types"
-import {AccountMeta, Connection, PublicKey, AddressLookupTableAccount } from "@solana/web3.js"
-
-const PLACEHOLDER_ALT = "11111111111111111111111111111111"
-
-/** Error thrown when the market's ALT is invalid or not set (e.g. system program placeholder). */
-export class InvalidAddressLookupTableError extends Error {
-  constructor(
-    message: string,
-    public readonly altAddress: string,
-  ) {
-    super(message)
-    this.name = "InvalidAddressLookupTableError"
-  }
-}
-
-/** Fetch and deserialize the ALT. Throws InvalidAddressLookupTableError when ALT is placeholder or invalid. */
-export async function fetchAddressLookupTable(
-  connection: Connection,
-  address: PublicKey,
-): Promise<PublicKey[]> {
-  const addressStr = address.toBase58()
-  if (addressStr === PLACEHOLDER_ALT) {
-    throw new InvalidAddressLookupTableError(
-      "Market's address lookup table is not set (system program placeholder). Use the admin app to repair ALT & CPI for this market.",
-      addressStr,
-    )
-  }
-  const accountInfo = await connection.getAccountInfo(address)
-  if (accountInfo === null) {
-    throw new Error("Failed to find address lookup table")
-  }
-
-  try {
-    const alt = AddressLookupTableAccount.deserialize(new Uint8Array(accountInfo.data))
-    return alt.addresses
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err)
-    if (
-      err instanceof RangeError ||
-      msg.includes("buffer length") ||
-      msg.includes("invalid instruction")
-    ) {
-      throw new InvalidAddressLookupTableError(
-        `Market's address lookup table (${addressStr}) is invalid or not an ALT account. Use the admin app to repair ALT & CPI for this market.`,
-        addressStr,
-      )
-    }
-    throw err
-  }
-}
-
-/** Create the CPI accounts lists from the Address Lookup Table and the on-chain stored CPI account indexes */
-export function makeCpiAccountMetaLists(altAddresses: PublicKey[], cpiIndexes: CpiAccountIndexes) {
-  const pluckAddress = (index: number) => altAddresses[index]
-  const transform = (a: CpiAccountIndex): AccountMeta => ({
-    isSigner: false,
-    isWritable: a.isWritable,
-    pubkey: pluckAddress(a.altIndex),
-  })
-
-  return {
-    getSyState: cpiIndexes.getSyState.map(transform),
-    withdrawSy: cpiIndexes.withdrawSy.map(transform),
-    depositSy: cpiIndexes.depositSy.map(transform),
-    claimEmission: cpiIndexes.claimEmission.map((a) => a.map(transform)),
-    getPositionState: cpiIndexes.getPositionState.map(transform),
-  }
-}
-
-/** Create the CPI accounts lists from the Address Lookup Table and the on-chain stored CPI account indexes (for Orderbook/full core CPI) */
-export function makeCoreCpiAccountMetaLists(altAddresses: PublicKey[], cpiIndexes: ExponentCoreCpiIndexes) {
-  const pluckAddress = (index: number) => altAddresses[index]
-  const transform = (a: CpiAccountIndex): AccountMeta => ({
-    isSigner: false,
-    isWritable: a.isWritable,
-    pubkey: pluckAddress(a.altIndex),
-  })
-
-  return {
-    depositYt: cpiIndexes.depositYt.map(transform),
-    withdrawYt: cpiIndexes.withdrawYt.map(transform),
-    stripSy: cpiIndexes.stripSy.map(transform),
-    mergeSy: cpiIndexes.mergeSy.map(transform),
-    collectInterest: cpiIndexes.collectInterest.map(transform),
-  }
-}
-
-/** Create the CPI accounts lists from the Address Lookup Table for MarketThree (only stripSy and mergeSy, others empty) */
-export function makeMarketCoreCpiAccountMetaLists(altAddresses: PublicKey[], cpiIndexes: MarketCpiCoreIndexes) {
-  const pluckAddress = (index: number) => altAddresses[index]
-  const transform = (a: CpiAccountIndex): AccountMeta => ({
-    isSigner: false,
-    isWritable: a.isWritable,
-    pubkey: pluckAddress(a.altIndex),
-  })
-
-  return {
-    depositYt: [],
-    withdrawYt: [],
-    stripSy: cpiIndexes.stripSy.map(transform),
-    mergeSy: cpiIndexes.mergeSy.map(transform),
-    collectInterest: [],
-  }
-}

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

@@ -1,143 +0,0 @@
-import { Connection, PublicKey } from "@solana/web3.js";
-import { CrossingSplit, crossingSplitCodec } from "../types/crossingSplit";
-import {
-  PersonalYieldTrackers,
-  personalYieldTrackersCodec,
-} from "../types/personalYieldTrackers";
-import {
-  PrincipalShareTrackers,
-  principalShareTrackersCodec,
-} from "../types/principalShareTrackers";
-import {
-  fixCodecSize,
-  getBytesCodec,
-  getStructCodec,
-  getU128Codec,
-  getU32Codec,
-  getU64Codec,
-  transformCodec,
-} from "@solana/codecs";
-
-export interface LpPositionAccountData {
-  owner: PublicKey;
-  market: PublicKey;
-  feeInsideLastPt: bigint;
-  feeInsideLastSy: bigint;
-  lpBalance: bigint;
-  tokensOwedSy: bigint;
-  tokensOwedPt: bigint;
-  lowerTickIdx: number;
-  upperTickIdx: number;
-  farms: PersonalYieldTrackers;
-  shareTrackers: PrincipalShareTrackers;
-  crossingSplit: CrossingSplit;
-}
-
-export interface LpPositionAccount {
-  address: PublicKey;
-  data: LpPositionAccountData;
-}
-
-const LpPositionAccountDataCodec = getStructCodec([
-  ["discriminator", fixCodecSize(getBytesCodec(), 8)],
-  [
-    "owner",
-    transformCodec(
-      fixCodecSize(getBytesCodec(), 32),
-      (value: PublicKey) => value.toBytes(),
-      (value) => new PublicKey(value),
-    ),
-  ],
-  [
-    "market",
-    transformCodec(
-      fixCodecSize(getBytesCodec(), 32),
-      (value: PublicKey) => value.toBytes(),
-      (value) => new PublicKey(value),
-    ),
-  ],
-  ["feeInsideLastPt", getU128Codec()],
-  ["feeInsideLastSy", getU128Codec()],
-  ["lpBalance", getU64Codec()],
-  ["tokensOwedSy", getU64Codec()],
-  ["tokensOwedPt", getU64Codec()],
-  ["lowerTickIdx", getU32Codec()],
-  ["upperTickIdx", getU32Codec()],
-  ["farms", personalYieldTrackersCodec],
-  ["shareTrackers", principalShareTrackersCodec],
-  ["crossingSplit", crossingSplitCodec],
-]);
-
-export function deserializeLpPositionAccount(
-  data: Uint8Array,
-): LpPositionAccountData {
-  const deserialized = LpPositionAccountDataCodec.decode(data);
-  const { discriminator: _, ...accountData } = deserialized;
-  return accountData as LpPositionAccountData;
-}
-
-export async function fetchLpPositionAccount(
-  connection: Connection,
-  address: PublicKey,
-): Promise<LpPositionAccount> {
-  const accountInfo = await connection.getAccountInfo(address);
-  if (!accountInfo) {
-    throw new Error(
-      "LpPosition account not found at address: " + address.toBase58(),
-    );
-  }
-  return {
-    address,
-    data: deserializeLpPositionAccount(accountInfo.data),
-  };
-}
-
-export async function fetchAllMaybeLpPositionAccounts(
-  connection: Connection,
-  addresses: PublicKey[],
-): Promise<(LpPositionAccount | null)[]> {
-  const accountInfos = await connection.getMultipleAccountsInfo(addresses);
-  return accountInfos.map((accountInfo, index) => {
-    if (!accountInfo) {
-      return null;
-    }
-    return {
-      address: addresses[index],
-      data: deserializeLpPositionAccount(accountInfo.data),
-    };
-  });
-}
-
-export async function fetchAllLpPositionAccounts(
-  connection: Connection,
-  addresses: PublicKey[],
-): Promise<LpPositionAccount[]> {
-  const maybeAccounts = await fetchAllMaybeLpPositionAccounts(
-    connection,
-    addresses,
-  );
-  const missingAddresses = maybeAccounts
-    .flatMap((account, i) => (!account ? [addresses[i].toBase58()] : []))
-    .join(", ");
-  if (missingAddresses) {
-    throw new Error(
-      "LpPosition account(s) not found at address(es): " + missingAddresses,
-    );
-  }
-  return maybeAccounts.filter((a): a is LpPositionAccount => a !== null);
-}
-
-export async function fetchProgramAccountsLpPosition(
-  connection: Connection,
-  programId: PublicKey,
-  options?: { commitment?: "processed" | "confirmed" | "finalized" },
-): Promise<LpPositionAccount[]> {
-  const accounts = await connection.getProgramAccounts(programId, {
-    commitment: options?.commitment,
-    filters: [{ memcmp: { offset: 0, bytes: "Jimf5pVB9RT" } }],
-  });
-  return accounts.map(({ pubkey, account }) => ({
-    address: pubkey,
-    data: deserializeLpPositionAccount(account.data),
-  }));
-}

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

@@ -1,274 +0,0 @@
-import {
-  ConfigurationOptions,
-  configurationOptionsCodec,
-} from "../types/configurationOptions";
-import { Connection, PublicKey } from "@solana/web3.js";
-import { CpiAccounts, cpiAccountsCodec } from "../types/cpiAccounts";
-import {
-  CpiCoreAccounts,
-  cpiCoreAccountsCodec,
-} from "../types/cpiCoreAccounts";
-import {
-  LiquidityNetBalanceLimits,
-  liquidityNetBalanceLimitsCodec,
-} from "../types/liquidityNetBalanceLimits";
-import { LpFarm, lpFarmCodec } from "../types/lpFarm";
-import {
-  MarketEmissions,
-  marketEmissionsCodec,
-} from "../types/marketEmissions";
-import {
-  MarketFinancials,
-  marketFinancialsCodec,
-} from "../types/marketFinancials";
-import {
-  fixCodecSize,
-  getBooleanCodec,
-  getBytesCodec,
-  getStructCodec,
-  getU8Codec,
-  transformCodec,
-} from "@solana/codecs";
-
-export interface MarketThreeAccountData {
-  admin: PublicKey;
-  addressLookupTable: PublicKey;
-  mintPt: PublicKey;
-  mintSy: PublicKey;
-  mintYt: PublicKey;
-  vault: PublicKey;
-  tokenPtEscrow: PublicKey;
-  tokenSyEscrow: PublicKey;
-  tokenYtEscrow: PublicKey;
-  tokenFeeTreasurySy: PublicKey;
-  tokenFeeTreasuryPt: PublicKey;
-  selfAddress: PublicKey;
-  ticks: PublicKey;
-  signerBump: Uint8Array;
-  statusFlags: number;
-  syProgram: PublicKey;
-  exponentCoreProgram: PublicKey;
-  configurationOptions: ConfigurationOptions;
-  financials: MarketFinancials;
-  emissions: MarketEmissions;
-  lpFarm: LpFarm;
-  cpiSyAccounts: CpiAccounts;
-  cpiCoreAccounts: CpiCoreAccounts;
-  isCurrentFlashSwap: boolean;
-  liquidityNetBalanceLimits: LiquidityNetBalanceLimits;
-  seedId: Uint8Array;
-}
-
-export interface MarketThreeAccount {
-  address: PublicKey;
-  data: MarketThreeAccountData;
-}
-
-const MarketThreeAccountDataCodec = getStructCodec([
-  ["discriminator", fixCodecSize(getBytesCodec(), 8)],
-  [
-    "admin",
-    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),
-    ),
-  ],
-  [
-    "mintPt",
-    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),
-    ),
-  ],
-  [
-    "vault",
-    transformCodec(
-      fixCodecSize(getBytesCodec(), 32),
-      (value: PublicKey) => value.toBytes(),
-      (value) => new PublicKey(value),
-    ),
-  ],
-  [
-    "tokenPtEscrow",
-    transformCodec(
-      fixCodecSize(getBytesCodec(), 32),
-      (value: PublicKey) => value.toBytes(),
-      (value) => new PublicKey(value),
-    ),
-  ],
-  [
-    "tokenSyEscrow",
-    transformCodec(
-      fixCodecSize(getBytesCodec(), 32),
-      (value: PublicKey) => value.toBytes(),
-      (value) => new PublicKey(value),
-    ),
-  ],
-  [
-    "tokenYtEscrow",
-    transformCodec(
-      fixCodecSize(getBytesCodec(), 32),
-      (value: PublicKey) => value.toBytes(),
-      (value) => new PublicKey(value),
-    ),
-  ],
-  [
-    "tokenFeeTreasurySy",
-    transformCodec(
-      fixCodecSize(getBytesCodec(), 32),
-      (value: PublicKey) => value.toBytes(),
-      (value) => new PublicKey(value),
-    ),
-  ],
-  [
-    "tokenFeeTreasuryPt",
-    transformCodec(
-      fixCodecSize(getBytesCodec(), 32),
-      (value: PublicKey) => value.toBytes(),
-      (value) => new PublicKey(value),
-    ),
-  ],
-  [
-    "selfAddress",
-    transformCodec(
-      fixCodecSize(getBytesCodec(), 32),
-      (value: PublicKey) => value.toBytes(),
-      (value) => new PublicKey(value),
-    ),
-  ],
-  [
-    "ticks",
-    transformCodec(
-      fixCodecSize(getBytesCodec(), 32),
-      (value: PublicKey) => value.toBytes(),
-      (value) => new PublicKey(value),
-    ),
-  ],
-  ["signerBump", fixCodecSize(getBytesCodec(), 1)],
-  ["statusFlags", getU8Codec()],
-  [
-    "syProgram",
-    transformCodec(
-      fixCodecSize(getBytesCodec(), 32),
-      (value: PublicKey) => value.toBytes(),
-      (value) => new PublicKey(value),
-    ),
-  ],
-  [
-    "exponentCoreProgram",
-    transformCodec(
-      fixCodecSize(getBytesCodec(), 32),
-      (value: PublicKey) => value.toBytes(),
-      (value) => new PublicKey(value),
-    ),
-  ],
-  ["configurationOptions", configurationOptionsCodec],
-  ["financials", marketFinancialsCodec],
-  ["emissions", marketEmissionsCodec],
-  ["lpFarm", lpFarmCodec],
-  ["cpiSyAccounts", cpiAccountsCodec],
-  ["cpiCoreAccounts", cpiCoreAccountsCodec],
-  ["isCurrentFlashSwap", getBooleanCodec()],
-  ["liquidityNetBalanceLimits", liquidityNetBalanceLimitsCodec],
-  ["seedId", fixCodecSize(getBytesCodec(), 1)],
-]);
-
-export function deserializeMarketThreeAccount(
-  data: Uint8Array,
-): MarketThreeAccountData {
-  const deserialized = MarketThreeAccountDataCodec.decode(data);
-  const { discriminator: _, ...accountData } = deserialized;
-  return accountData as MarketThreeAccountData;
-}
-
-export async function fetchMarketThreeAccount(
-  connection: Connection,
-  address: PublicKey,
-): Promise<MarketThreeAccount> {
-  const accountInfo = await connection.getAccountInfo(address);
-  if (!accountInfo) {
-    throw new Error(
-      "MarketThree account not found at address: " + address.toBase58(),
-    );
-  }
-  return {
-    address,
-    data: deserializeMarketThreeAccount(accountInfo.data),
-  };
-}
-
-export async function fetchAllMaybeMarketThreeAccounts(
-  connection: Connection,
-  addresses: PublicKey[],
-): Promise<(MarketThreeAccount | null)[]> {
-  const accountInfos = await connection.getMultipleAccountsInfo(addresses);
-  return accountInfos.map((accountInfo, index) => {
-    if (!accountInfo) {
-      return null;
-    }
-    return {
-      address: addresses[index],
-      data: deserializeMarketThreeAccount(accountInfo.data),
-    };
-  });
-}
-
-export async function fetchAllMarketThreeAccounts(
-  connection: Connection,
-  addresses: PublicKey[],
-): Promise<MarketThreeAccount[]> {
-  const maybeAccounts = await fetchAllMaybeMarketThreeAccounts(
-    connection,
-    addresses,
-  );
-  const missingAddresses = maybeAccounts
-    .flatMap((account, i) => (!account ? [addresses[i].toBase58()] : []))
-    .join(", ");
-  if (missingAddresses) {
-    throw new Error(
-      "MarketThree account(s) not found at address(es): " + missingAddresses,
-    );
-  }
-  return maybeAccounts.filter((a): a is MarketThreeAccount => a !== null);
-}
-
-export async function fetchProgramAccountsMarketThree(
-  connection: Connection,
-  programId: PublicKey,
-  options?: { commitment?: "processed" | "confirmed" | "finalized" },
-): Promise<MarketThreeAccount[]> {
-  const accounts = await connection.getProgramAccounts(programId, {
-    commitment: options?.commitment,
-    filters: [{ memcmp: { offset: 0, bytes: "hdoWfvn8Dqv" } }],
-  });
-  return accounts.map(({ pubkey, account }) => ({
-    address: pubkey,
-    data: deserializeMarketThreeAccount(account.data),
-  }));
-}