@exponent-labs/exponent-sdk 0.9.1 → 0.9.3

package/src/exponentVaults/squadsVaultTxnResolver/resolvers/loopscale.ts

@@ -1,94 +0,0 @@
-import { LOOPSCALE_ACCOUNT_INDICES } from "../../policyBuilders"
-import {
-  DefiInteraction,
-  INTERACTION_TYPES,
-  InteractionType,
-  ProtocolInteraction,
-  ResolveInteractionParams,
-} from "../types"
-import { convertToDefiInteraction } from "./helpers"
-
-const LOOPSCALE_INTERACTION_TYPES = new Set<InteractionType>([
-  // Loan actions
-  INTERACTION_TYPES.CREATE_LOAN,
-  INTERACTION_TYPES.DEPOSIT_COLLATERAL,
-  INTERACTION_TYPES.BORROW_PRINCIPAL,
-  INTERACTION_TYPES.REPAY_PRINCIPAL,
-  INTERACTION_TYPES.WITHDRAW_COLLATERAL,
-  INTERACTION_TYPES.CLOSE_LOAN,
-  INTERACTION_TYPES.UPDATE_WEIGHT_MATRIX,
-  INTERACTION_TYPES.LOCK_LOAN,
-  INTERACTION_TYPES.UNLOCK_LOAN,
-  INTERACTION_TYPES.REFINANCE_LEDGER,
-  // Strategy actions
-  INTERACTION_TYPES.CREATE_STRATEGY,
-  INTERACTION_TYPES.DEPOSIT_STRATEGY,
-  INTERACTION_TYPES.WITHDRAW_STRATEGY,
-  INTERACTION_TYPES.CLOSE_STRATEGY,
-  INTERACTION_TYPES.UPDATE_STRATEGY,
-])
-
-export function resolveLoopscaleProtocolInteraction(
-  interaction: ProtocolInteraction,
-  params?: ResolveInteractionParams,
-): DefiInteraction | null {
-  if (!LOOPSCALE_INTERACTION_TYPES.has(interaction.type)) {
-    console.warn(
-      `Invalid interaction type. Expected Loopscale interaction, got: ${interaction.type}. Txn: ${interaction.txnSignature}`,
-    )
-    return null
-  }
-
-  const { accounts, balanceChanges, type } = interaction
-
-  const allBalanceChanges = interaction?.balanceChanges || []
-
-  const ownerScopedBalanceChanges = params?.squadsVaultAddress
-    ? balanceChanges.filter((bc) => bc.owner === params.squadsVaultAddress)
-    : balanceChanges
-
-  if (type === INTERACTION_TYPES.DEPOSIT_COLLATERAL) {
-    const tokenMint = accounts[LOOPSCALE_ACCOUNT_INDICES.depositCollateralMint] ?? null
-    const tokenChange = tokenMint
-      ? (ownerScopedBalanceChanges.find((bc) => bc.mint === tokenMint && BigInt(bc.change) < 0n) ?? null)
-      : null
-    return convertToDefiInteraction(interaction, tokenMint, tokenChange)
-  }
-
-  if (type === INTERACTION_TYPES.BORROW_PRINCIPAL) {
-    const tokenMint = accounts[LOOPSCALE_ACCOUNT_INDICES.borrowPrincipalMint] ?? null
-    const tokenChange = allBalanceChanges.find((bc) => bc.mint === tokenMint && BigInt(bc.change) < 0n) ?? null
-
-    return convertToDefiInteraction(interaction, tokenMint, tokenChange)
-  }
-
-  if (type === INTERACTION_TYPES.REPAY_PRINCIPAL) {
-    const tokenMint = accounts[LOOPSCALE_ACCOUNT_INDICES.repayPrincipalMint]
-    const tokenChange = allBalanceChanges.find((bc) => bc.mint === tokenMint && BigInt(bc.change) > 0n) ?? null
-
-    return convertToDefiInteraction(interaction, tokenMint, tokenChange)
-  }
-
-  if (type === INTERACTION_TYPES.WITHDRAW_COLLATERAL) {
-    const tokenMint = accounts[LOOPSCALE_ACCOUNT_INDICES.withdrawCollateralMint]
-    const tokenChange = allBalanceChanges.find((bc) => bc.mint === tokenMint && BigInt(bc.change) > 0n) ?? null
-    return convertToDefiInteraction(interaction, tokenMint, tokenChange)
-  }
-
-  if (type === INTERACTION_TYPES.DEPOSIT_STRATEGY) {
-    const tokenMint = accounts[LOOPSCALE_ACCOUNT_INDICES.depositStrategyMint]
-    const tokenChange = allBalanceChanges.find((bc) => bc.mint === tokenMint && BigInt(bc.change) > 0n) ?? null
-
-    return convertToDefiInteraction(interaction, tokenMint, tokenChange)
-  }
-
-  if (type === INTERACTION_TYPES.WITHDRAW_STRATEGY) {
-    const tokenMint = accounts[LOOPSCALE_ACCOUNT_INDICES.withdrawStrategyMint]
-    const tokenChange = allBalanceChanges.find((bc) => bc.mint === tokenMint && BigInt(bc.change) < 0n) ?? null
-    return convertToDefiInteraction(interaction, tokenMint, tokenChange)
-  }
-
-  // Admin/setup actions: createLoan, closeLoan, createStrategy, closeStrategy,
-  // updateWeightMatrix, lockLoan, unlockLoan, updateStrategy, refinanceLedger
-  return convertToDefiInteraction(interaction, null, null)
-}

