@exponent-labs/exponent-sdk 0.1.7 → 0.1.8

package/src/addressLookupTableUtil.ts

@@ -1,6 +1,11 @@
 import { web3 } from "@coral-xyz/anchor"
 
-import { CpiAccountIndex, CpiAccountIndexes } from "@exponent-labs/exponent-types"
+import {
+  CpiAccountIndex,
+  CpiAccountIndexes,
+  ExponentCoreCpiIndexes,
+  MarketCpiCoreIndexes,
+} from "@exponent-labs/exponent-types"
 
 /** Fetch and deserialize the ALT */
 export async function fetchAddressLookupTable(
@@ -33,3 +38,39 @@ export function makeCpiAccountMetaLists(altAddresses: web3.PublicKey[], cpiIndex
     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: web3.PublicKey[], cpiIndexes: ExponentCoreCpiIndexes) {
+  const pluckAddress = (index: number) => altAddresses[index]
+  const transform = (a: CpiAccountIndex): web3.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: web3.PublicKey[], cpiIndexes: MarketCpiCoreIndexes) {
+  const pluckAddress = (index: number) => altAddresses[index]
+  const transform = (a: CpiAccountIndex): web3.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/clmm/events.ts

@@ -0,0 +1,17 @@
+import { IdlTypes } from "@coral-xyz/anchor"
+
+import { ExponentClmm, IDL, PROGRAM_ID } from "@exponent-labs/exponent-clmm-idl"
+
+import { EventDecoderV2 } from "../EventDecoderV2"
+import { createAnchorProgram } from "../utils"
+
+export const CLMM_PROGRAM_ID = PROGRAM_ID
+const CLMM_PROGRAM = createAnchorProgram(IDL as ExponentClmm)
+export const CLMM_EVENT_DECODER = new EventDecoderV2(CLMM_PROGRAM)
+
+export type ClmmEventNames = ExponentClmm["events"][number]["name"]
+export type ClmmEvent<Name extends ClmmEventNames> = IdlTypes<ExponentClmm>[Name]
+
+export type PersonalYieldTrackers = IdlTypes<ExponentClmm>["personalYieldTrackers"]
+export type PrincipalShare = IdlTypes<ExponentClmm>["principalShare"]
+export type PrincipalShareTrackers = IdlTypes<ExponentClmm>["principalShareTrackers"]

package/src/clmm/index.ts

@@ -0,0 +1 @@
+export * from "./events"

package/src/events.ts

@@ -9,33 +9,34 @@ const EVENT_IX_TAG = new BN("1d9acb512ea545e4", 16)
 export class EventDecoder {
   private coder: BorshCoder
   programId: web3.PublicKey
-  private static eventIxTag = EVENT_IX_TAG
+  private static eventIxTagBuffer = Buffer.from(EVENT_IX_TAG.toArray("le", 8))
 
   constructor(idl: ExponentCore = IDL as ExponentCore) {
     this.programId = new web3.PublicKey(idl.address)
     this.coder = new BorshCoder(idl)
   }
 
-  parseAsTransactionCpiData(log: string): string | null {
+  private parseAsTransactionCpiData(ixnData: string | Uint8Array, errLogger?: typeof console.error): string | null {
     try {
-      const encodedLog = Buffer.from(bs58.decode(log))
+      const encodedLog = typeof ixnData === "string" ? Buffer.from(bs58.decode(ixnData)) : Buffer.from(ixnData)
       const discriminator = encodedLog.subarray(0, 8)
 
-      const eventIxTagBuffer = Uint8Array.from(EventDecoder.eventIxTag.toBuffer("le", 8))
+      const eventIxTagBuffer = EventDecoder.eventIxTagBuffer
 
       if (discriminator.equals(eventIxTagBuffer)) {
         return Buffer.from(Uint8Array.from(encodedLog.subarray(8))).toString("base64")
       }
 
-      throw new Error("Discriminator not found")
+      // Not an event instruction - just a regular instruction from the same program
+      return null
     } catch (error) {
-      console.error("Unable tp parse transaction CPI data:", error)
+      errLogger?.("Unable to parse transaction CPI data:", error)
       return null
     }
   }
 
-  decode(log: string): GenericEvent | null {
-    const cpiData = this.parseAsTransactionCpiData(log)
+  private decode(ixnData: string | Uint8Array, errLogger?: typeof console.error): GenericEvent | null {
+    const cpiData = this.parseAsTransactionCpiData(ixnData)
     if (!cpiData) {
       return null
     }
@@ -47,12 +48,26 @@ export class EventDecoder {
         data: event.data,
       }
     } catch (error) {
-      console.error(`Failed to decode event:`, error)
+      errLogger?.(`Failed to decode event:`, error)
       return null
     }
   }
 
-  async parseCpiEvents(
+  parseCpiEvents(instructions: web3.CompiledInstruction[], accountKeys: web3.MessageAccountKeys) {
+    const events = instructions
+      .map((ixn) => {
+        const programPubkey = accountKeys.get(ixn.programIdIndex)
+        if (programPubkey === undefined || !programPubkey.equals(new web3.PublicKey(this.programId))) {
+          return null
+        }
+        return this.decode(ixn.data) || null
+      })
+      .filter((ev) => !!ev)
+
+    return categorizeEvents(events)
+  }
+
+  async parseTransactionResponseCpiEvents(
     transactionResponse: web3.VersionedTransactionResponse | web3.TransactionResponse,
     connection: web3.Connection,
   ): Promise<CategorizedEvents> {
@@ -67,27 +82,16 @@ export class EventDecoder {
       }),
     )
 
-    const instructions: web3.CompiledInstruction[] = innerInstructions.map(({ instructions }) => instructions).flat()
-
-    const events: GenericEvent[] = instructions
-      .map((ix) => {
-        const accountKeys = transactionResponse?.transaction.message.getAccountKeys({
-          addressLookupTableAccounts: lookupTables.map((lookup) => lookup.value),
-        })
-        const programPubkey = accountKeys.get(ix.programIdIndex)
-        if (programPubkey === undefined || !programPubkey.equals(this.programId)) {
-          return null
-        }
-
-        const event = this.decode(ix.data)
+    const accountKeys = transactionResponse?.transaction.message.getAccountKeys({
+      addressLookupTableAccounts: lookupTables.map((lookup) => lookup.value),
+    })
 
-        return event || null
-      })
-      .filter((ev) => !!ev)
+    const instructions: web3.CompiledInstruction[] = innerInstructions.map(({ instructions }) => instructions).flat()
 
-    return categorizeEvents(events)
+    return this.parseCpiEvents(instructions, accountKeys)
   }
 
+  //? Keep as legacy for indexer v1 on websocket
   parseHeliusWebsocketCpiEvents(
     transactionResponse: web3.VersionedTransactionResponse | web3.TransactionResponse,
   ): CategorizedEvents {
@@ -127,19 +131,28 @@ function categorizeEvents(events: GenericEvent[]): CategorizedEvents {
   const stripEvents: StripEvent[] = []
   const mergeEvents: MergeEvent[] = []
   const depositYtEvents: DepositYtEvent[] = []
+  const depositYtEventsV2: DepositYtEventV2[] = []
   const withdrawYtEvents: WithdrawYtEvent[] = []
+  const withdrawYtEventsV2: WithdrawYtEventV2[] = []
   const collectInterestEvents: CollectInterestEvent[] = []
+  const collectInterestEventsV2: CollectInterestEventV2[] = []
   const collectEmissionEvents: CollectEmissionEvent[] = []
+  const collectEmissionEventsV2: CollectEmissionEventV2[] = []
   const stageYieldEvents: StageYieldEvent[] = []
+  const stageYieldEventsV2: StageYieldEventV2[] = []
   const initializeYieldPositionEvents: InitializeYieldPositionEvent[] = []
   const withdrawLpEvents: WithdrawLpEvent[] = []
+  const withdrawLpEventsV2: WithdrawLpEventV2[] = []
   const withdrawLiquidityEvents: WithdrawLiquidityEvent[] = []
   const sellYtEvents: SellYtEvent[] = []
   const marketCollectEmissionEvents: MarketCollectEmissionEvent[] = []
+  const marketCollectEmissionEventsV2: MarketCollectEmissionEventV2[] = []
   const initLpPositionEvents: InitLpPositionEvent[] = []
   const depositLpEvents: DepositLpEvent[] = []
+  const depositLpEventsV2: DepositLpEventV2[] = []
   const depositLiquidityEvents: DepositLiquidityEvent[] = []
   const claimFarmEmissionsEvents: ClaimFarmEmissionsEvent[] = []
+  const claimFarmEmissionsEventsV2: ClaimFarmEmissionsEventV2[] = []
   const buyYtEvents: BuyYtEvent[] = []
   const wrapperBuyYtEvents: WrapperBuyYtEvent[] = []
   const wrapperSellYtEvents: WrapperSellYtEvent[] = []
@@ -168,24 +181,42 @@ function categorizeEvents(events: GenericEvent[]): CategorizedEvents {
       case "DepositYtEvent":
         depositYtEvents.push(ev.data as DepositYtEvent)
         break
+      case "DepositYtEventV2":
+        depositYtEventsV2.push(ev.data as DepositYtEventV2)
+        break
       case "WithdrawYtEvent":
         withdrawYtEvents.push(ev.data as WithdrawYtEvent)
         break
+      case "WithdrawYtEventV2":
+        withdrawYtEventsV2.push(ev.data as WithdrawYtEventV2)
+        break
       case "CollectInterestEvent":
         collectInterestEvents.push(ev.data as CollectInterestEvent)
         break
+      case "CollectInterestEventV2":
+        collectInterestEventsV2.push(ev.data as CollectInterestEventV2)
+        break
       case "CollectEmissionEvent":
         collectEmissionEvents.push(ev.data as CollectEmissionEvent)
         break
+      case "CollectEmissionEventV2":
+        collectEmissionEventsV2.push(ev.data as CollectEmissionEventV2)
+        break
       case "StageYieldEvent":
         stageYieldEvents.push(ev.data as StageYieldEvent)
         break
+      case "StageYieldEventV2":
+        stageYieldEventsV2.push(ev.data as StageYieldEventV2)
+        break
       case "InitializeYieldPositionEvent":
         initializeYieldPositionEvents.push(ev.data as InitializeYieldPositionEvent)
         break
       case "WithdrawLpEvent":
         withdrawLpEvents.push(ev.data as WithdrawLpEvent)
         break
+      case "WithdrawLpEventV2":
+        withdrawLpEventsV2.push(ev.data as WithdrawLpEventV2)
+        break
       case "WithdrawLiquidityEvent":
         withdrawLiquidityEvents.push(ev.data as WithdrawLiquidityEvent)
         break
@@ -195,18 +226,27 @@ function categorizeEvents(events: GenericEvent[]): CategorizedEvents {
       case "MarketCollectEmissionEvent":
         marketCollectEmissionEvents.push(ev.data as MarketCollectEmissionEvent)
         break
+      case "MarketCollectEmissionEventV2":
+        marketCollectEmissionEventsV2.push(ev.data as MarketCollectEmissionEventV2)
+        break
       case "InitLpPositionEvent":
         initLpPositionEvents.push(ev.data as InitLpPositionEvent)
         break
       case "DepositLpEvent":
         depositLpEvents.push(ev.data as DepositLpEvent)
         break
+      case "DepositLpEventV2":
+        depositLpEventsV2.push(ev.data as DepositLpEventV2)
+        break
       case "DepositLiquidityEvent":
         depositLiquidityEvents.push(ev.data as DepositLiquidityEvent)
         break
       case "ClaimFarmEmissionsEvent":
         claimFarmEmissionsEvents.push(ev.data as ClaimFarmEmissionsEvent)
         break
+      case "ClaimFarmEmissionsEventV2":
+        claimFarmEmissionsEventsV2.push(ev.data as ClaimFarmEmissionsEventV2)
+        break
       case "BuyYtEvent":
         buyYtEvents.push(ev.data as BuyYtEvent)
         break
@@ -254,19 +294,28 @@ function categorizeEvents(events: GenericEvent[]): CategorizedEvents {
     stripEvents,
     mergeEvents,
     depositYtEvents,
+    depositYtEventsV2,
     withdrawYtEvents,
+    withdrawYtEventsV2,
     collectInterestEvents,
+    collectInterestEventsV2,
     collectEmissionEvents,
+    collectEmissionEventsV2,
     stageYieldEvents,
+    stageYieldEventsV2,
     initializeYieldPositionEvents,
     withdrawLpEvents,
+    withdrawLpEventsV2,
     withdrawLiquidityEvents,
     sellYtEvents,
     marketCollectEmissionEvents,
+    marketCollectEmissionEventsV2,
     initLpPositionEvents,
     depositLpEvents,
+    depositLpEventsV2,
     depositLiquidityEvents,
     claimFarmEmissionsEvents,
+    claimFarmEmissionsEventsV2,
     buyYtEvents,
     wrapperBuyYtEvents,
     wrapperSellYtEvents,
@@ -288,19 +337,28 @@ export interface CategorizedEvents {
   stripEvents: StripEvent[]
   mergeEvents: MergeEvent[]
   depositYtEvents: DepositYtEvent[]
+  depositYtEventsV2: DepositYtEventV2[]
   withdrawYtEvents: WithdrawYtEvent[]
+  withdrawYtEventsV2: WithdrawYtEventV2[]
   collectInterestEvents: CollectInterestEvent[]
+  collectInterestEventsV2: CollectInterestEventV2[]
   collectEmissionEvents: CollectEmissionEvent[]
+  collectEmissionEventsV2: CollectEmissionEventV2[]
   stageYieldEvents: StageYieldEvent[]
+  stageYieldEventsV2: StageYieldEventV2[]
   initializeYieldPositionEvents: InitializeYieldPositionEvent[]
   withdrawLpEvents: WithdrawLpEvent[]
+  withdrawLpEventsV2: WithdrawLpEventV2[]
   withdrawLiquidityEvents: WithdrawLiquidityEvent[]
   sellYtEvents: SellYtEvent[]
   marketCollectEmissionEvents: MarketCollectEmissionEvent[]
+  marketCollectEmissionEventsV2: MarketCollectEmissionEventV2[]
   initLpPositionEvents: InitLpPositionEvent[]
   depositLpEvents: DepositLpEvent[]
+  depositLpEventsV2: DepositLpEventV2[]
   depositLiquidityEvents: DepositLiquidityEvent[]
   claimFarmEmissionsEvents: ClaimFarmEmissionsEvent[]
+  claimFarmEmissionsEventsV2: ClaimFarmEmissionsEventV2[]
   buyYtEvents: BuyYtEvent[]
   wrapperBuyYtEvents: WrapperBuyYtEvent[]
   wrapperSellYtEvents: WrapperSellYtEvent[]
@@ -389,6 +447,29 @@ export interface DepositYtEvent {
   unix_timestamp: BN
 }
 
+export interface DepositYtEventV2 {
+  depositor: web3.PublicKey
+  vault: web3.PublicKey
+  user_yield_position: web3.PublicKey
+  vault_yield_position: web3.PublicKey
+  yt_src: web3.PublicKey
+  escrow_yt: web3.PublicKey
+  amount: BN
+  sy_exchange_rate: AnchorizedPNum
+  user_yt_balance_after: BN
+  vault_yt_balance_after: BN
+  user_staged_yield: BN
+  unix_timestamp: BN
+  user_interest: {
+    last_seen_index: AnchorizedPNum
+    staged: BN
+  }
+  user_emissions: {
+    last_seen_index: AnchorizedPNum
+    staged: BN
+  }[]
+}
+
 export interface WithdrawYtEvent {
   owner: web3.PublicKey
   vault: web3.PublicKey
@@ -404,6 +485,29 @@ export interface WithdrawYtEvent {
   unix_timestamp: BN
 }
 
+export interface WithdrawYtEventV2 {
+  owner: web3.PublicKey
+  vault: web3.PublicKey
+  user_yield_position: web3.PublicKey
+  vault_yield_position: web3.PublicKey
+  yt_dst: web3.PublicKey
+  escrow_yt: web3.PublicKey
+  amount: BN
+  sy_exchange_rate: AnchorizedPNum
+  user_yt_balance_after: BN
+  vault_yt_balance_after: BN
+  user_staged_yield: BN
+  unix_timestamp: BN
+  user_interest: {
+    last_seen_index: AnchorizedPNum
+    staged: BN
+  }
+  user_emissions: {
+    last_seen_index: AnchorizedPNum
+    staged: BN
+  }[]
+}
+
 export interface CollectInterestEvent {
   user: web3.PublicKey
   vault: web3.PublicKey
@@ -413,6 +517,23 @@ export interface CollectInterestEvent {
   unix_timestamp: BN
 }
 
+export interface CollectInterestEventV2 {
+  user: web3.PublicKey
+  vault: web3.PublicKey
+  user_yield_position: web3.PublicKey
+  amount_to_user: BN
+  amount_to_treasury: BN
+  unix_timestamp: BN
+  user_interest: {
+    last_seen_index: AnchorizedPNum
+    staged: BN
+  }
+  user_emissions: {
+    last_seen_index: AnchorizedPNum
+    staged: BN
+  }[]
+}
+
 export interface CollectEmissionEvent {
   user: web3.PublicKey
   vault: web3.PublicKey
@@ -423,6 +544,24 @@ export interface CollectEmissionEvent {
   unix_timestamp: BN
 }
 
+export interface CollectEmissionEventV2 {
+  user: web3.PublicKey
+  vault: web3.PublicKey
+  position: web3.PublicKey
+  emission_index: number
+  amount_to_user: BN
+  amount_to_treasury: BN
+  unix_timestamp: BN
+  user_interest: {
+    last_seen_index: AnchorizedPNum
+    staged: BN
+  }
+  user_emissions: {
+    last_seen_index: AnchorizedPNum
+    staged: BN
+  }[]
+}
+
 export interface StageYieldEvent {
   payer: web3.PublicKey
   vault: web3.PublicKey
@@ -435,6 +574,25 @@ export interface StageYieldEvent {
   unix_timestamp: BN
 }
 
+export interface StageYieldEventV2 {
+  payer: web3.PublicKey
+  vault: web3.PublicKey
+  user_yield_position: web3.PublicKey
+  vault_yield_position: web3.PublicKey
+  sy_exchange_rate: AnchorizedPNum
+  user_yt_balance: BN
+  user_staged_yield: BN
+  unix_timestamp: BN
+  user_interest: {
+    last_seen_index: AnchorizedPNum
+    staged: BN
+  }
+  user_emissions: {
+    last_seen_index: AnchorizedPNum
+    staged: BN
+  }[]
+}
+
 export interface InitializeYieldPositionEvent {
   owner: web3.PublicKey
   vault: web3.PublicKey
@@ -454,6 +612,30 @@ export interface WithdrawLpEvent {
   unix_timestamp: BN
 }
 
+export interface WithdrawLpEventV2 {
+  owner: web3.PublicKey
+  market: web3.PublicKey
+  lp_position: web3.PublicKey
+  mint_lp: web3.PublicKey
+  token_lp_dst: web3.PublicKey
+  token_lp_escrow: web3.PublicKey
+  amount: BN
+  new_lp_balance: BN
+  unix_timestamp: BN
+  emissions: {
+    trackers: {
+      last_seen_index: AnchorizedPNum
+      staged: BN
+    }[]
+  }
+  farms: {
+    trackers: {
+      last_seen_index: AnchorizedPNum
+      staged: BN
+    }[]
+  }
+}
+
 export interface WithdrawLiquidityEvent {
   withdrawer: web3.PublicKey
   market: web3.PublicKey
@@ -497,6 +679,29 @@ export interface MarketCollectEmissionEvent {
   timestamp: BN
 }
 
+export interface MarketCollectEmissionEventV2 {
+  owner: web3.PublicKey
+  market: web3.PublicKey
+  lp_position: web3.PublicKey
+  token_emission_escrow: web3.PublicKey
+  token_emission_dst: web3.PublicKey
+  emission_index: number
+  amount_collected: BN
+  timestamp: BN
+  emissions: {
+    trackers: {
+      last_seen_index: AnchorizedPNum
+      staged: BN
+    }[]
+  }
+  farms: {
+    trackers: {
+      last_seen_index: AnchorizedPNum
+      staged: BN
+    }[]
+  }
+}
+
 export interface InitLpPositionEvent {
   fee_payer: web3.PublicKey
   owner: web3.PublicKey
@@ -519,6 +724,30 @@ export interface DepositLpEvent {
   timestamp: BN
 }
 
+export interface DepositLpEventV2 {
+  owner: web3.PublicKey
+  market: web3.PublicKey
+  lp_position: web3.PublicKey
+  token_lp_src: web3.PublicKey
+  token_lp_escrow: web3.PublicKey
+  mint_lp: web3.PublicKey
+  amount: BN
+  new_lp_balance: BN
+  timestamp: BN
+  emissions: {
+    trackers: {
+      last_seen_index: AnchorizedPNum
+      staged: BN
+    }[]
+  }
+  farms: {
+    trackers: {
+      last_seen_index: AnchorizedPNum
+      staged: BN
+    }[]
+  }
+}
+
 export interface DepositLiquidityEvent {
   depositor: web3.PublicKey
   market: web3.PublicKey
@@ -549,6 +778,30 @@ export interface ClaimFarmEmissionsEvent {
   remaining_staged: BN
 }
 
+export interface ClaimFarmEmissionsEventV2 {
+  owner: web3.PublicKey
+  market: web3.PublicKey
+  lp_position: web3.PublicKey
+  token_dst: web3.PublicKey
+  mint: web3.PublicKey
+  token_farm: web3.PublicKey
+  farm_index: number
+  amount_claimed: BN
+  remaining_staged: BN
+  emissions: {
+    trackers: {
+      last_seen_index: AnchorizedPNum
+      staged: BN
+    }[]
+  }
+  farms: {
+    trackers: {
+      last_seen_index: AnchorizedPNum
+      staged: BN
+    }[]
+  }
+}
+
 export interface BuyYtEvent {
   trader: web3.PublicKey
   market: web3.PublicKey

package/src/eventsV2.ts

@@ -0,0 +1,13 @@
+import { IdlTypes } from "@coral-xyz/anchor"
+
+import { ExponentCore, IDL, PROGRAM_ID } from "@exponent-labs/exponent-idl"
+
+import { EventDecoderV2 } from "./EventDecoderV2"
+import { createAnchorProgram } from "./utils"
+
+export const EXPONENT_PROGRAM_ID = PROGRAM_ID
+const EXPONENT_PROGRAM = createAnchorProgram(IDL as ExponentCore)
+export const EXPONENT_EVENT_DECODER = new EventDecoderV2(EXPONENT_PROGRAM)
+
+export type ExponentCoreEventNames = ExponentCore["events"][number]["name"]
+export type ExponentCoreEvent<Name extends ExponentCoreEventNames> = IdlTypes<ExponentCore>[Name]