@exponent-labs/exponent-sdk 0.0.3

package/src/vault.ts

@@ -0,0 +1,999 @@
+import { BN, Program, web3, AnchorProvider } from "@coral-xyz/anchor"
+import { ClaimAmount } from "@exponent-labs/exponent-ix"
+import { deserializeEmission, ExponentFetcher, serializeEmission } from "@exponent-labs/exponent-fetcher"
+import { fetchAddressLookupTable, makeCpiAccountMetaLists } from "./addressLookupTableUtil"
+import {
+  deserializeFlavorGeneric,
+  deserializeFlavorKamino,
+  deserializeFlavorMarginfi,
+  deserializeFlavorParena,
+  deserializeFlavorJitoRestaking,
+  makeFlavor,
+  makeFlavorGenericSync,
+  makeFlavorKaminoSync,
+  makeFlavorMarginfiSync,
+  makeFlavorPerenaSync,
+  makeFlavorJitoRestakingSync,
+  serializeFlavorGeneric,
+  serializeFlavorJitoRestaking,
+  serializeFlavorKamino,
+  serializeFlavorMarginfi,
+  serializeFlavorParena,
+} from "./flavors"
+import { Environment } from "./environment"
+import { getAssociatedTokenAddressSync, TOKEN_PROGRAM_ID } from "@solana/spl-token"
+import { deserializeSyPosition, makeSyPosition, serializeSyPostion } from "./syPosition"
+import { ExponentCore, IDL } from "@exponent-labs/exponent-idl"
+import { emitEventAuthority, InstructionAccounts, uniqueRemainingAccounts } from "./utils"
+import { EXPONENT_ADMIN_PROGRAM_ID, ExponentAdminPda } from "@exponent-labs/exponent-admin-pda"
+import { ExponentPDA } from "@exponent-labs/exponent-pda"
+import { MyWallet } from "./market"
+import { deserializeCpiAccountsRaw, serializeCpiAccountsRaw } from "@exponent-labs/exponent-ix"
+import { VaultEmission, VaultJson, VaultState, AnchorizedPNum, CpiAccountsRaw } from "@exponent-labs/exponent-types"
+import { extendAddressLookupTable } from "./utils/altUtil"
+
+export type CollectTreasuryEmissionKind =
+  | { yieldPosition: {} }
+  | {
+      treasuryEmission: {}
+    }
+
+export type CollectTreasuryInterestKind =
+  | {
+      yieldPosition: {}
+    }
+  | {
+      treasuryInterest: {}
+    }
+
+/** Emission info for SY program */
+interface SyEmission {
+  /** Token account that holds emission tokens */
+  escrowAccountAddress: web3.PublicKey
+
+  /** Mint for the emission token */
+  mint: web3.PublicKey
+
+  /** Token program ID for the emission token */
+  tokenProgramAddress: web3.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
+}
+
+export class Vault {
+  private coreProgram: Program<ExponentCore>
+
+  constructor(
+    public state: VaultState,
+    public selfAddress: web3.PublicKey,
+    public env: Environment,
+    public connection: web3.Connection,
+  ) {
+    const mockWallet = new MyWallet(web3.Keypair.generate())
+    this.coreProgram = new Program(IDL as ExponentCore, new AnchorProvider(connection, mockWallet))
+  }
+
+  static loadFromJson(v: VaultJson, address: web3.PublicKey, env: Environment, connection: web3.Connection) {
+    const state = toVaultState(v)
+    return new Vault(state, address, env, connection)
+  }
+
+  static async load(env: Environment, connection: web3.Connection, address: web3.PublicKey) {
+    const fetcher = new ExponentFetcher({ connection })
+    const v = await fetcher.fetchVault(address)
+
+    const alt = await fetchAddressLookupTable(connection, v.addressLookupTable)
+    const cpiAccounts = makeCpiAccountMetaLists(alt, v.cpiAccounts)
+    const flavor = await makeFlavor(fetcher, env, v.syProgram, cpiAccounts)
+    const positionInCpiAccounts = cpiAccounts.depositSy[6]
+    console.log("positionInCpiAccounts", positionInCpiAccounts.pubkey.toBase58())
+    const syPosition = await makeSyPosition(fetcher, flavor, v.syProgram, v.authority)
+
+    const state: VaultState = {
+      ptSupply: v.ptSupply,
+      syForPt: v.syForPt,
+      startTs: v.startTs,
+      durationSeconds: v.duration,
+      authority: v.authority,
+      addressLookupTable: v.addressLookupTable,
+      lastSeenSyExchangeRate: v.lastSeenSyExchangeRate,
+      allTimeHighSyExchangeRate: v.allTimeHighSyExchangeRate,
+      syProgram: v.syProgram,
+      mintPt: v.mintPt,
+      mintSy: v.mintSy,
+      mintYt: v.mintYt,
+      escrowSy: v.escrowSy,
+      escrowYt: v.escrowYt,
+      yieldPositonAddress: v.yieldPosition,
+      cpiAccounts,
+      flavor,
+      syPosition,
+      totalSyInEscrow: v.totalSyInEscrow,
+      treasurySyTokenAccount: v.treasurySyTokenAccount,
+      interestBpsFee: v.interestBpsFee,
+      emissions: v.emissions,
+      minOperationSizeStrip: v.minOpSizeStrip,
+      minOperationSizeMerge: v.minOpSizeMerge,
+      status: v.status,
+      finalSyExchangeRate: v.finalSyExchangeRate,
+      maxPySupply: v.maxPySupply,
+    }
+
+    return new Vault(state, address, env, connection)
+  }
+
+  async reload(conn: web3.Connection = this.connection) {
+    const v = await Vault.load(this.env, conn, this.selfAddress)
+    this.state = v.state
+    return v
+  }
+
+  toJson(): VaultJson {
+    return {
+      startTs: this.state.startTs,
+      duration: this.state.durationSeconds,
+      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,
+      syPosition: serializeSyPostion(this.state.syPosition),
+      minOperationSizeStrip: this.state.minOperationSizeStrip.toString(),
+      minOperationSizeMerge: this.state.minOperationSizeMerge.toString(),
+      yieldPositonAddress: this.state.yieldPositonAddress.toString(),
+      interestFeeBps: this.state.interestBpsFee,
+      flavor: (() => {
+        switch (this.state.flavor.flavor) {
+          case "marginfi":
+            return serializeFlavorMarginfi(this.state.flavor)
+          case "kamino":
+            return serializeFlavorKamino(this.state.flavor)
+          case "jitoRestaking":
+            return serializeFlavorJitoRestaking(this.state.flavor)
+          case "perena":
+            return serializeFlavorParena(this.state.flavor)
+          case "generic":
+            return serializeFlavorGeneric(this.state.flavor)
+          default:
+            throw new Error(`Unknown flavor: ${this.state.flavor}`)
+        }
+      })(),
+      emissions: this.state.emissions.map((e) => serializeEmission(e)),
+      maxPySupply: this.state.maxPySupply.toString(),
+    }
+  }
+
+  get pda() {
+    return new ExponentPDA(this.coreProgram.programId)
+  }
+
+  get syBalance(): bigint {
+    return this.state.syPosition.balanceSy
+  }
+
+  get mintSy(): web3.PublicKey {
+    return this.state.mintSy
+  }
+
+  getAdminStatePda() {
+    return new ExponentAdminPda(EXPONENT_ADMIN_PROGRAM_ID).exponentAdmin()
+  }
+
+  get mintPt(): web3.PublicKey {
+    return this.state.mintPt
+  }
+
+  get mintYt(): web3.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(this.coreProgram.programId)
+  }
+
+  /** 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(): web3.PublicKey[] {
+    return this.vaultEmissions.map((e) => e.tokenAccount)
+  }
+
+  get currentSyExchangeRate(): number {
+    return this.flavor.currentSyExchangeRate
+  }
+
+  get escrowYt(): web3.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: web3.PublicKey
+    emissionIndex: number
+    amount: ClaimAmount
+    emissionDst?: web3.PublicKey
+  }) {
+    const accounts = this.collectEmissionAccounts({ emissionIndex, owner, emissionDst })
+
+    return this.coreProgram.methods
+      .collectEmission(emissionIndex, amount)
+      .accountsStrict(accounts.mainAccounts)
+      .remainingAccounts(accounts.remainingAccounts)
+      .instruction()
+  }
+
+  /** Strip SY into PT & YT */
+  ixStrip({
+    syIn,
+    depositor,
+    ptDst,
+    ytDst,
+    sySrc,
+  }: {
+    syIn: bigint
+    depositor: web3.PublicKey
+    ptDst?: web3.PublicKey
+    ytDst?: web3.PublicKey
+    sySrc?: web3.PublicKey
+  }): Promise<web3.TransactionInstruction> {
+    const { mainAccounts, remainingAccounts } = this.stripAccounts({ depositor, ptDst, ytDst, sySrc })
+    return this.coreProgram.methods
+      .strip(new BN(syIn.toString()))
+      .accountsStrict(mainAccounts)
+      .remainingAccounts(remainingAccounts)
+      .instruction()
+  }
+
+  async ixStripFromBase({
+    owner,
+    amountBase,
+    baseSrc,
+    sySrc,
+    ptDst,
+    ytDst,
+  }: {
+    owner: web3.PublicKey
+    amountBase: bigint
+    baseSrc?: web3.PublicKey
+    sySrc?: web3.PublicKey
+    ptDst?: web3.PublicKey
+    ytDst?: web3.PublicKey
+  }): Promise<web3.TransactionInstruction> {
+    baseSrc = baseSrc || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
+    sySrc = sySrc || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
+    ptDst = ptDst || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
+    ytDst = ytDst || 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 })
+
+    return this.coreProgram.methods
+      .wrapperStrip(new BN(amountBase.toString()), mintSyRemAccounts.length)
+      .accountsStrict({
+        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: web3.SystemProgram.programId,
+        vaultAddressLookupTable: this.addressLookupTable,
+        vaultRobotYieldPosition: this.state.yieldPositonAddress,
+        eventAuthority: this.eventAuthority,
+        program: this.coreProgram.programId,
+        escrowYt: this.escrowYt,
+        userYieldPosition,
+      })
+      .remainingAccounts(mintSyRemAccounts.concat(remainingAccounts))
+      .instruction()
+  }
+
+  async ixMergeToBase({
+    owner,
+    amountPy,
+    ptSrc,
+    ytSrc,
+    syDst,
+    baseDst,
+  }: {
+    owner: web3.PublicKey
+    amountPy: bigint
+    ptSrc?: web3.PublicKey
+    ytSrc?: web3.PublicKey
+    syDst?: web3.PublicKey
+    baseDst?: web3.PublicKey
+  }): Promise<web3.TransactionInstruction> {
+    baseDst = baseDst || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
+    syDst = syDst || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
+    ptSrc = ptSrc || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
+    ytSrc = ytSrc || getAssociatedTokenAddressSync(this.mintYt, owner, true, TOKEN_PROGRAM_ID)
+
+    const redeemSyIx = await this.state.flavor.ixRedeemSy({
+      amountSy: "0",
+      redeemer: owner,
+      redeemerBaseTokenAccount: baseDst,
+      redeemerSyTokenAccount: syDst,
+    })
+
+    const mintSyRemAccounts = redeemSyIx.keys
+
+    const remainingAccounts = uniqueRemainingAccounts([...this.cpiAccounts.withdrawSy, ...this.cpiAccounts.getSyState])
+
+    return this.coreProgram.methods
+      .wrapperMerge(new BN(amountPy.toString()), mintSyRemAccounts.length)
+      .accountsStrict({
+        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: web3.SystemProgram.programId,
+        vaultAddressLookupTable: this.addressLookupTable,
+        vaultRobotYieldPosition: this.state.yieldPositonAddress,
+        eventAuthority: this.eventAuthority,
+        program: this.coreProgram.programId,
+      })
+      .remainingAccounts(mintSyRemAccounts.concat(remainingAccounts))
+      .instruction()
+  }
+
+  /** Merge PT & YT into SY */
+  ixMerge({
+    pyIn,
+    depositor,
+    ptSrc,
+    ytSrc,
+    syDst,
+  }: {
+    pyIn: bigint
+    depositor: web3.PublicKey
+    ptSrc?: web3.PublicKey
+    ytSrc?: web3.PublicKey
+    syDst?: web3.PublicKey
+  }): Promise<web3.TransactionInstruction> {
+    const accounts = this.mergeAccounts({ owner: depositor, ptSrc, ytSrc, syDst })
+
+    return this.coreProgram.methods
+      .merge(new BN(pyIn.toString()))
+      .accountsStrict(accounts.mainAccounts)
+      .remainingAccounts(accounts.remainingAccounts)
+      .instruction()
+  }
+
+  /** Initialize the yield position for a vault */
+  ixInitializeYieldPosition({ owner }: { owner: web3.PublicKey }): Promise<web3.TransactionInstruction> {
+    const accounts = this.initializeYieldPositionAccounts({ owner })
+
+    return this.coreProgram.methods.initializeYieldPosition().accountsStrict(accounts.mainAccounts).instruction()
+  }
+
+  /** Collect interest (as SY) from a yield position */
+  ixCollectInterest({ owner, amount, syDst }: { owner: web3.PublicKey; amount: ClaimAmount; syDst?: web3.PublicKey }) {
+    const accounts = this.collectInterestAccounts({ owner, syDst })
+    return this.coreProgram.methods
+      .collectInterest(amount)
+      .accountsStrict(accounts.mainAccounts)
+      .remainingAccounts(accounts.remainingAccounts)
+      .instruction()
+  }
+
+  /** Administrative action to configure a vault */
+  /** Administrative action to configure a vault */
+  ixConfigureVault({
+    signer,
+    action,
+  }: {
+    signer: web3.PublicKey
+    action: AdminAction
+  }): Promise<web3.TransactionInstruction> {
+    const accounts = this.configureVaultAccounts({ signer })
+
+    return this.coreProgram.methods
+      .modifyVaultSetting(action)
+      .accountsStrict(accounts.mainAccounts)
+      .remainingAccounts(accounts.remainingAccounts)
+      .instruction()
+  }
+
+  collectEmissionAccounts({
+    emissionIndex,
+    owner,
+    emissionDst,
+  }: {
+    emissionIndex: number
+    owner: web3.PublicKey
+    emissionDst?: web3.PublicKey
+  }): InstructionAccounts<CollectEmissionAccounts> {
+    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 })
+    emissionDst = emissionDst || 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: this.coreProgram.programId,
+      },
+      remainingAccounts,
+    }
+  }
+
+  stripAccounts({
+    depositor,
+    ptDst,
+    ytDst,
+    sySrc,
+  }: {
+    depositor: web3.PublicKey
+    ptDst?: web3.PublicKey
+    ytDst?: web3.PublicKey
+    sySrc?: web3.PublicKey
+  }): InstructionAccounts<StripAccounts> {
+    ptDst = ptDst || getAssociatedTokenAddressSync(this.mintPt, depositor, true, TOKEN_PROGRAM_ID)
+    ytDst = ytDst || getAssociatedTokenAddressSync(this.mintYt, depositor, true, TOKEN_PROGRAM_ID)
+    sySrc = sySrc || 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: this.coreProgram.programId,
+      },
+      remainingAccounts,
+    }
+  }
+
+  ixCollectTreasuryInterest({
+    signer,
+    syDst,
+    amount,
+    kind,
+  }: {
+    signer: web3.PublicKey
+    syDst: web3.PublicKey
+    amount: ClaimAmount
+    kind: CollectTreasuryInterestKind
+  }): Promise<web3.TransactionInstruction> {
+    return this.coreProgram.methods
+      .collectTreasuryInterest(amount, kind)
+      .accountsStrict({
+        addressLookupTable: this.addressLookupTable,
+        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,
+        syDst,
+      })
+      .remainingAccounts(this.cpiAccounts.withdrawSy)
+      .instruction()
+  }
+
+  ixCollectTreasuryEmission({
+    index,
+    amount,
+    emissionDst,
+    signer,
+    kind,
+  }: {
+    index: number
+    amount: ClaimAmount
+    emissionDst: web3.PublicKey
+    signer: web3.PublicKey
+    kind: CollectTreasuryEmissionKind
+  }): Promise<web3.TransactionInstruction> {
+    return this.coreProgram.methods
+      .collectTreasuryEmission(index, amount, kind)
+      .accountsStrict({
+        addressLookupTable: this.addressLookupTable,
+        vault: this.selfAddress,
+        admin: this.getAdminStatePda(),
+        authority: this.authority,
+        emissionDst,
+        emissionEscrow: this.state.emissions[index].tokenAccount,
+        signer,
+        syProgram: this.state.syProgram,
+        tokenProgram: this.syEmissions[index].tokenProgramAddress,
+        yieldPosition: this.state.yieldPositonAddress,
+      })
+      .remainingAccounts(this.cpiAccounts.claimEmission[index])
+      .instruction()
+  }
+
+  async ixAddStandaloneEmission({
+    signer,
+    emissionMint,
+    emissionTokenProgram = TOKEN_PROGRAM_ID,
+    treasuryTokenAccountEmission,
+    treasuryFeeBps,
+    altAddresses,
+    cpiAccounts,
+  }: {
+    signer: web3.PublicKey
+    emissionMint: web3.PublicKey
+    emissionTokenProgram?: web3.PublicKey
+    treasuryTokenAccountEmission: web3.PublicKey
+    treasuryFeeBps: number
+    altAddresses: web3.PublicKey[]
+    cpiAccounts: CpiAccountsRaw
+  }) {
+    const altUtil = extendAddressLookupTable(altAddresses, cpiAccounts)
+
+    const tokenEmission = getAssociatedTokenAddressSync(emissionMint, this.authority, true, emissionTokenProgram)
+    const ix = await this.coreProgram.methods
+      .addEmission(altUtil.cpiAccountIndexes, treasuryFeeBps)
+      .accountsStrict({
+        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: web3.SystemProgram.programId,
+      })
+      .remainingAccounts(
+        this.cpiAccounts.depositSy.concat(
+          altUtil.addressLookupTableExtension.map((pubkey) => ({
+            pubkey,
+            isSigner: false,
+            isWritable: false,
+          })),
+        ),
+      )
+      .instruction()
+
+    return {
+      extendAddressLookupTableExtensionAccounts: altUtil.addressLookupTableExtension,
+      ix,
+    }
+  }
+
+  collectInterestAccounts({
+    owner,
+    syDst,
+  }: {
+    owner: web3.PublicKey
+    syDst?: web3.PublicKey
+  }): InstructionAccounts<CollectInterestAccounts> {
+    syDst = syDst || 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: this.coreProgram.programId,
+      },
+      remainingAccounts,
+    }
+  }
+
+  /** Construct accounts for Merge instruction */
+  mergeAccounts({
+    owner,
+    ptSrc,
+    ytSrc,
+    syDst,
+  }: {
+    owner: web3.PublicKey
+    ptSrc?: web3.PublicKey
+    ytSrc?: web3.PublicKey
+    syDst?: web3.PublicKey
+  }): InstructionAccounts<MergeAccounts> {
+    ptSrc = ptSrc || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
+    ytSrc = ytSrc || getAssociatedTokenAddressSync(this.mintYt, owner, true, TOKEN_PROGRAM_ID)
+    syDst = syDst || 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: this.coreProgram.programId,
+      },
+      remainingAccounts,
+    }
+  }
+
+  initializeYieldPositionAccounts({
+    owner,
+  }: {
+    owner: web3.PublicKey
+  }): InstructionAccounts<InitializeYieldPositionAccounts> {
+    const yieldPosition = this.pda.yieldPosition({ owner, vault: this.selfAddress })
+    return {
+      mainAccounts: {
+        owner,
+        vault: this.selfAddress,
+        yieldPosition,
+        systemProgram: web3.SystemProgram.programId,
+        eventAuthority: this.eventAuthority,
+        program: this.coreProgram.programId,
+      },
+      remainingAccounts: [],
+    }
+  }
+
+  /** Construct accounts for Merge instruction */
+  configureVaultAccounts({ signer }: { signer: web3.PublicKey }): InstructionAccounts<ConfigureVaultAccounts> {
+    return {
+      mainAccounts: {
+        signer,
+        vault: this.selfAddress,
+        adminState: this.getAdminStatePda(),
+        systemProgram: web3.SystemProgram.programId,
+      },
+      remainingAccounts: [],
+    }
+  }
+}
+
+function toVaultState(vault: VaultJson): VaultState {
+  return {
+    ptSupply: BigInt(vault.ptSupply),
+    syForPt: BigInt(vault.syForPt),
+    startTs: vault.startTs,
+    durationSeconds: vault.duration,
+    authority: new web3.PublicKey(vault.authority),
+    addressLookupTable: new web3.PublicKey(vault.addressLookupTable),
+    lastSeenSyExchangeRate: vault.lastSeenSyExchangeRate,
+    allTimeHighSyExchangeRate: vault.allTimeHighSyExchangeRate,
+    escrowSy: new web3.PublicKey(vault.escrowSy),
+    escrowYt: new web3.PublicKey(vault.escrowYt),
+    syProgram: new web3.PublicKey(vault.syProgram),
+    syPosition: deserializeSyPosition(vault.syPosition),
+    mintPt: new web3.PublicKey(vault.mintPt),
+    status: vault.status,
+    minOperationSizeStrip: BigInt(vault.minOperationSizeStrip),
+    minOperationSizeMerge: BigInt(vault.minOperationSizeMerge),
+    mintYt: new web3.PublicKey(vault.mintYt),
+    mintSy: new web3.PublicKey(vault.mintSy),
+    yieldPositonAddress: new web3.PublicKey(vault.yieldPositonAddress),
+    treasurySyTokenAccount: new web3.PublicKey(vault.treasurySyTokenAccount),
+    interestBpsFee: vault.interestFeeBps,
+    totalSyInEscrow: BigInt(vault.totalSyInEscrow),
+    cpiAccounts: deserializeCpiAccountsRaw(vault.cpiAccounts),
+    finalSyExchangeRate: vault.finalSyExchangeRate,
+    flavor: (() => {
+      switch (vault.flavor.flavor) {
+        case "marginfi":
+          return makeFlavorMarginfiSync(deserializeFlavorMarginfi(vault.flavor))
+        case "kamino":
+          return makeFlavorKaminoSync(deserializeFlavorKamino(vault.flavor))
+        case "jitoRestaking":
+          return makeFlavorJitoRestakingSync(deserializeFlavorJitoRestaking(vault.flavor))
+        case "perena":
+          return makeFlavorPerenaSync(deserializeFlavorParena(vault.flavor))
+        case "generic":
+          return makeFlavorGenericSync(deserializeFlavorGeneric(vault.flavor))
+        default:
+          throw new Error(`Unknown flavor: ${vault.flavor}`)
+      }
+    })(),
+    emissions: vault.emissions.map((e) => deserializeEmission(e)),
+    maxPySupply: BigInt(vault.maxPySupply),
+  }
+}
+
+export interface CollectInterestAccounts {
+  vault: web3.PublicKey
+  owner: web3.PublicKey
+  authority: web3.PublicKey
+  escrowSy: web3.PublicKey
+  tokenSyDst: web3.PublicKey
+  tokenProgram: web3.PublicKey
+  yieldPosition: web3.PublicKey
+  addressLookupTable: web3.PublicKey
+  syProgram: web3.PublicKey
+  treasurySyTokenAccount: web3.PublicKey
+  eventAuthority: web3.PublicKey
+  program: web3.PublicKey
+}
+
+export interface CollectEmissionAccounts {
+  owner: web3.PublicKey
+  vault: web3.PublicKey
+  position: web3.PublicKey
+  syProgram: web3.PublicKey
+  addressLookupTable: web3.PublicKey
+  authority: web3.PublicKey
+  emissionEscrow: web3.PublicKey
+  emissionDst: web3.PublicKey
+  treasuryEmissionTokenAccount: web3.PublicKey
+  tokenProgram: web3.PublicKey
+  eventAuthority: web3.PublicKey
+  program: web3.PublicKey
+}
+
+/** Accounts used by Merge */
+export interface MergeAccounts {
+  owner: web3.PublicKey
+  authority: web3.PublicKey
+  vault: web3.PublicKey
+  escrowSy: web3.PublicKey
+  ytSrc: web3.PublicKey
+  ptSrc: web3.PublicKey
+  syDst: web3.PublicKey
+  mintPt: web3.PublicKey
+  mintYt: web3.PublicKey
+  addressLookupTable: web3.PublicKey
+  syProgram: web3.PublicKey
+  tokenProgram: web3.PublicKey
+  yieldPosition: web3.PublicKey
+  eventAuthority: web3.PublicKey
+  program: web3.PublicKey
+}
+
+/** Accounts used by Strip */
+export interface StripAccounts {
+  depositor: web3.PublicKey
+  authority: web3.PublicKey
+  vault: web3.PublicKey
+  sySrc: web3.PublicKey
+  escrowSy: web3.PublicKey
+  ytDst: web3.PublicKey
+  ptDst: web3.PublicKey
+  mintYt: web3.PublicKey
+  mintPt: web3.PublicKey
+  tokenProgram: web3.PublicKey
+  addressLookupTable: web3.PublicKey
+  syProgram: web3.PublicKey
+  yieldPosition: web3.PublicKey
+  eventAuthority: web3.PublicKey
+  program: web3.PublicKey
+}
+
+/** Accounts used by Initialize Yield Position */
+export interface InitializeYieldPositionAccounts {
+  owner: web3.PublicKey
+  vault: web3.PublicKey
+  yieldPosition: web3.PublicKey
+  systemProgram: web3.PublicKey
+  eventAuthority: web3.PublicKey
+  program: web3.PublicKey
+}
+
+/** Accounts used by Configure Vault */
+export interface ConfigureVaultAccounts {
+  vault: web3.PublicKey
+  signer: web3.PublicKey
+  adminState: web3.PublicKey
+  systemProgram: web3.PublicKey
+}
+
+export type AdminAction =
+  | { setVaultStatus: [number] }
+  | { changeVaultBpsFee: [number] }
+  | { changeVaultTreasuryTokenAccount: [web3.PublicKey] }
+  | {
+      changeEmissionTreasuryTokenAccount: {
+        emissionIndex: number
+        newTokenAccount: web3.PublicKey
+      }
+    }
+  | {
+      changeMinOperationSize: {
+        isStrip: boolean
+        newSize: BN
+      }
+    }
+  | {
+      changeEmissionBpsFee: {
+        emissionIndex: number
+        newFeeBps: number
+      }
+    }
+  | {
+      changeClaimLimits: {
+        maxClaimAmountPerWindow: BN
+        claimWindowDurationSeconds: number
+      }
+    }
+  | {
+      changeMaxPySupply: {
+        newMaxPySupply: BN
+      }
+    }