package/src/exponentVaults/squadsVaultTxnResolver/resolvers/titan.ts

@@ -1,41 +0,0 @@
-import { TITAN_ACCOUNT_INDICES } from "../../policyBuilders"
-import { ACTION_DISPLAY_NAMES } from "../constants"
-import { DefiInteraction, INTERACTION_TYPES, ProtocolInteraction, ResolveInteractionParams } from "../types"
-
-export function resolveTitanProtocolInteraction(
-  interaction: ProtocolInteraction,
-  params?: ResolveInteractionParams,
-): DefiInteraction {
-  if (interaction.type !== INTERACTION_TYPES.SWAP_ROUTE_V2)
-    throw new Error(`Invalid interaction type. Expected: ${interaction.type}`)
-
-  const { /*ixDataBase58,*/ balanceChanges, accounts, protocolName, protocolProgram, txnSignature, timestamp } =
-    interaction
-
-  // const dataBytes = bs58.decode(ixDataBase58)
-
-  // const inputMint = accounts[TITAN_ACCOUNT_INDICES.inputMint] ?? null
-  const outputMint = accounts[TITAN_ACCOUNT_INDICES.outputMint] ?? null
-
-  // let inputAmount: string | null = null
-  // if (dataBytes.length >= 16) {
-  //   inputAmount = Buffer.from(dataBytes.subarray(8, 16)).readBigUInt64LE(0).toString()
-  // }
-
-  const outputChange = outputMint && params?.squadsVaultAddress
-    ? balanceChanges.find((b) => b.owner === params.squadsVaultAddress && b.mint === outputMint)
-    : null
-
-  return {
-    protocolName,
-    protocolProgram,
-    typeHuman: ACTION_DISPLAY_NAMES[interaction.type],
-    type: interaction.type,
-    token: {
-      mint: outputMint,
-      amount: outputChange?.change?.toString() || null,
-    },
-    txnSignature,
-    timestamp,
-  }
-}

package/src/exponentVaults/squadsVaultTxnResolver/squadsVaultTxnResolver.ts

