@exponent-labs/exponent-sdk 0.9.2 → 0.9.3

package/src/vault.ts

@@ -1,1033 +0,0 @@
-import {Connection, PublicKey, SystemProgram, TransactionInstruction} from '@solana/web3.js'
-import {
-  TOKEN_PROGRAM_ID,
-  createAssociatedTokenAccountIdempotentInstruction,
-  getAssociatedTokenAddressSync,
-} from "@solana/spl-token"
-
-import BN  from 'bn.js'
-
-import { EXPONENT_ADMIN_PROGRAM_ID, ExponentAdminPda } from "@exponent-labs/exponent-admin-pda"
-import { ExponentFetcher, deserializeEmission, serializeEmission } from "@exponent-labs/exponent-fetcher"
-import { ExponentPDA } from "@exponent-labs/exponent-pda"
-import {
-  AnchorizedPNum,
-  CpiAccountsRaw,
-  VaultEmission,
-  VaultJson,
-  VaultState,
-  VaultStateJson,
-  deserializeCpiAccountsRaw,
-  serializeCpiAccountsRaw,
-} from "@exponent-labs/exponent-types"
-import { ClaimAmount } from "@exponent-labs/marginfi-sy-sdk"
-
-import { fetchAddressLookupTable, makeCpiAccountMetaLists } from "./addressLookupTableUtil"
-import { Environment } from "./environment"
-import {
-  deserializeFlavorGeneric,
-  deserializeFlavorJitoRestaking,
-  deserializeFlavorKamino,
-  deserializeFlavorMarginfi,
-  deserializeFlavorPerena,
-  makeFlavor,
-  makeFlavorGenericSync,
-  makeFlavorJitoRestakingSync,
-  makeFlavorKaminoSync,
-  makeFlavorMarginfiSync,
-  makeFlavorPerenaSync,
-  serializeFlavorGeneric,
-  serializeFlavorJitoRestaking,
-  serializeFlavorKamino,
-  serializeFlavorMarginfi,
-  serializeFlavorPerena,
-} from "./flavors"
-import { deserializeSyPosition, makeSyPosition, serializeSyPosition } from "./syPosition"
-import { InstructionAccounts, emitEventAuthority, uniqueRemainingAccounts } from "./utils"
-import { extendAddressLookupTable } from "./utils/altUtil"
-import * as exponentCore from "./client/core"
-import {
-  CollectEmissionInstructionAccounts,
-  CollectInterestInstructionAccounts,
-  InitializeYieldPositionInstructionAccounts,
-  MergeInstructionAccounts,
-  ModifyVaultSettingInstructionAccounts,
-  StripInstructionAccounts,
-} from "./client/core"
-
-/** Emission info for SY program */
-interface SyEmission {
-  /** Token account that holds emission tokens */
-  escrowAccountAddress: PublicKey
-
-  /** Mint for the emission token */
-  mint: PublicKey
-
-  /** Token program ID for the emission token */
-  tokenProgramAddress: PublicKey
-
-  /** How many emissions have been claimed by SY holders */
-  totalClaimed: BN
-
-  /** How many emissions have been earned by the SY robot over its lifetime */
-  lastSeenTotalAccruedEmissions: BN
-
-  /** Global index for sharing out rewards to SY holders */
-  index: AnchorizedPNum
-}
-
-interface VaultLoadOptions {
-  syConfig?: {
-    skipWrap?: boolean
-  }
-}
-
-export class Vault {
-  constructor(
-    public state: VaultState,
-    public selfAddress: PublicKey,
-    public env: Environment,
-    public connection: Connection,
-  ) {
-
-  }
-
-  static loadFromJson(vaultJson: VaultJson, address: PublicKey, env: Environment, connection: Connection) {
-    const state = deserializeVaultState(vaultJson.state)
-    return new Vault(state, address, env, connection)
-  }
-
-  static async load(
-    env: Environment,
-    connection: Connection,
-    address: PublicKey,
-    options: VaultLoadOptions = {},
-  ) {
-    const fetcher = new ExponentFetcher({ connection })
-    const vault = await fetcher.fetchVault(address)
-
-    const alt = await fetchAddressLookupTable(connection, vault.addressLookupTable)
-    const cpiAccounts = makeCpiAccountMetaLists(alt, vault.cpiAccounts)
-    const flavor = await makeFlavor(fetcher, env, vault.syProgram, cpiAccounts, options.syConfig)
-
-    const syPosition = await makeSyPosition(fetcher, flavor, vault.syProgram, vault.authority)
-
-    const state: VaultState = {
-      ptSupply: vault.ptSupply,
-      syForPt: vault.syForPt,
-      startTs: vault.startTs,
-      durationSeconds: vault.duration,
-      authority: vault.authority,
-      addressLookupTable: vault.addressLookupTable,
-      lastSeenSyExchangeRate: vault.lastSeenSyExchangeRate,
-      allTimeHighSyExchangeRate: vault.allTimeHighSyExchangeRate,
-      syProgram: vault.syProgram,
-      mintPt: vault.mintPt,
-      mintSy: vault.mintSy,
-      mintYt: vault.mintYt,
-      escrowSy: vault.escrowSy,
-      escrowYt: vault.escrowYt,
-      // Misspelled word
-      yieldPositonAddress: vault.yieldPosition,
-      cpiAccounts,
-      flavor,
-      syPosition,
-      totalSyInEscrow: vault.totalSyInEscrow,
-      treasurySyTokenAccount: vault.treasurySyTokenAccount,
-      interestBpsFee: vault.interestBpsFee,
-      emissions: vault.emissions,
-      minOperationSizeStrip: vault.minOpSizeStrip,
-      minOperationSizeMerge: vault.minOpSizeMerge,
-      status: vault.status,
-      finalSyExchangeRate: vault.finalSyExchangeRate,
-      maxPySupply: vault.maxPySupply,
-    }
-
-    return new Vault(state, address, env, connection)
-  }
-
-  async reload(connection: Connection = this.connection) {
-    const vault = await Vault.load(this.env, connection, this.selfAddress)
-    this.state = vault.state
-    return vault
-  }
-
-  toJson(): VaultJson {
-    return {
-      startTs: this.state.startTs,
-      duration: this.state.durationSeconds,
-      state: serializeVaultState(this.state),
-      authority: this.state.authority.toString(),
-      syBalance: this.syBalance.toString(),
-      addressLookupTable: this.state.addressLookupTable.toString(),
-      lastSeenSyExchangeRate: this.state.lastSeenSyExchangeRate,
-      selfAddress: this.selfAddress.toString(),
-      syProgram: this.state.syProgram.toString(),
-      mintPt: this.state.mintPt.toString(),
-      mintYt: this.state.mintYt.toString(),
-      mintSy: this.state.mintSy.toString(),
-      currentSyExchangeRate: this.state.flavor.currentSyExchangeRate,
-      startDateString: new Date(this.state.startTs * 1000).toISOString(),
-      escrowSy: this.state.escrowSy.toString(),
-      escrowYt: this.state.escrowYt.toString(),
-      treasurySyTokenAccount: this.state.treasurySyTokenAccount.toString(),
-      allTimeHighSyExchangeRate: this.state.allTimeHighSyExchangeRate,
-      finalSyExchangeRate: this.state.finalSyExchangeRate,
-      ptSupply: this.state.ptSupply.toString(),
-      syForPt: this.state.syForPt.toString(),
-      totalSyInEscrow: this.state.totalSyInEscrow.toString(),
-      cpiAccounts: serializeCpiAccountsRaw(this.state.cpiAccounts),
-      status: this.state.status,
-      // Misspelled word
-      syPosition: serializeSyPosition(this.state.syPosition),
-      minOperationSizeStrip: this.state.minOperationSizeStrip.toString(),
-      minOperationSizeMerge: this.state.minOperationSizeMerge.toString(),
-      // Misspelled word
-      yieldPositonAddress: this.state.yieldPositonAddress.toString(),
-      interestFeeBps: this.state.interestBpsFee,
-      flavor: serializeFlavorState(this.state.flavor),
-      emissions: this.state.emissions.map((e) => serializeEmission(e)),
-      maxPySupply: this.state.maxPySupply.toString(),
-    }
-  }
-
-  get pda() {
-    return new ExponentPDA(exponentCore.EXPONENTCORE_PROGRAM_ID)
-  }
-
-  get syBalance(): bigint {
-    return this.state.syPosition.balanceSy
-  }
-
-  get mintSy(): PublicKey {
-    return this.state.mintSy
-  }
-
-  getAdminStatePda() {
-    return new ExponentAdminPda(EXPONENT_ADMIN_PROGRAM_ID).exponentAdmin()
-  }
-
-  get mintPt(): PublicKey {
-    return this.state.mintPt
-  }
-
-  get mintYt(): PublicKey {
-    return this.state.mintYt
-  }
-
-  get flavor() {
-    return this.state.flavor
-  }
-
-  get cpiAccounts() {
-    return this.state.cpiAccounts
-  }
-
-  get authority() {
-    return this.state.authority
-  }
-
-  get escrowSy() {
-    return this.state.escrowSy
-  }
-
-  get addressLookupTable() {
-    return this.state.addressLookupTable
-  }
-
-  get eventAuthority() {
-    return emitEventAuthority(exponentCore.EXPONENTCORE_PROGRAM_ID)
-  }
-
-  /** Emission metadata from SY program */
-  get syEmissions(): SyEmission[] {
-    if (this.flavor.flavor === "marginfi") {
-      return this.flavor.mfiSyState.account.emissions.map((e) => ({
-        escrowAccountAddress: e.escrowAccount,
-        mint: e.mint,
-        tokenProgramAddress: e.tokenProgram,
-        totalClaimed: e.totalClaimedEmissions,
-        lastSeenTotalAccruedEmissions: e.lastSeenTotalAccruedEmissions,
-        index: e.index,
-      }))
-    }
-    if (this.flavor.flavor === "kamino") {
-      return this.flavor.kaminoSyState.account.emissions.map((e) => ({
-        escrowAccountAddress: e.escrowAccount,
-        mint: e.mint,
-        tokenProgramAddress: e.tokenProgram,
-        totalClaimed: e.totalClaimedEmissions,
-        lastSeenTotalAccruedEmissions: e.lastSeenTotalAccruedEmissions,
-        index: e.index,
-      }))
-    }
-    if (this.flavor.flavor === "jitoRestaking") {
-      return this.flavor.jitoSyState.account.emissions.map((e) => ({
-        escrowAccountAddress: e.escrowAccount,
-        mint: e.mint,
-        tokenProgramAddress: e.tokenProgram,
-        totalClaimed: e.totalClaimedEmissions,
-        lastSeenTotalAccruedEmissions: e.lastSeenTotalAccruedEmissions,
-        index: e.index,
-      }))
-    }
-    if (this.flavor.flavor === "perena") {
-      return this.flavor.perenaSyState.account.emissions.map((e) => ({
-        escrowAccountAddress: e.escrowAccount,
-        mint: e.mint,
-        tokenProgramAddress: e.tokenProgram,
-        totalClaimed: e.totalClaimedEmissions,
-        lastSeenTotalAccruedEmissions: e.lastSeenTotalAccruedEmissions,
-        index: e.index,
-      }))
-    }
-    if (this.flavor.flavor === "generic") {
-      return this.flavor.genericSyState.account.emissions.map((e) => ({
-        escrowAccountAddress: e.escrowAccount,
-        mint: e.mint,
-        tokenProgramAddress: e.tokenProgram,
-        totalClaimed: e.totalClaimedEmissions,
-        lastSeenTotalAccruedEmissions: e.lastSeenTotalAccruedEmissions,
-        index: e.index,
-      }))
-    }
-    throw new Error("Unknown flavor")
-  }
-
-  /** Emissions from the vault */
-  get vaultEmissions(): VaultEmission[] {
-    return this.state.emissions
-  }
-
-  /** Get the escrow token account addresses for the emissions, in order */
-  get vaultEmissionTokenAccounts(): PublicKey[] {
-    return this.vaultEmissions.map((e) => e.tokenAccount)
-  }
-
-  get currentSyExchangeRate(): number {
-    return this.flavor.currentSyExchangeRate
-  }
-
-  get escrowYt(): PublicKey {
-    return this.state.escrowYt
-  }
-
-  /** UNIX Timestamp (seconds) at which the vault expires */
-  get expirationTimestamp(): number {
-    return this.state.startTs + this.state.durationSeconds
-  }
-
-  /** Date at which the vault expires */
-  get expirationDate(): Date {
-    return new Date(this.expirationTimestamp * 1000)
-  }
-
-  /** Collect an emission earned with a YT position */
-  ixCollectEmission({
-    owner,
-    emissionIndex,
-    amount,
-    emissionDst,
-  }: {
-    owner: PublicKey
-    emissionIndex: number
-    amount: exponentCore.Amount
-    emissionDst?: PublicKey
-  }) : TransactionInstruction {
-    const accounts = this.collectEmissionAccounts({ emissionIndex, owner, emissionDst })
-    const ix = exponentCore.createCollectEmissionInstruction(
-      accounts.mainAccounts,
-      { index: emissionIndex, amount },
-    )
-    ix.keys.push(...accounts.remainingAccounts)
-    return ix
-  }
-
-  /** Strip SY into PT & YT */
-  ixStrip({
-    syIn,
-    depositor,
-    ptDst,
-    ytDst,
-    sySrc,
-  }: {
-    syIn: bigint
-    depositor: PublicKey
-    ptDst?: PublicKey
-    ytDst?: PublicKey
-    sySrc?: PublicKey
-  }): TransactionInstruction {
-    const { mainAccounts, remainingAccounts } = this.stripAccounts({ depositor, ptDst, ytDst, sySrc })
-    const ix = exponentCore.createStripInstruction(
-      mainAccounts,
-      {amount: syIn},
-    );
-    ix.keys.push(...remainingAccounts);
-    return ix
-  }
-
-  async ixStripFromBase({
-    owner,
-    amountBase,
-    baseSrc: baseSrcParam,
-    sySrc: sySrcParam,
-    ptDst: ptDstParam,
-    ytDst: ytDstParam,
-  }: {
-    owner: PublicKey
-    amountBase: bigint
-    baseSrc?: PublicKey
-    sySrc?: PublicKey
-    ptDst?: PublicKey
-    ytDst?: PublicKey
-  }): Promise<TransactionInstruction> {
-    const baseSrc = baseSrcParam || getAssociatedTokenAddressSync(
-      this.flavor.mintBase,
-      owner,
-      true,
-      this.flavor.baseTokenProgram,
-    )
-    const sySrc = sySrcParam || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
-    const ptDst = ptDstParam || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
-    const ytDst = ytDstParam || getAssociatedTokenAddressSync(this.mintYt, owner, true, TOKEN_PROGRAM_ID)
-
-    const mintSyIx = await this.state.flavor.ixMintSy({
-      amountBase: "0",
-      depositor: owner,
-      depositorBaseTokenAccount: baseSrc,
-      depositorSyTokenAccount: sySrc,
-    })
-
-    const mintSyRemAccounts = mintSyIx.keys
-
-    const remainingAccounts = uniqueRemainingAccounts([...this.cpiAccounts.depositSy])
-
-    const userYieldPosition = this.pda.yieldPosition({ owner, vault: this.selfAddress })
-
-    const ix = exponentCore.createWrapperStripInstruction(
-      {
-        depositor: owner,
-        authority: this.authority,
-        vault: this.selfAddress,
-        mintPt: this.mintPt,
-        mintYt: this.mintYt,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        syProgram: this.state.syProgram,
-        tokenSyDepositor: sySrc,
-        tokenYtDepositor: ytDst,
-        escrowSy: this.escrowSy,
-        tokenPtDepositor: ptDst,
-        systemProgram: SystemProgram.programId,
-        vaultAddressLookupTable: this.addressLookupTable,
-        vaultRobotYieldPosition: this.state.yieldPositonAddress,
-        eventAuthority: this.eventAuthority,
-        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
-        escrowYt: this.escrowYt,
-        userYieldPosition,
-      },
-      { amountBase, mintSyAccountsUntil: mintSyRemAccounts.length },
-    )
-    ix.keys.push(...mintSyRemAccounts.concat(remainingAccounts))
-    return ix
-  }
-
-  async ixMergeToBase({
-    owner,
-    payer = owner,
-    amountPy,
-    ptSrc: ptSrcParam,
-    ytSrc: ytSrcParam,
-    syDst: syDstParam,
-    baseDst,
-  }: {
-    owner: PublicKey
-    payer?: PublicKey
-    amountPy: bigint
-    ptSrc?: PublicKey
-    ytSrc?: PublicKey
-    syDst?: PublicKey
-    baseDst?: PublicKey
-  }): Promise<{ ixs: TransactionInstruction[]; setupIxs: TransactionInstruction[] }> {
-    const syDst = syDstParam || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
-    const ptSrc = ptSrcParam || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
-    const ytSrc = ytSrcParam || getAssociatedTokenAddressSync(this.mintYt, owner, true, TOKEN_PROGRAM_ID)
-
-    const tokenSyTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(payer, syDst, owner, this.mintSy)
-    const tokenPtTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(payer, ptSrc, owner, this.mintPt)
-    const tokenYtTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(payer, ytSrc, owner, this.mintYt)
-
-    const redeemSyIx = await this.state.flavor.ixRedeemSy({
-      amountSy: "0",
-      redeemer: owner,
-      redeemerBaseTokenAccount: baseDst || PublicKey.default,
-      redeemerSyTokenAccount: syDst,
-    })
-
-    const mintSyRemAccounts = redeemSyIx.keys
-
-    const remainingAccounts = uniqueRemainingAccounts([...this.cpiAccounts.withdrawSy, ...this.cpiAccounts.getSyState])
-
-    const ix = exponentCore.createWrapperMergeInstruction(
-      {
-        merger: owner,
-        authority: this.authority,
-        vault: this.selfAddress,
-        mintPt: this.mintPt,
-        mintYt: this.mintYt,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        syProgram: this.state.syProgram,
-        tokenSyMerger: syDst,
-        tokenYtMerger: ytSrc,
-        tokenPtMerger: ptSrc,
-        escrowSy: this.escrowSy,
-        systemProgram: SystemProgram.programId,
-        vaultAddressLookupTable: this.addressLookupTable,
-        vaultRobotYieldPosition: this.state.yieldPositonAddress,
-        eventAuthority: this.eventAuthority,
-        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
-      },
-      { amountPy, redeemSyAccountsUntil: mintSyRemAccounts.length },
-    )
-    ix.keys.push(...mintSyRemAccounts.concat(remainingAccounts))
-
-    return {
-      ixs: [
-        ...(await this.flavor.preIxs({ signer: owner })),
-        ix,
-        ...(await this.flavor.postIxs({ signer: owner })),
-      ],
-      setupIxs: [tokenSyTraderAtaIx, tokenPtTraderAtaIx, tokenYtTraderAtaIx],
-    }
-  }
-
-  /** Merge PT & YT into SY */
-  ixMerge({
-    pyIn,
-    depositor,
-    ptSrc,
-    ytSrc,
-    syDst,
-  }: {
-    pyIn: bigint
-    depositor: PublicKey
-    ptSrc?: PublicKey
-    ytSrc?: PublicKey
-    syDst?: PublicKey
-  }): TransactionInstruction {
-    const accounts = this.mergeAccounts({ owner: depositor, ptSrc, ytSrc, syDst })
-    const ix = exponentCore.createMergeInstruction(
-      accounts.mainAccounts,
-      { amount: pyIn },
-    )
-    ix.keys.push(...accounts.remainingAccounts)
-    return ix
-  }
-
-  /** Initialize the yield position for a vault */
-  ixInitializeYieldPosition({ owner }: { owner: PublicKey }): TransactionInstruction {
-    const accounts = this.initializeYieldPositionAccounts({ owner })
-
-    return exponentCore.createInitializeYieldPositionInstruction(accounts.mainAccounts)
-  }
-
-  /** Collect interest (as SY) from a yield position */
-  ixCollectInterest({ owner, amount, syDst }: { owner: PublicKey; amount: exponentCore.Amount; syDst?: PublicKey }): TransactionInstruction {
-    const accounts = this.collectInterestAccounts({ owner, syDst })
-    const ix = exponentCore.createCollectInterestInstruction(
-      accounts.mainAccounts,
-      { amount },
-    )
-    ix.keys.push(...accounts.remainingAccounts)
-    return ix
-  }
-
-  /** Wrapper to collect interest that handles SY redemption */
-  async ixWrapperCollectInterest({
-    claimer,
-    tokenSyDst: tokenSyDstParam,
-  }: {
-    claimer: PublicKey
-    tokenSyDst?: PublicKey
-  }) {
-    const yieldPosition = this.pda.yieldPosition({ owner: claimer, vault: this.selfAddress })
-    const tokenSyDst = tokenSyDstParam || getAssociatedTokenAddressSync(this.mintSy, claimer, true, TOKEN_PROGRAM_ID)
-    const tokenBaseClaimer = getAssociatedTokenAddressSync(
-      this.flavor.mintBase,
-      claimer,
-      true,
-      this.flavor.baseTokenProgram,
-    )
-    const tokenBaseClaimerAtaIx = createAssociatedTokenAccountIdempotentInstruction(
-      claimer,
-      tokenBaseClaimer,
-      claimer,
-      this.flavor.mintBase,
-      this.flavor.baseTokenProgram,
-    )
-
-    const tokenSyClaimer = getAssociatedTokenAddressSync(this.mintSy, claimer, true)
-    const tokenSyClaimerAtaIx = createAssociatedTokenAccountIdempotentInstruction(
-      claimer,
-      tokenSyClaimer,
-      claimer,
-      this.mintSy,
-    )
-
-    const remainingAccounts = uniqueRemainingAccounts([
-      ...this.cpiAccounts.getSyState,
-      ...this.cpiAccounts.withdrawSy,
-    ])
-
-    const redeemSyIx = await this.flavor.ixRedeemSy({
-      amountSy: "0",
-      redeemer: claimer,
-      redeemerBaseTokenAccount: tokenBaseClaimer,
-      redeemerSyTokenAccount: tokenSyDst,
-    })
-
-    const ix = exponentCore.createWrapperCollectInterestInstruction(
-      {
-        claimer,
-        authority: this.authority,
-        vault: this.selfAddress,
-        addressLookupTable: this.addressLookupTable,
-        escrowSy: this.escrowSy,
-        syProgram: this.state.syProgram,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        yieldPosition: yieldPosition,
-        tokenSyDst,
-        treasurySyTokenAccount: this.state.treasurySyTokenAccount,
-        eventAuthority: this.eventAuthority,
-        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
-      },
-      { redeemSyAccountsLength: redeemSyIx.keys.length },
-    )
-    ix.keys.push(...redeemSyIx.keys, ...remainingAccounts)
-
-    return {
-      ixs: [
-        ...(await this.flavor.preIxs({ signer: claimer })),
-        ix,
-        ...(await this.flavor.postIxs({ signer: claimer })),
-      ],
-      setupIxs: [tokenBaseClaimerAtaIx, tokenSyClaimerAtaIx],
-    }
-  }
-
-  /** Administrative action to configure a vault */
-  ixConfigureVault({
-    signer,
-    action,
-  }: {
-    signer: PublicKey
-    action: exponentCore.AdminAction
-  }): TransactionInstruction {
-    const accounts = this.configureVaultAccounts({ signer })
-
-    const ix = exponentCore.createModifyVaultSettingInstruction(
-      accounts.mainAccounts,
-      { action },
-    )
-    ix.keys.push(...accounts.remainingAccounts)
-    return ix
-  }
-
-  collectEmissionAccounts({
-    emissionIndex,
-    owner,
-    emissionDst: emissionDstParam,
-  }: {
-    emissionIndex: number
-    owner: PublicKey
-    emissionDst?: PublicKey
-  }): InstructionAccounts<CollectEmissionInstructionAccounts> {
-    const syE = this.syEmissions[emissionIndex]
-    if (!syE) {
-      throw new Error("Emission index out of bounds")
-    }
-
-    const vaultE = this.vaultEmissions[emissionIndex]
-    if (!vaultE) {
-      throw new Error("Emission index out of bounds")
-    }
-
-    const tokenProgram = syE.tokenProgramAddress
-
-    const emissionEscrow = vaultE.tokenAccount
-    const treasuryEmissionTokenAccount = vaultE.treasuryTokenAccount
-    const position = this.pda.yieldPosition({ owner, vault: this.selfAddress })
-    const emissionDst =
-      emissionDstParam || getAssociatedTokenAddressSync(syE.mint, owner, true, syE.tokenProgramAddress)
-    const remainingAccounts = uniqueRemainingAccounts([...this.cpiAccounts.claimEmission[emissionIndex]])
-
-    return {
-      mainAccounts: {
-        owner,
-        addressLookupTable: this.addressLookupTable,
-        vault: this.selfAddress,
-        authority: this.authority,
-        emissionDst,
-        emissionEscrow,
-        treasuryEmissionTokenAccount,
-        syProgram: this.state.syProgram,
-        position,
-        tokenProgram,
-        eventAuthority: this.eventAuthority,
-        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
-      },
-      remainingAccounts,
-    }
-  }
-
-  stripAccounts({
-    depositor,
-    ptDst: ptDstParam,
-    ytDst: ytDstParam,
-    sySrc: sySrcParam,
-  }: {
-    depositor: PublicKey
-    ptDst?: PublicKey
-    ytDst?: PublicKey
-    sySrc?: PublicKey
-  }): InstructionAccounts<StripInstructionAccounts> {
-    const ptDst = ptDstParam || getAssociatedTokenAddressSync(this.mintPt, depositor, true, TOKEN_PROGRAM_ID)
-    const ytDst = ytDstParam || getAssociatedTokenAddressSync(this.mintYt, depositor, true, TOKEN_PROGRAM_ID)
-    const sySrc = sySrcParam || getAssociatedTokenAddressSync(this.mintSy, depositor, true, TOKEN_PROGRAM_ID)
-
-    // console.log("sysrc account: ", sySrc.toBase58())
-
-    const remainingAccounts = uniqueRemainingAccounts([...this.cpiAccounts.depositSy])
-
-    return {
-      mainAccounts: {
-        depositor,
-        authority: this.authority,
-        vault: this.selfAddress,
-        escrowSy: this.escrowSy,
-        ytDst,
-        ptDst,
-        sySrc,
-        mintYt: this.mintYt,
-        mintPt: this.mintPt,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        addressLookupTable: this.addressLookupTable,
-        syProgram: this.state.syProgram,
-        yieldPosition: this.state.yieldPositonAddress,
-        eventAuthority: this.eventAuthority,
-        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
-      },
-      remainingAccounts,
-    }
-  }
-
-  ixCollectTreasuryInterest({
-    signer,
-    syDst,
-    amount,
-    kind,
-  }: {
-    signer: PublicKey
-    syDst: PublicKey
-    amount: exponentCore.Amount
-    kind: exponentCore.CollectTreasuryInterestKind
-  }): TransactionInstruction {
-    const ix = exponentCore.createCollectTreasuryInterestInstruction(
-      {
-        signer,
-        vault: this.selfAddress,
-        admin: this.getAdminStatePda(),
-        authority: this.authority,
-        escrowSy: this.escrowSy,
-        syProgram: this.state.syProgram,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        yieldPosition: this.state.yieldPositonAddress,
-        addressLookupTable: this.addressLookupTable,
-        syDst,
-      },
-      { amount, kind },
-    )
-    ix.keys.push(...this.cpiAccounts.withdrawSy)
-    return ix
-  }
-
-  ixCollectTreasuryEmission({
-    index,
-    amount,
-    emissionDst,
-    signer,
-    kind,
-  }: {
-    index: number
-    amount: exponentCore.Amount
-    emissionDst: PublicKey
-    signer: PublicKey
-    kind: exponentCore.CollectTreasuryEmissionKind
-  }): TransactionInstruction {
-    const ix = exponentCore.createCollectTreasuryEmissionInstruction(
-      {
-        signer,
-        vault: this.selfAddress,
-        admin: this.getAdminStatePda(),
-        authority: this.authority,
-        emissionDst,
-        emissionEscrow: this.state.emissions[index].tokenAccount,
-        syProgram: this.state.syProgram,
-        tokenProgram: this.syEmissions[index].tokenProgramAddress,
-        yieldPosition: this.state.yieldPositonAddress,
-        addressLookupTable: this.addressLookupTable,
-      },
-      { emissionIndex: index, amount, kind },
-    )
-    ix.keys.push(...this.cpiAccounts.claimEmission[index])
-    return ix
-  }
-
-  ixAddStandaloneEmission({
-    signer,
-    emissionMint,
-    emissionTokenProgram = TOKEN_PROGRAM_ID,
-    treasuryTokenAccountEmission,
-    treasuryFeeBps,
-    altAddresses,
-    cpiAccounts,
-  }: {
-    signer: PublicKey
-    emissionMint: PublicKey
-    emissionTokenProgram?: PublicKey
-    treasuryTokenAccountEmission: PublicKey
-    treasuryFeeBps: number
-    altAddresses: PublicKey[]
-    cpiAccounts: CpiAccountsRaw
-  }) {
-    const altUtil = extendAddressLookupTable(altAddresses, cpiAccounts)
-
-    const tokenEmission = getAssociatedTokenAddressSync(emissionMint, this.authority, true, emissionTokenProgram)
-    const ix = exponentCore.createAddEmissionInstruction(
-      {
-        vault: this.selfAddress,
-        addressLookupTable: this.addressLookupTable,
-        admin: this.getAdminStatePda(),
-        authority: signer,
-        syProgram: this.state.syProgram,
-        yieldPosition: this.state.yieldPositonAddress,
-        robotTokenAccount: tokenEmission,
-        treasuryTokenAccount: treasuryTokenAccountEmission,
-        feePayer: signer,
-        systemProgram: SystemProgram.programId,
-      },
-      { cpiAccounts: altUtil.cpiAccountIndexes, treasuryFeeBps },
-    )
-    ix.keys.push(
-      ...this.cpiAccounts.depositSy.concat(
-        altUtil.addressLookupTableExtension.map((pubkey) => ({
-          pubkey,
-          isSigner: false,
-          isWritable: false,
-        })),
-      ),
-    )
-
-    return {
-      extendAddressLookupTableExtensionAccounts: altUtil.addressLookupTableExtension,
-      ix,
-    }
-  }
-
-  collectInterestAccounts({
-    owner,
-    syDst: syDstParam,
-  }: {
-    owner: PublicKey
-    syDst?: PublicKey
-  }): InstructionAccounts<CollectInterestInstructionAccounts> {
-    const syDst = syDstParam || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
-    const yieldPosition = this.pda.yieldPosition({ owner, vault: this.selfAddress })
-    const remainingAccounts = [...this.cpiAccounts.withdrawSy]
-
-    return {
-      mainAccounts: {
-        owner,
-        vault: this.selfAddress,
-        authority: this.authority,
-        escrowSy: this.escrowSy,
-        syProgram: this.state.syProgram,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        yieldPosition,
-        addressLookupTable: this.addressLookupTable,
-        treasurySyTokenAccount: this.state.treasurySyTokenAccount,
-        tokenSyDst: syDst,
-        eventAuthority: this.eventAuthority,
-        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
-      },
-      remainingAccounts,
-    }
-  }
-
-  /** Construct accounts for Merge instruction */
-  mergeAccounts({
-    owner,
-    ptSrc: ptSrcParam,
-    ytSrc: ytSrcParam,
-    syDst: syDstParam,
-  }: {
-    owner: PublicKey
-    ptSrc?: PublicKey
-    ytSrc?: PublicKey
-    syDst?: PublicKey
-  }): InstructionAccounts<MergeInstructionAccounts> {
-    const ptSrc = ptSrcParam || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
-    const ytSrc = ytSrcParam || getAssociatedTokenAddressSync(this.mintYt, owner, true, TOKEN_PROGRAM_ID)
-    const syDst = syDstParam || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
-    const remainingAccounts = [...this.cpiAccounts.getSyState, ...this.cpiAccounts.withdrawSy]
-    return {
-      mainAccounts: {
-        owner,
-        authority: this.authority,
-        vault: this.selfAddress,
-        escrowSy: this.escrowSy,
-        ytSrc,
-        ptSrc,
-        syDst,
-        mintPt: this.mintPt,
-        mintYt: this.mintYt,
-        addressLookupTable: this.addressLookupTable,
-        syProgram: this.state.syProgram,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        yieldPosition: this.state.yieldPositonAddress,
-        eventAuthority: this.eventAuthority,
-        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
-      },
-      remainingAccounts,
-    }
-  }
-
-  initializeYieldPositionAccounts({
-    owner,
-  }: {
-    owner: PublicKey
-  }): InstructionAccounts<InitializeYieldPositionInstructionAccounts> {
-    const yieldPosition = this.pda.yieldPosition({ owner, vault: this.selfAddress })
-    return {
-      mainAccounts: {
-        owner,
-        vault: this.selfAddress,
-        yieldPosition,
-        systemProgram: SystemProgram.programId,
-        eventAuthority: this.eventAuthority,
-        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
-      },
-      remainingAccounts: [],
-    }
-  }
-
-  /** Construct accounts for Merge instruction */
-  configureVaultAccounts({ signer }: { signer: PublicKey }): InstructionAccounts<ModifyVaultSettingInstructionAccounts> {
-    return {
-      mainAccounts: {
-        signer,
-        vault: this.selfAddress,
-        adminState: this.getAdminStatePda(),
-        systemProgram: SystemProgram.programId,
-      },
-      remainingAccounts: [],
-    }
-  }
-}
-
-function serializeFlavorState(flavor: VaultState["flavor"]): VaultStateJson["flavor"] {
-  switch (flavor.flavor) {
-    case "marginfi":
-      return serializeFlavorMarginfi(flavor)
-    case "kamino":
-      return serializeFlavorKamino(flavor)
-    case "jitoRestaking":
-      return serializeFlavorJitoRestaking(flavor)
-    case "perena":
-      return serializeFlavorPerena(flavor)
-    case "generic":
-      return serializeFlavorGeneric(flavor)
-    default:
-      throw new Error(`Unknown flavor: ${flavor}`)
-  }
-}
-
-function deserializeFlavorState(flavor: VaultStateJson["flavor"]): VaultState["flavor"] {
-  switch (flavor.flavor) {
-    case "marginfi":
-      return makeFlavorMarginfiSync(deserializeFlavorMarginfi(flavor))
-    case "kamino":
-      return makeFlavorKaminoSync(deserializeFlavorKamino(flavor))
-    case "jitoRestaking":
-      return makeFlavorJitoRestakingSync(deserializeFlavorJitoRestaking(flavor))
-    case "perena":
-      return makeFlavorPerenaSync(deserializeFlavorPerena(flavor))
-    case "generic":
-      return makeFlavorGenericSync(deserializeFlavorGeneric(flavor))
-    default:
-      throw new Error(`Unknown flavor: ${flavor}`)
-  }
-}
-
-export function serializeVaultState(state: VaultState): VaultStateJson {
-  return {
-    ptSupply: state.ptSupply.toString(),
-    syForPt: state.syForPt.toString(),
-    startTs: state.startTs,
-    durationSeconds: state.durationSeconds,
-    authority: state.authority.toString(),
-    addressLookupTable: state.addressLookupTable.toString(),
-    lastSeenSyExchangeRate: state.lastSeenSyExchangeRate,
-    allTimeHighSyExchangeRate: state.allTimeHighSyExchangeRate,
-    escrowSy: state.escrowSy.toString(),
-    escrowYt: state.escrowYt.toString(),
-    syProgram: state.syProgram.toString(),
-    syPosition: serializeSyPosition(state.syPosition),
-    cpiAccounts: serializeCpiAccountsRaw(state.cpiAccounts),
-    mintPt: state.mintPt.toString(),
-    status: state.status,
-    minOperationSizeStrip: state.minOperationSizeStrip.toString(),
-    minOperationSizeMerge: state.minOperationSizeMerge.toString(),
-    mintYt: state.mintYt.toString(),
-    mintSy: state.mintSy.toString(),
-    yieldPositonAddress: state.yieldPositonAddress.toString(),
-    treasurySyTokenAccount: state.treasurySyTokenAccount.toString(),
-    interestBpsFee: state.interestBpsFee,
-    totalSyInEscrow: state.totalSyInEscrow.toString(),
-    flavor: serializeFlavorState(state.flavor),
-    finalSyExchangeRate: state.finalSyExchangeRate,
-    emissions: state.emissions.map((emission) => serializeEmission(emission)),
-    maxPySupply: state.maxPySupply.toString(),
-  }
-}
-
-export function deserializeVaultState(state: VaultStateJson): VaultState {
-  return {
-    ptSupply: BigInt(state.ptSupply),
-    syForPt: BigInt(state.syForPt),
-    startTs: state.startTs,
-    durationSeconds: state.durationSeconds,
-    authority: new PublicKey(state.authority),
-    addressLookupTable: new PublicKey(state.addressLookupTable),
-    lastSeenSyExchangeRate: state.lastSeenSyExchangeRate,
-    allTimeHighSyExchangeRate: state.allTimeHighSyExchangeRate,
-    escrowSy: new PublicKey(state.escrowSy),
-    escrowYt: new PublicKey(state.escrowYt),
-    syProgram: new PublicKey(state.syProgram),
-    syPosition: deserializeSyPosition(state.syPosition),
-    cpiAccounts: deserializeCpiAccountsRaw(state.cpiAccounts),
-    mintPt: new PublicKey(state.mintPt),
-    status: state.status,
-    minOperationSizeStrip: BigInt(state.minOperationSizeStrip),
-    minOperationSizeMerge: BigInt(state.minOperationSizeMerge),
-    mintYt: new PublicKey(state.mintYt),
-    mintSy: new PublicKey(state.mintSy),
-    yieldPositonAddress: new PublicKey(state.yieldPositonAddress),
-    treasurySyTokenAccount: new PublicKey(state.treasurySyTokenAccount),
-    interestBpsFee: state.interestBpsFee,
-    totalSyInEscrow: BigInt(state.totalSyInEscrow),
-    flavor: deserializeFlavorState(state.flavor),
-    finalSyExchangeRate: state.finalSyExchangeRate,
-    emissions: state.emissions.map((emission) => deserializeEmission(emission)),
-    maxPySupply: BigInt(state.maxPySupply),
-  }
-}