@exponent-labs/exponent-sdk 0.1.7 → 0.9.0

package/src/exponentVaults/scope-refresh.ts

@@ -0,0 +1,169 @@
+import { Reserve } from "@exponent-labs/kamino-reserve-deserializer"
+import { AccountMeta, Connection, PublicKey, SYSVAR_INSTRUCTIONS_PUBKEY, TransactionInstruction } from "@solana/web3.js"
+
+const SCOPE_PROGRAM_ID = new PublicKey("HFn8GnPADiny6XqUoWE8uRPPxb29ikn4yTuPa9MF2fWJ")
+const U16_MAX = 65535
+
+// Known Scope feed Configuration PDAs keyed by oraclePrices address.
+// Source: @kamino-finance/scope-sdk constants/index.ts
+const SCOPE_CONFIGURATIONS: Record<string, string> = {
+  "3t4JZcueEzTbVP6kLxXrL3VpWx45jDer4eqysweBchNH": "6cMwdbrJ95D7v5655Zsoe7oXmjQJMnagWK8EcdG6qmGM", // klend
+  "3NJYftD5sjVfxSnUdZ1wVML8f3aC6mp1CXCL6L7TnU8C": "AdTiP7QyjUyv6crF4H8z7fxJKU7Z5eCAGvJN1Y55cXxb", // hubble
+}
+
+// Oracle types that cannot be refreshed by the Scope program
+const NON_REFRESHABLE_ORACLE_TYPES = new Set([5, 20]) // Chainlink, PythLazer
+
+// Scope Configuration account layout (after 8-byte discriminator):
+//   offset 8:   admin (32 bytes)
+//   offset 40:  oracleMappings (32 bytes)
+//   offset 72:  oraclePrices (32 bytes)
+//   offset 104: tokensMetadata (32 bytes)
+//   offset 136: oracleTwaps (32 bytes)
+function decodeScopeConfig(data: Buffer) {
+  return {
+    oracleMappings: new PublicKey(data.subarray(40, 72)),
+    oraclePrices: new PublicKey(data.subarray(72, 104)),
+    oracleTwaps: new PublicKey(data.subarray(136, 168)),
+  }
+}
+
+// Scope OracleMappings account layout (after 8-byte discriminator):
+//   offset 8:     priceInfoAccounts[512] (512 * 32 = 16384 bytes)
+//   offset 16392: priceTypes[512] (512 bytes)
+function decodeScopeOracleMappings(data: Buffer) {
+  const priceInfoAccounts: PublicKey[] = []
+  for (let i = 0; i < 512; i++) {
+    const start = 8 + i * 32
+    priceInfoAccounts.push(new PublicKey(data.subarray(start, start + 32)))
+  }
+  const priceTypes: number[] = []
+  for (let i = 0; i < 512; i++) {
+    priceTypes.push(data[16392 + i])
+  }
+  return { priceInfoAccounts, priceTypes }
+}
+
+// refreshPriceList discriminator: [83, 186, 207, 131, 203, 254, 198, 130]
+const REFRESH_PRICE_LIST_DISCRIMINATOR = Buffer.from([83, 186, 207, 131, 203, 254, 198, 130])
+
+function buildRefreshPriceListIx(
+  oraclePrices: PublicKey,
+  oracleMappings: PublicKey,
+  oracleTwaps: PublicKey,
+  tokens: number[],
+  oracleAccounts: AccountMeta[],
+): TransactionInstruction {
+  // Data: 8-byte discriminator + borsh Vec<u16> (4-byte length + N * 2-byte values)
+  const data = Buffer.alloc(8 + 4 + tokens.length * 2)
+  REFRESH_PRICE_LIST_DISCRIMINATOR.copy(data, 0)
+  data.writeUInt32LE(tokens.length, 8)
+  for (let i = 0; i < tokens.length; i++) {
+    data.writeUInt16LE(tokens[i], 12 + i * 2)
+  }
+
+  const keys: AccountMeta[] = [
+    { pubkey: oraclePrices, isSigner: false, isWritable: true },
+    { pubkey: oracleMappings, isSigner: false, isWritable: false },
+    { pubkey: oracleTwaps, isSigner: false, isWritable: true },
+    { pubkey: SYSVAR_INSTRUCTIONS_PUBKEY, isSigner: false, isWritable: false },
+    ...oracleAccounts,
+  ]
+
+  return new TransactionInstruction({
+    programId: SCOPE_PROGRAM_ID,
+    keys,
+    data,
+  })
+}
+
+/**
+ * Build Scope refreshPriceList instructions for all reserves that use Scope oracles.
+ * Should be prepended before refreshReserve instructions so that Scope oracle data
+ * has fresh timestamps when reserves are refreshed.
+ */
+export async function buildScopeRefreshInstructions(
+  connection: Connection,
+  reserves: { account: Reserve }[],
+): Promise<TransactionInstruction[]> {
+  const defaultKey = PublicKey.default
+
+  // 1. Group token IDs by Scope feed (oraclePrices address)
+  const feedTokens = new Map<string, Set<number>>()
+  for (const { account } of reserves) {
+    const scopeConfig = account.config.tokenInfo.scopeConfiguration
+    if (scopeConfig.priceFeed.equals(defaultKey)) continue
+
+    const feedKey = scopeConfig.priceFeed.toBase58()
+    if (!feedTokens.has(feedKey)) feedTokens.set(feedKey, new Set())
+    const tokens = feedTokens.get(feedKey)!
+
+    for (const tokenId of scopeConfig.priceChain) {
+      if (tokenId !== U16_MAX) tokens.add(tokenId)
+    }
+    for (const tokenId of scopeConfig.twapChain) {
+      if (tokenId !== U16_MAX) tokens.add(tokenId)
+    }
+  }
+
+  if (feedTokens.size === 0) return []
+
+  // 2. For each feed, fetch Scope accounts and build the instruction
+  const instructions: TransactionInstruction[] = []
+  for (const [oraclePricesKey, tokenIds] of feedTokens) {
+    const oraclePrices = new PublicKey(oraclePricesKey)
+
+    // Look up the Scope Configuration PDA for this feed
+    const configPdaStr = SCOPE_CONFIGURATIONS[oraclePricesKey]
+    if (!configPdaStr) {
+      console.warn(`Unknown Scope feed: ${oraclePricesKey}, skipping refresh`)
+      continue
+    }
+    const configPda = new PublicKey(configPdaStr)
+
+    // Fetch Configuration account to get oracleMappings and oracleTwaps
+    const configInfo = await connection.getAccountInfo(configPda)
+    if (!configInfo) {
+      console.warn(`Scope Configuration not found: ${configPdaStr}`)
+      continue
+    }
+    const config = decodeScopeConfig(configInfo.data as Buffer)
+
+    // Fetch OracleMappings to get per-token oracle accounts
+    const mappingsInfo = await connection.getAccountInfo(config.oracleMappings)
+    if (!mappingsInfo) {
+      console.warn(`Scope OracleMappings not found: ${config.oracleMappings.toBase58()}`)
+      continue
+    }
+    const mappings = decodeScopeOracleMappings(mappingsInfo.data as Buffer)
+
+    // Filter out non-refreshable oracle types and build remaining accounts
+    const sortedTokens = [...tokenIds].sort((a, b) => a - b)
+    const refreshableTokens: number[] = []
+    const oracleAccounts: AccountMeta[] = []
+
+    for (const tokenId of sortedTokens) {
+      if (NON_REFRESHABLE_ORACLE_TYPES.has(mappings.priceTypes[tokenId])) continue
+      refreshableTokens.push(tokenId)
+      oracleAccounts.push({
+        pubkey: mappings.priceInfoAccounts[tokenId],
+        isSigner: false,
+        isWritable: false,
+      })
+    }
+
+    if (refreshableTokens.length === 0) continue
+
+    instructions.push(
+      buildRefreshPriceListIx(
+        oraclePrices,
+        config.oracleMappings,
+        config.oracleTwaps,
+        refreshableTokens,
+        oracleAccounts,
+      ),
+    )
+  }
+
+  return instructions
+}