@@ -1,91 +0,0 @@
-import type { VersionedTransactionResponse } from "@solana/web3.js"
-
-import {
-  ejectDecompiledIxnsFromVersionedTx,
-  filterInteractionsWithTopLevel,
-  getMessageAccountKeysFromVersionedTxn,
-  getTxnTokensBalancesChanges,
-  resolveInteractionType,
-} from "./helpers"
-import { RESOLVER_BY_PROGRAM_ID } from "./resolvers"
-import type {
-  DecompiledInstructionWithInner,
-  DefiInteraction,
-  ProtocolInteraction,
-  ResolveInteractionParams,
-  TokenBalanceChange,
-} from "./types"
-
-type DecompiledParams = {
-  instructions: DecompiledInstructionWithInner[]
-  balanceChanges: TokenBalanceChange[]
-  txnSignature: string
-  timestamp: number
-}
-
-export class SquadsVaultTxnResolver {
-  getProtocolInteractions(tx: VersionedTransactionResponse): ProtocolInteraction[]
-  getProtocolInteractions(params: DecompiledParams): ProtocolInteraction[]
-  getProtocolInteractions(txOrParams: VersionedTransactionResponse | DecompiledParams): ProtocolInteraction[] {
-    let topLevelInstructions: DecompiledInstructionWithInner[]
-    let balanceChanges: TokenBalanceChange[]
-    let txnSignature: string
-    let timestamp: number
-
-    if ("instructions" in txOrParams) {
-      topLevelInstructions = txOrParams.instructions
-      balanceChanges = txOrParams.balanceChanges
-      txnSignature = txOrParams.txnSignature
-      timestamp = txOrParams.timestamp
-    } else {
-      topLevelInstructions = ejectDecompiledIxnsFromVersionedTx(txOrParams)
-      const accountKeys = getMessageAccountKeysFromVersionedTxn(txOrParams)
-      balanceChanges = getTxnTokensBalancesChanges(txOrParams, accountKeys)
-      txnSignature = txOrParams.transaction.signatures[0] ?? ""
-      timestamp = txOrParams.blockTime ?? 0
-    }
-
-    const allInstructions = topLevelInstructions.flatMap((ix) => [ix, ...(ix.innerInstructions ?? [])])
-
-    const interactions: ProtocolInteraction[] = []
-
-    for (const instruction of allInstructions) {
-      const resolved = resolveInteractionType(instruction.programId, instruction.data)
-      if (!resolved) continue
-
-      interactions.push({
-        type: resolved.type,
-        protocolName: resolved.protocolName,
-        protocolProgram: instruction.programId,
-        ixDataBase58: instruction.data,
-        accounts: instruction.accounts,
-        balanceChanges,
-        txnSignature,
-        timestamp,
-      })
-    }
-
-    return interactions
-  }
-
-  resolveInteraction(interaction: ProtocolInteraction, params?: ResolveInteractionParams): DefiInteraction | null {
-    const resolver = RESOLVER_BY_PROGRAM_ID.get(interaction.protocolProgram)
-    if (!resolver) return null
-
-    return resolver(interaction, params)
-  }
-
-  /**
-   * When a single Squads vault transaction contains multiple protocol interactions
-   * (e.g. Loopscale createStrategy + deposit, or Exponent depositYt + postOffer),
-   * the caller currently gets all of them back. This batch method automatically
-   * keeps only the "top-level" interaction per transaction when one exists.
-   */
-  resolveInteractions(interactions: ProtocolInteraction[], params?: ResolveInteractionParams): DefiInteraction[] {
-    const resolved = interactions
-      .map((i) => this.resolveInteraction(i, params))
-      .filter((r): r is DefiInteraction => r !== null)
-
-    return filterInteractionsWithTopLevel(resolved)
-  }
-}

package/src/exponentVaults/squadsVaultTxnResolver/types.ts

