@exponent-labs/exponent-sdk 0.9.1 → 0.9.3

package/src/exponentVaults/squadsVaultTxnResolver/helpers.ts

@@ -1,355 +0,0 @@
-import {
-  CompiledInnerInstruction,
-  CompiledInstruction,
-  MessageAccountKeys,
-  PublicKey,
-  VersionedTransactionResponse,
-} from "@solana/web3.js"
-import bs58 from "bs58"
-
-import {
-  CLMM_DISCRIMINATORS,
-  EXPONENT_CLMM_PROGRAM_ID,
-  EXPONENT_CORE_DISCRIMINATORS,
-  EXPONENT_CORE_PROGRAM_ID,
-  EXPONENT_ORDERBOOK_PROGRAM_ID,
-  GENERIC_STANDARD_PROGRAM_ID,
-  JITO_RESTAKING_STANDARD_PROGRAM_ID,
-  KAMINO_DISCRIMINATORS,
-  KAMINO_LENDING_PROGRAM_ID,
-  KAMINO_STANDARD_PROGRAM_ID,
-  LOOPSCALE_DISCRIMINATORS,
-  LOOPSCALE_PROGRAM_ID,
-  MARGINFI_STANDARD_PROGRAM_ID,
-  ORDERBOOK_DISCRIMINATORS,
-  PERENA_STANDARD_PROGRAM_ID,
-  STANDARD_PROGRAM_DISCRIMINATORS,
-  TITAN_DISCRIMINATORS,
-  TITAN_PROGRAM_ID,
-} from "../policyBuilders"
-import {
-  DecompiledInstruction,
-  DecompiledInstructionWithInner,
-  DefiInteraction,
-  INTERACTION_TYPES,
-  InteractionType,
-  PROTOCOLS,
-  TOP_LEVEL_INTERACTIONS,
-  TokenBalanceChange,
-} from "./types"
-import { toHex } from "./utils"
-
-export function decompileInstructions(
-  accountKeys: MessageAccountKeys,
-  instructions: CompiledInstruction[],
-  innerInstructions: CompiledInnerInstruction[] = [],
-): DecompiledInstructionWithInner[] {
-  const decompileIxn = (ixn: CompiledInstruction): DecompiledInstruction => ({
-    programId: accountKeys.get(ixn.programIdIndex)!.toBase58(),
-    accounts: ixn.accounts.map((index) => accountKeys.get(index)!.toBase58()),
-    data: ixn.data,
-  })
-
-  return instructions.map((ixn, idx) => {
-    const innerIxn = innerInstructions.find((inner) => inner.index === idx)
-    return {
-      ...decompileIxn(ixn),
-      innerInstructions: innerIxn ? innerIxn.instructions.map(decompileIxn) : undefined,
-    }
-  })
-}
-
-export function getMessageAccountKeysFromVersionedTxn(response: VersionedTransactionResponse): MessageAccountKeys {
-  const loadedWritableAddresses = response?.meta?.loadedAddresses?.writable.map((a) => new PublicKey(a)) ?? []
-  const loadedReadonlyAddresses = response?.meta?.loadedAddresses?.readonly.map((a) => new PublicKey(a)) ?? []
-  const staticAccounts = response?.transaction?.message?.staticAccountKeys.map((a) => new PublicKey(a)) ?? []
-
-  return new MessageAccountKeys(staticAccounts, {
-    writable: loadedWritableAddresses,
-    readonly: loadedReadonlyAddresses,
-  })
-}
-
-export function ejectDecompiledIxnsFromVersionedTx(tx: VersionedTransactionResponse): DecompiledInstructionWithInner[] {
-  const accountKeys = getMessageAccountKeysFromVersionedTxn(tx)
-
-  const messageInstructions = tx?.transaction?.message?.compiledInstructions ?? []
-  const instructions: CompiledInstruction[] = messageInstructions.map((ix) => ({
-    programIdIndex: ix.programIdIndex,
-    accounts: Array.from(ix.accountKeyIndexes),
-    data: bs58.encode(ix.data),
-  }))
-
-  const innerInstructions = tx?.meta?.innerInstructions ?? []
-
-  return decompileInstructions(accountKeys, instructions, innerInstructions)
-}
-
-type TokenBalanceInput = {
-  accountIndex: number
-  mint: string
-  owner?: string
-  uiTokenAmount?: { amount: string }
-}
-
-type TxnWithTokenBalances = {
-  meta?: {
-    preTokenBalances?: TokenBalanceInput[] | null
-    postTokenBalances?: TokenBalanceInput[] | null
-  } | null
-}
-
-export function getTxnTokensBalancesChanges(
-  tx: TxnWithTokenBalances,
-  accountKeys: MessageAccountKeys,
-): TokenBalanceChange[] {
-  const pre = tx.meta?.preTokenBalances ?? []
-  const post = tx.meta?.postTokenBalances ?? []
-
-  const balanceChanges: TokenBalanceChange[] = []
-
-  for (const postBal of post) {
-    const owner = postBal.owner
-    const mint = postBal.mint
-    if (!owner || !mint) continue
-
-    const postAmount = BigInt(postBal.uiTokenAmount?.amount ?? "0")
-    const preBal = pre.find((p) => p.accountIndex === postBal.accountIndex)
-    const preAmount = preBal ? BigInt(preBal.uiTokenAmount?.amount ?? "0") : 0n
-
-    const change = postAmount - preAmount
-    if (change !== 0n) {
-      const account = accountKeys.get(postBal.accountIndex)?.toBase58() ?? ""
-      balanceChanges.push({ account, owner, mint, change: change.toString() })
-    }
-  }
-
-  return balanceChanges
-}
-
-// ---------------------------------------------------------------------------
-// Program ID constants
-// ---------------------------------------------------------------------------
-
-const EXPONENT_ORDERBOOK_PROGRAM = EXPONENT_ORDERBOOK_PROGRAM_ID.toBase58()
-const EXPONENT_CORE_PROGRAM = EXPONENT_CORE_PROGRAM_ID.toBase58()
-const EXPONENT_CLMM_PROGRAM = EXPONENT_CLMM_PROGRAM_ID.toBase58()
-const KAMINO_LENDING_PROGRAM = KAMINO_LENDING_PROGRAM_ID.toBase58()
-const TITAN_PROGRAM = TITAN_PROGRAM_ID.toBase58()
-const LOOPSCALE_PROGRAM = LOOPSCALE_PROGRAM_ID.toBase58()
-
-const STANDARD_PROGRAM_IDS = new Set([
-  MARGINFI_STANDARD_PROGRAM_ID.toBase58(),
-  KAMINO_STANDARD_PROGRAM_ID.toBase58(),
-  JITO_RESTAKING_STANDARD_PROGRAM_ID.toBase58(),
-  PERENA_STANDARD_PROGRAM_ID.toBase58(),
-  GENERIC_STANDARD_PROGRAM_ID.toBase58(),
-])
-
-// ---------------------------------------------------------------------------
-// Discriminator maps
-// ---------------------------------------------------------------------------
-
-const WRAPPER_MARKET_OFFER_DISC = toHex(ORDERBOOK_DISCRIMINATORS.wrapperMarketOffer)
-
-const ORDERBOOK_ACTION_IDS_BY_DISCRIMINATOR: Record<string, InteractionType> = {
-  [toHex(ORDERBOOK_DISCRIMINATORS.wrapperPostOffer)]: INTERACTION_TYPES.WRAPPER_POST_OFFER,
-  [toHex(ORDERBOOK_DISCRIMINATORS.rawPostOffer)]: INTERACTION_TYPES.RAW_POST_OFFER,
-  [toHex(ORDERBOOK_DISCRIMINATORS.rawMarketOffer)]: INTERACTION_TYPES.RAW_MARKET_OFFER,
-  [toHex(ORDERBOOK_DISCRIMINATORS.wrapperRemoveOffer)]: INTERACTION_TYPES.WRAPPER_REMOVE_OFFER,
-  [toHex(ORDERBOOK_DISCRIMINATORS.wrapperWithdrawFunds)]: INTERACTION_TYPES.WRAPPER_WITHDRAW_FUNDS,
-}
-
-const EXPONENT_CORE_ACTION_BY_DISCRIMINATOR: Record<string, InteractionType> = {
-  [toHex(EXPONENT_CORE_DISCRIMINATORS.initializeYieldPosition)]: INTERACTION_TYPES.INITIALIZE_YIELD_POSITION,
-  [toHex(EXPONENT_CORE_DISCRIMINATORS.wrapperStrip)]: INTERACTION_TYPES.WRAPPER_STRIP,
-  [toHex(EXPONENT_CORE_DISCRIMINATORS.wrapperMerge)]: INTERACTION_TYPES.WRAPPER_MERGE,
-  [toHex(EXPONENT_CORE_DISCRIMINATORS.collectInterest)]: INTERACTION_TYPES.COLLECT_INTEREST,
-  [toHex(EXPONENT_CORE_DISCRIMINATORS.wrapperCollectInterest)]: INTERACTION_TYPES.WRAPPER_COLLECT_INTEREST,
-  [toHex(EXPONENT_CORE_DISCRIMINATORS.depositYt)]: INTERACTION_TYPES.DEPOSIT_YT,
-  [toHex(EXPONENT_CORE_DISCRIMINATORS.withdrawYt)]: INTERACTION_TYPES.WITHDRAW_YT,
-}
-
-const STANDARD_PROGRAM_ACTION_BY_DISCRIMINATOR: Record<string, InteractionType> = {
-  [toHex(STANDARD_PROGRAM_DISCRIMINATORS.mint)]: INTERACTION_TYPES.MINT_SY,
-  [toHex(STANDARD_PROGRAM_DISCRIMINATORS.redeem)]: INTERACTION_TYPES.REDEEM_SY,
-}
-
-const KAMINO_ACTION_ID_BY_DISCRIMINATOR: Record<string, InteractionType> = {
-  [toHex(KAMINO_DISCRIMINATORS.initUserMetadata)]: INTERACTION_TYPES.INIT_USER_METADATA,
-  [toHex(KAMINO_DISCRIMINATORS.depositReserveLiquidity)]: INTERACTION_TYPES.DEPOSIT_RESERVE_LIQUIDITY,
-  [toHex(KAMINO_DISCRIMINATORS.depositReserveLiquidityAndObligationCollateral)]:
-    INTERACTION_TYPES.LENDING_ACCOUNT_DEPOSIT,
-  [toHex(KAMINO_DISCRIMINATORS.depositReserveLiquidityAndObligationCollateralV2)]:
-    INTERACTION_TYPES.LENDING_ACCOUNT_DEPOSIT,
-  [toHex(KAMINO_DISCRIMINATORS.withdrawObligationCollateralAndRedeemReserveCollateral)]:
-    INTERACTION_TYPES.LENDING_ACCOUNT_WITHDRAW,
-  [toHex(KAMINO_DISCRIMINATORS.withdrawObligationCollateralAndRedeemReserveCollateralV2)]:
-    INTERACTION_TYPES.LENDING_ACCOUNT_WITHDRAW,
-  [toHex(KAMINO_DISCRIMINATORS.borrowObligationLiquidity)]: INTERACTION_TYPES.LENDING_ACCOUNT_BORROW,
-  [toHex(KAMINO_DISCRIMINATORS.borrowObligationLiquidityV2)]: INTERACTION_TYPES.LENDING_ACCOUNT_BORROW,
-  [toHex(KAMINO_DISCRIMINATORS.repayObligationLiquidity)]: INTERACTION_TYPES.LENDING_ACCOUNT_REPAY,
-  [toHex(KAMINO_DISCRIMINATORS.repayObligationLiquidityV2)]: INTERACTION_TYPES.LENDING_ACCOUNT_REPAY,
-  [toHex(KAMINO_DISCRIMINATORS.initObligation)]: INTERACTION_TYPES.INIT_OBLIGATION,
-  [toHex(KAMINO_DISCRIMINATORS.initObligationFarmsForReserve)]: INTERACTION_TYPES.INIT_OBLIGATION_FARMS_FOR_RESERVE,
-  [toHex(KAMINO_DISCRIMINATORS.refreshReserve)]: INTERACTION_TYPES.REFRESH_RESERVE,
-  [toHex(KAMINO_DISCRIMINATORS.refreshObligation)]: INTERACTION_TYPES.REFRESH_OBLIGATION,
-}
-
-const TITAN_ACTION_ID_BY_DISCRIMINATOR: Record<string, InteractionType> = {
-  [toHex(TITAN_DISCRIMINATORS.swapRouteV2)]: INTERACTION_TYPES.SWAP_ROUTE_V2,
-}
-
-const CLMM_ACTION_ID_BY_DISCRIMINATOR: Record<string, InteractionType> = {
-  [toHex(CLMM_DISCRIMINATORS.depositLiquidity)]: INTERACTION_TYPES.DEPOSIT_LIQUIDITY,
-  [toHex(CLMM_DISCRIMINATORS.addLiquidity)]: INTERACTION_TYPES.ADD_LIQUIDITY,
-  [toHex(CLMM_DISCRIMINATORS.withdrawLiquidity)]: INTERACTION_TYPES.WITHDRAW_LIQUIDITY,
-  [toHex(CLMM_DISCRIMINATORS.tradePt)]: INTERACTION_TYPES.TRADE_PT,
-  [toHex(CLMM_DISCRIMINATORS.tradePtExactOut)]: INTERACTION_TYPES.TRADE_PT_EXACT_OUT,
-  [toHex(CLMM_DISCRIMINATORS.buyYt)]: INTERACTION_TYPES.BUY_YT,
-  [toHex(CLMM_DISCRIMINATORS.sellYt)]: INTERACTION_TYPES.SELL_YT,
-  [toHex(CLMM_DISCRIMINATORS.claimFarmEmission)]: INTERACTION_TYPES.CLAIM_FARM_EMISSION,
-}
-
-const LOOPSCALE_ACTION_ID_BY_DISCRIMINATOR: Record<string, InteractionType> = {
-  [toHex(LOOPSCALE_DISCRIMINATORS.createLoan)]: INTERACTION_TYPES.CREATE_LOAN,
-  [toHex(LOOPSCALE_DISCRIMINATORS.depositCollateral)]: INTERACTION_TYPES.DEPOSIT_COLLATERAL,
-  [toHex(LOOPSCALE_DISCRIMINATORS.borrowPrincipal)]: INTERACTION_TYPES.BORROW_PRINCIPAL,
-  [toHex(LOOPSCALE_DISCRIMINATORS.repayPrincipal)]: INTERACTION_TYPES.REPAY_PRINCIPAL,
-  [toHex(LOOPSCALE_DISCRIMINATORS.withdrawCollateral)]: INTERACTION_TYPES.WITHDRAW_COLLATERAL,
-  [toHex(LOOPSCALE_DISCRIMINATORS.closeLoan)]: INTERACTION_TYPES.CLOSE_LOAN,
-  [toHex(LOOPSCALE_DISCRIMINATORS.createStrategy)]: INTERACTION_TYPES.CREATE_STRATEGY,
-  [toHex(LOOPSCALE_DISCRIMINATORS.depositStrategy)]: INTERACTION_TYPES.DEPOSIT_STRATEGY,
-  [toHex(LOOPSCALE_DISCRIMINATORS.withdrawStrategy)]: INTERACTION_TYPES.WITHDRAW_STRATEGY,
-  [toHex(LOOPSCALE_DISCRIMINATORS.closeStrategy)]: INTERACTION_TYPES.CLOSE_STRATEGY,
-  [toHex(LOOPSCALE_DISCRIMINATORS.updateWeightMatrix)]: INTERACTION_TYPES.UPDATE_WEIGHT_MATRIX,
-  [toHex(LOOPSCALE_DISCRIMINATORS.lockLoan)]: INTERACTION_TYPES.LOCK_LOAN,
-  [toHex(LOOPSCALE_DISCRIMINATORS.unlockLoan)]: INTERACTION_TYPES.UNLOCK_LOAN,
-  [toHex(LOOPSCALE_DISCRIMINATORS.updateStrategy)]: INTERACTION_TYPES.UPDATE_STRATEGY,
-  [toHex(LOOPSCALE_DISCRIMINATORS.refinanceLedger)]: INTERACTION_TYPES.REFINANCE_LEDGER,
-}
-
-// ---------------------------------------------------------------------------
-// Protocol name by program ID
-// ---------------------------------------------------------------------------
-
-const PROTOCOL_NAME_BY_PROGRAM_ID = new Map<string, string>([
-  [EXPONENT_ORDERBOOK_PROGRAM, PROTOCOLS.EXPONENT],
-  [EXPONENT_CORE_PROGRAM, PROTOCOLS.EXPONENT],
-  [EXPONENT_CLMM_PROGRAM, PROTOCOLS.EXPONENT],
-  [KAMINO_LENDING_PROGRAM, PROTOCOLS.KAMINO],
-  [TITAN_PROGRAM, PROTOCOLS.TITAN],
-  [LOOPSCALE_PROGRAM, PROTOCOLS.LOOPSCALE],
-  ...[...STANDARD_PROGRAM_IDS].map((id) => [id, PROTOCOLS.EXPONENT] as [string, string]),
-])
-
-// ---------------------------------------------------------------------------
-// Disambiguate wrapperMarketOffer
-// ---------------------------------------------------------------------------
-
-function disambiguateWrapperMarketOffer(dataBytes: Uint8Array): InteractionType {
-  if (dataBytes.length < 27) {
-    return INTERACTION_TYPES.SWAP_EXACT_SY_FOR_PT
-  }
-  const offerType = dataBytes[25]
-  const virtualOffer = dataBytes[26] !== 0
-  if (virtualOffer) {
-    return offerType === 1 ? INTERACTION_TYPES.SWAP_EXACT_SY_FOR_PT : INTERACTION_TYPES.SWAP_EXACT_PT_FOR_SY
-  }
-  return offerType === 1 ? INTERACTION_TYPES.SWAP_EXACT_SY_FOR_YT : INTERACTION_TYPES.SWAP_EXACT_YT_FOR_SY
-}
-
-// ---------------------------------------------------------------------------
-// Resolve interaction type from programId + instruction data
-// ---------------------------------------------------------------------------
-
-function resolveExponentInteractionType(programId: string, dataBytes: Uint8Array): InteractionType | null {
-  if (programId === EXPONENT_ORDERBOOK_PROGRAM) {
-    const discHex = toHex(dataBytes.subarray(0, 1))
-    if (discHex === WRAPPER_MARKET_OFFER_DISC) return disambiguateWrapperMarketOffer(dataBytes)
-    return ORDERBOOK_ACTION_IDS_BY_DISCRIMINATOR[discHex] ?? null
-  }
-
-  if (programId === EXPONENT_CORE_PROGRAM) {
-    const discHex = toHex(dataBytes.subarray(0, 1))
-    return EXPONENT_CORE_ACTION_BY_DISCRIMINATOR[discHex] ?? null
-  }
-
-  if (STANDARD_PROGRAM_IDS.has(programId)) {
-    const discHex = toHex(dataBytes.subarray(0, 1))
-    return STANDARD_PROGRAM_ACTION_BY_DISCRIMINATOR[discHex] ?? null
-  }
-
-  return null
-}
-
-function resolve8ByteDiscriminator(
-  dataBytes: Uint8Array,
-  map: Record<string, InteractionType>,
-): InteractionType | null {
-  if (dataBytes.length < 8) return null
-  const discHex = toHex(dataBytes.subarray(0, 8))
-  return map[discHex] ?? null
-}
-
-export function filterInteractionsWithTopLevel(interactions: DefiInteraction[]): DefiInteraction[] {
-  const grouped = new Map<string, DefiInteraction[]>()
-
-  for (const interaction of interactions) {
-    const group = grouped.get(interaction.txnSignature)
-    if (group) {
-      group.push(interaction)
-    } else {
-      grouped.set(interaction.txnSignature, [interaction])
-    }
-  }
-
-  const topLevelSet = new Set<string>(TOP_LEVEL_INTERACTIONS)
-  const result: DefiInteraction[] = []
-
-  for (const group of grouped.values()) {
-    const topLevel = group.filter((i) => topLevelSet.has(i.type))
-    if (topLevel.length > 0) {
-      result.push(...topLevel)
-    } else {
-      result.push(...group)
-    }
-  }
-
-  return result
-}
-
-export function resolveInteractionType(
-  programId: string,
-  ixDataBase58: string,
-): { type: InteractionType; protocolName: string } | null {
-  let dataBytes: Uint8Array
-  try {
-    dataBytes = bs58.decode(ixDataBase58)
-  } catch {
-    return null
-  }
-  if (dataBytes.length === 0) return null
-
-  const protocolName = PROTOCOL_NAME_BY_PROGRAM_ID.get(programId)
-  if (!protocolName) return null
-
-  let type: InteractionType | null = null
-
-  if (programId === KAMINO_LENDING_PROGRAM) {
-    type = resolve8ByteDiscriminator(dataBytes, KAMINO_ACTION_ID_BY_DISCRIMINATOR)
-  } else if (programId === TITAN_PROGRAM) {
-    type = resolve8ByteDiscriminator(dataBytes, TITAN_ACTION_ID_BY_DISCRIMINATOR)
-  } else if (programId === LOOPSCALE_PROGRAM) {
-    type = resolve8ByteDiscriminator(dataBytes, LOOPSCALE_ACTION_ID_BY_DISCRIMINATOR)
-  } else if (programId === EXPONENT_CLMM_PROGRAM) {
-    const discHex = toHex(dataBytes.subarray(0, 1))
-    type = CLMM_ACTION_ID_BY_DISCRIMINATOR[discHex] ?? null
-  } else {
-    type = resolveExponentInteractionType(programId, dataBytes)
-  }
-
-  if (!type) return null
-
-  return { type, protocolName }
-}

package/src/exponentVaults/squadsVaultTxnResolver/index.ts

@@ -1,16 +0,0 @@
-export type {
-  ProtocolInteraction,
-  DecompiledInstructionWithInner,
-  DefiInteraction,
-  ProtocolResolver,
-  ResolveInteractionParams,
-  ExponentTokensMap,
-  ExponentVaultTokens,
-  TokenBalanceChange,
-  InteractionType,
-} from "./types"
-export { INTERACTION_TYPES, PROTOCOLS } from "./types"
-export { ACTION_DISPLAY_NAMES } from "./constants"
-export { decompileInstructions, getMessageAccountKeysFromVersionedTxn, getTxnTokensBalancesChanges } from "./helpers"
-
-export { SquadsVaultTxnResolver } from "./squadsVaultTxnResolver"