package/src/exponentVaults/squadsVaultTxnResolver/constants.ts

@@ -0,0 +1,59 @@
+import { InteractionType } from "./types"
+
+/* eslint-disable camelcase */
+export const ACTION_DISPLAY_NAMES: Record<InteractionType, string> = {
+  swap_exact_sy_for_pt: "Buy PT",
+  swap_exact_pt_for_sy: "Sell PT",
+  swap_exact_sy_for_yt: "Buy YT",
+  swap_exact_yt_for_sy: "Sell YT",
+  wrapper_post_offer: "Post Limit Order",
+  raw_post_offer: "Post Offer",
+  raw_market_offer: "Market Offer",
+  wrapper_remove_offer: "Remove Offer",
+  wrapper_withdraw_funds: "Withdraw Filled Orders",
+  initialize_yield_position: "Initialize Yield Position",
+  wrapper_strip: "Strip",
+  wrapper_merge: "Merge",
+  mint_sy: "Mint SY",
+  redeem_sy: "Redeem SY",
+  lending_account_deposit: "Deposit",
+  lending_account_withdraw: "Withdraw",
+  lending_account_borrow: "Borrow",
+  lending_account_repay: "Repay",
+  init_user_metadata: "Init User Metadata",
+  deposit_reserve_liquidity: "Deposit Reserve Liquidity",
+  init_obligation: "Init Obligation",
+  init_obligation_farms_for_reserve: "Init Obligation Farms",
+  refresh_reserve: "Refresh Reserve",
+  refresh_obligation: "Refresh Obligation",
+  swap_route_v2: "Swap",
+  collect_interest: "Collect Interest",
+  wrapper_collect_interest: "Collect Interest",
+  deposit_yt: "Deposit YT",
+  withdraw_yt: "Withdraw YT",
+  // CLMM
+  deposit_liquidity: "Deposit Liquidity",
+  add_liquidity: "Add Liquidity",
+  withdraw_liquidity: "Withdraw Liquidity",
+  trade_pt: "Trade PT",
+  trade_pt_exact_out: "Trade PT (Exact Out)",
+  buy_yt: "Buy YT",
+  sell_yt: "Sell YT",
+  claim_farm_emission: "Claim Rewards",
+  // Loopscale
+  create_loan: "Create Loan",
+  deposit_collateral: "Deposit Collateral",
+  borrow_principal: "Borrow",
+  repay_principal: "Repay",
+  withdraw_collateral: "Withdraw Collateral",
+  close_loan: "Close Loan",
+  create_strategy: "Create Strategy",
+  deposit_strategy: "Deposit",
+  withdraw_strategy: "Withdraw",
+  close_strategy: "Close Strategy",
+  update_weight_matrix: "Update Weight Matrix",
+  lock_loan: "Lock Loan",
+  unlock_loan: "Unlock Loan",
+  update_strategy: "Update Strategy",
+  refinance_ledger: "Refinance",
+}

package/src/exponentVaults/squadsVaultTxnResolver/helpers.ts

@@ -0,0 +1,355 @@
+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

@@ -0,0 +1,16 @@
+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"