@@ -1,171 +0,0 @@
-export type TokenBalanceChange = {
-  account: string
-  owner: string
-  mint: string
-  change: string
-}
-
-export type DecompiledInstruction = {
-  programId: string
-  accounts: string[]
-  data: string // base58-encoded
-}
-
-export type DecompiledInstructionWithInner = DecompiledInstruction & {
-  innerInstructions?: DecompiledInstruction[]
-}
-
-// ---------------------------------------------------------------------------
-// Constants for type-safe equality checks at upper level
-// ---------------------------------------------------------------------------
-
-export const INTERACTION_TYPES = {
-  // Exponent Orderbook
-  SWAP_EXACT_SY_FOR_PT: "swap_exact_sy_for_pt",
-  SWAP_EXACT_PT_FOR_SY: "swap_exact_pt_for_sy",
-  SWAP_EXACT_SY_FOR_YT: "swap_exact_sy_for_yt",
-  SWAP_EXACT_YT_FOR_SY: "swap_exact_yt_for_sy",
-  WRAPPER_POST_OFFER: "wrapper_post_offer",
-  RAW_POST_OFFER: "raw_post_offer",
-  RAW_MARKET_OFFER: "raw_market_offer",
-  WRAPPER_REMOVE_OFFER: "wrapper_remove_offer",
-  WRAPPER_WITHDRAW_FUNDS: "wrapper_withdraw_funds",
-  // Exponent Core
-  INITIALIZE_YIELD_POSITION: "initialize_yield_position",
-  WRAPPER_STRIP: "wrapper_strip",
-  WRAPPER_MERGE: "wrapper_merge",
-  COLLECT_INTEREST: "collect_interest",
-  WRAPPER_COLLECT_INTEREST: "wrapper_collect_interest",
-  DEPOSIT_YT: "deposit_yt",
-  WITHDRAW_YT: "withdraw_yt",
-  // Exponent Standard
-  MINT_SY: "mint_sy",
-  REDEEM_SY: "redeem_sy",
-  // 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_farm_emission",
-  // Kamino
-  LENDING_ACCOUNT_DEPOSIT: "lending_account_deposit",
-  LENDING_ACCOUNT_WITHDRAW: "lending_account_withdraw",
-  LENDING_ACCOUNT_BORROW: "lending_account_borrow",
-  LENDING_ACCOUNT_REPAY: "lending_account_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_for_reserve",
-  REFRESH_RESERVE: "refresh_reserve",
-  REFRESH_OBLIGATION: "refresh_obligation",
-  // Titan
-  SWAP_ROUTE_V2: "swap_route_v2",
-  // Loopscale
-  CREATE_LOAN: "create_loan",
-  DEPOSIT_COLLATERAL: "deposit_collateral",
-  BORROW_PRINCIPAL: "borrow_principal",
-  REPAY_PRINCIPAL: "repay_principal",
-  WITHDRAW_COLLATERAL: "withdraw_collateral",
-  CLOSE_LOAN: "close_loan",
-  CREATE_STRATEGY: "create_strategy",
-  DEPOSIT_STRATEGY: "deposit_strategy",
-  WITHDRAW_STRATEGY: "withdraw_strategy",
-  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_ledger",
-} as const
-
-export type InteractionType = (typeof INTERACTION_TYPES)[keyof typeof INTERACTION_TYPES]
-
-export const TOP_LEVEL_INTERACTIONS: InteractionType[] = [
-  // Exponent Orderbook
-  INTERACTION_TYPES.WRAPPER_POST_OFFER,
-  INTERACTION_TYPES.WRAPPER_REMOVE_OFFER,
-  INTERACTION_TYPES.RAW_POST_OFFER,
-  INTERACTION_TYPES.RAW_MARKET_OFFER,
-  INTERACTION_TYPES.WRAPPER_WITHDRAW_FUNDS,
-  // CLMM
-  INTERACTION_TYPES.TRADE_PT,
-  INTERACTION_TYPES.TRADE_PT_EXACT_OUT,
-  // Kamino
-  INTERACTION_TYPES.LENDING_ACCOUNT_BORROW,
-  INTERACTION_TYPES.LENDING_ACCOUNT_DEPOSIT,
-  // Loopscale
-  INTERACTION_TYPES.CREATE_STRATEGY,
-  INTERACTION_TYPES.DEPOSIT_COLLATERAL,
-  INTERACTION_TYPES.WITHDRAW_COLLATERAL,
-]
-
-export const PROTOCOLS = {
-  EXPONENT: "Exponent",
-  KAMINO: "Kamino",
-  TITAN: "Titan",
-  LOOPSCALE: "Loopscale",
-} as const
-
-// ---------------------------------------------------------------------------
-// Result types
-// ---------------------------------------------------------------------------
-
-export type ProtocolInteraction = {
-  type: InteractionType
-  protocolName: string
-  protocolProgram: string
-  ixDataBase58: string
-  accounts: string[]
-  balanceChanges: TokenBalanceChange[]
-  txnSignature: string
-  timestamp: number
-}
-
-// type DefiInteraction = {
-//   timestamp: number
-//   txnSignature: string
-//   type: string
-//   inputMint: string | null
-//   outputMint: string | null
-//   inputAmount: string | null
-//   outputAmount: string | null
-//   protocol: string
-//   balanceChanges: TokenBalanceChange[]
-// }
-
-export type DefiInteractionToken = {
-  mint: string
-  amount: string
-}
-
-export type ExponentVaultTokens = {
-  ptMint: string
-  ytMint: string
-  syMint: string
-  underlyingMint: string
-}
-
-export type ExponentTokensMap = Map<string, ExponentVaultTokens>
-
-export type ResolveInteractionParams = {
-  squadsVaultAddress?: string
-  exponentTokensMap?: ExponentTokensMap
-}
-
-export type DefiInteraction = {
-  typeHuman: string
-  type: InteractionType
-  protocolName: string
-  protocolProgram: string
-  token: DefiInteractionToken | null
-  txnSignature: string
-  timestamp: number
-}
-
-export type ProtocolResolver = (
-  interaction: ProtocolInteraction,
-  params?: ResolveInteractionParams,
-) => DefiInteraction | null

package/src/exponentVaults/squadsVaultTxnResolver/utils.ts

@@ -1,3 +0,0 @@
-export function toHex(data: Uint8Array | Buffer) {
-  return Buffer.from(data).toString("hex")
-}