@exponent-labs/exponent-sdk 0.1.8 → 0.9.0

package/src/vault.ts

@@ -1,13 +1,14 @@
-import { AnchorProvider, BN, Program, web3 } from "@coral-xyz/anchor"
+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 { ExponentCore, IDL } from "@exponent-labs/exponent-idl"
 import { ExponentPDA } from "@exponent-labs/exponent-pda"
 import {
   AnchorizedPNum,
@@ -41,39 +42,29 @@ import {
   serializeFlavorMarginfi,
   serializeFlavorPerena,
 } from "./flavors"
-import { MyWallet } from "./market"
 import { deserializeSyPosition, makeSyPosition, serializeSyPosition } from "./syPosition"
 import { InstructionAccounts, emitEventAuthority, uniqueRemainingAccounts } from "./utils"
 import { extendAddressLookupTable } from "./utils/altUtil"
-
-export type CollectTreasuryEmissionKind =
-  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-  | { yieldPosition: {} }
-  | {
-      // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-      treasuryEmission: {}
-    }
-
-export type CollectTreasuryInterestKind =
-  | {
-      // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-      yieldPosition: {}
-    }
-  | {
-      // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-      treasuryInterest: {}
-    }
+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: web3.PublicKey
+  escrowAccountAddress: PublicKey
 
   /** Mint for the emission token */
-  mint: web3.PublicKey
+  mint: PublicKey
 
   /** Token program ID for the emission token */
-  tokenProgramAddress: web3.PublicKey
+  tokenProgramAddress: PublicKey
 
   /** How many emissions have been claimed by SY holders */
   totalClaimed: BN
@@ -92,29 +83,24 @@ interface VaultLoadOptions {
 }
 
 export class Vault {
-  private coreProgram: Program<ExponentCore>
-
   constructor(
     public state: VaultState,
-    public selfAddress: web3.PublicKey,
+    public selfAddress: PublicKey,
     public env: Environment,
-    public connection: web3.Connection,
+    public connection: Connection,
   ) {
-    this.coreProgram = new Program(
-      IDL as ExponentCore,
-      new AnchorProvider(connection, new MyWallet(web3.Keypair.generate())),
-    )
+
   }
 
-  static loadFromJson(vaultJson: VaultJson, address: web3.PublicKey, env: Environment, connection: web3.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: web3.Connection,
-    address: web3.PublicKey,
+    connection: Connection,
+    address: PublicKey,
     options: VaultLoadOptions = {},
   ) {
     const fetcher = new ExponentFetcher({ connection })
@@ -160,7 +146,7 @@ export class Vault {
     return new Vault(state, address, env, connection)
   }
 
-  async reload(connection: web3.Connection = this.connection) {
+  async reload(connection: Connection = this.connection) {
     const vault = await Vault.load(this.env, connection, this.selfAddress)
     this.state = vault.state
     return vault
@@ -206,14 +192,14 @@ export class Vault {
   }
 
   get pda() {
-    return new ExponentPDA(this.coreProgram.programId)
+    return new ExponentPDA(exponentCore.EXPONENTCORE_PROGRAM_ID)
   }
 
   get syBalance(): bigint {
     return this.state.syPosition.balanceSy
   }
 
-  get mintSy(): web3.PublicKey {
+  get mintSy(): PublicKey {
     return this.state.mintSy
   }
 
@@ -221,11 +207,11 @@ export class Vault {
     return new ExponentAdminPda(EXPONENT_ADMIN_PROGRAM_ID).exponentAdmin()
   }
 
-  get mintPt(): web3.PublicKey {
+  get mintPt(): PublicKey {
     return this.state.mintPt
   }
 
-  get mintYt(): web3.PublicKey {
+  get mintYt(): PublicKey {
     return this.state.mintYt
   }
 
@@ -250,7 +236,7 @@ export class Vault {
   }
 
   get eventAuthority() {
-    return emitEventAuthority(this.coreProgram.programId)
+    return emitEventAuthority(exponentCore.EXPONENTCORE_PROGRAM_ID)
   }
 
   /** Emission metadata from SY program */
@@ -314,7 +300,7 @@ export class Vault {
   }
 
   /** Get the escrow token account addresses for the emissions, in order */
-  get vaultEmissionTokenAccounts(): web3.PublicKey[] {
+  get vaultEmissionTokenAccounts(): PublicKey[] {
     return this.vaultEmissions.map((e) => e.tokenAccount)
   }
 
@@ -322,7 +308,7 @@ export class Vault {
     return this.flavor.currentSyExchangeRate
   }
 
-  get escrowYt(): web3.PublicKey {
+  get escrowYt(): PublicKey {
     return this.state.escrowYt
   }
 
@@ -343,18 +329,18 @@ export class Vault {
     amount,
     emissionDst,
   }: {
-    owner: web3.PublicKey
+    owner: PublicKey
     emissionIndex: number
-    amount: ClaimAmount
-    emissionDst?: web3.PublicKey
-  }) {
+    amount: exponentCore.Amount
+    emissionDst?: PublicKey
+  }) : TransactionInstruction {
     const accounts = this.collectEmissionAccounts({ emissionIndex, owner, emissionDst })
-
-    return this.coreProgram.methods
-      .collectEmission(emissionIndex, amount)
-      .accountsStrict(accounts.mainAccounts)
-      .remainingAccounts(accounts.remainingAccounts)
-      .instruction()
+    const ix = exponentCore.createCollectEmissionInstruction(
+      accounts.mainAccounts,
+      { index: emissionIndex, amount },
+    )
+    ix.keys.push(...accounts.remainingAccounts)
+    return ix
   }
 
   /** Strip SY into PT & YT */
@@ -366,17 +352,18 @@ export class Vault {
     sySrc,
   }: {
     syIn: bigint
-    depositor: web3.PublicKey
-    ptDst?: web3.PublicKey
-    ytDst?: web3.PublicKey
-    sySrc?: web3.PublicKey
-  }): Promise<web3.TransactionInstruction> {
+    depositor: PublicKey
+    ptDst?: PublicKey
+    ytDst?: PublicKey
+    sySrc?: PublicKey
+  }): TransactionInstruction {
     const { mainAccounts, remainingAccounts } = this.stripAccounts({ depositor, ptDst, ytDst, sySrc })
-    return this.coreProgram.methods
-      .strip(new BN(syIn.toString()))
-      .accountsStrict(mainAccounts)
-      .remainingAccounts(remainingAccounts)
-      .instruction()
+    const ix = exponentCore.createStripInstruction(
+      mainAccounts,
+      {amount: syIn},
+    );
+    ix.keys.push(...remainingAccounts);
+    return ix
   }
 
   async ixStripFromBase({
@@ -387,14 +374,19 @@ export class Vault {
     ptDst: ptDstParam,
     ytDst: ytDstParam,
   }: {
-    owner: web3.PublicKey
+    owner: PublicKey
     amountBase: bigint
-    baseSrc?: web3.PublicKey
-    sySrc?: web3.PublicKey
-    ptDst?: web3.PublicKey
-    ytDst?: web3.PublicKey
-  }): Promise<web3.TransactionInstruction> {
-    const baseSrc = baseSrcParam || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
+    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)
@@ -412,9 +404,8 @@ export class Vault {
 
     const userYieldPosition = this.pda.yieldPosition({ owner, vault: this.selfAddress })
 
-    return this.coreProgram.methods
-      .wrapperStrip(new BN(amountBase.toString()), mintSyRemAccounts.length)
-      .accountsStrict({
+    const ix = exponentCore.createWrapperStripInstruction(
+      {
         depositor: owner,
         authority: this.authority,
         vault: this.selfAddress,
@@ -426,45 +417,49 @@ export class Vault {
         tokenYtDepositor: ytDst,
         escrowSy: this.escrowSy,
         tokenPtDepositor: ptDst,
-        systemProgram: web3.SystemProgram.programId,
+        systemProgram: SystemProgram.programId,
         vaultAddressLookupTable: this.addressLookupTable,
         vaultRobotYieldPosition: this.state.yieldPositonAddress,
         eventAuthority: this.eventAuthority,
-        program: this.coreProgram.programId,
+        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
         escrowYt: this.escrowYt,
         userYieldPosition,
-      })
-      .remainingAccounts(mintSyRemAccounts.concat(remainingAccounts))
-      .instruction()
+      },
+      { 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: web3.PublicKey
+    owner: PublicKey
+    payer?: PublicKey
     amountPy: bigint
-    ptSrc?: web3.PublicKey
-    ytSrc?: web3.PublicKey
-    syDst?: web3.PublicKey
-    baseDst?: web3.PublicKey
-  }): Promise<{ ixs: web3.TransactionInstruction[]; setupIxs: web3.TransactionInstruction[] }> {
+    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(owner, syDst, owner, this.mintSy)
-    const tokenPtTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(owner, ptSrc, owner, this.mintPt)
-    const tokenYtTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(owner, ytSrc, owner, this.mintYt)
+    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 || web3.PublicKey.default,
+      redeemerBaseTokenAccount: baseDst || PublicKey.default,
       redeemerSyTokenAccount: syDst,
     })
 
@@ -472,9 +467,8 @@ export class Vault {
 
     const remainingAccounts = uniqueRemainingAccounts([...this.cpiAccounts.withdrawSy, ...this.cpiAccounts.getSyState])
 
-    const ix = await this.coreProgram.methods
-      .wrapperMerge(new BN(amountPy.toString()), mintSyRemAccounts.length)
-      .accountsStrict({
+    const ix = exponentCore.createWrapperMergeInstruction(
+      {
         merger: owner,
         authority: this.authority,
         vault: this.selfAddress,
@@ -486,17 +480,22 @@ export class Vault {
         tokenYtMerger: ytSrc,
         tokenPtMerger: ptSrc,
         escrowSy: this.escrowSy,
-        systemProgram: web3.SystemProgram.programId,
+        systemProgram: SystemProgram.programId,
         vaultAddressLookupTable: this.addressLookupTable,
         vaultRobotYieldPosition: this.state.yieldPositonAddress,
         eventAuthority: this.eventAuthority,
-        program: this.coreProgram.programId,
-      })
-      .remainingAccounts(mintSyRemAccounts.concat(remainingAccounts))
-      .instruction()
+        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 }))],
+      ixs: [
+        ...(await this.flavor.preIxs({ signer: owner })),
+        ix,
+        ...(await this.flavor.postIxs({ signer: owner })),
+      ],
       setupIxs: [tokenSyTraderAtaIx, tokenPtTraderAtaIx, tokenYtTraderAtaIx],
     }
   }
@@ -510,53 +509,127 @@ export class Vault {
     syDst,
   }: {
     pyIn: bigint
-    depositor: web3.PublicKey
-    ptSrc?: web3.PublicKey
-    ytSrc?: web3.PublicKey
-    syDst?: web3.PublicKey
-  }): Promise<web3.TransactionInstruction> {
+    depositor: PublicKey
+    ptSrc?: PublicKey
+    ytSrc?: PublicKey
+    syDst?: PublicKey
+  }): 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()
+    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: web3.PublicKey }): Promise<web3.TransactionInstruction> {
+  ixInitializeYieldPosition({ owner }: { owner: PublicKey }): TransactionInstruction {
     const accounts = this.initializeYieldPositionAccounts({ owner })
 
-    return this.coreProgram.methods.initializeYieldPosition().accountsStrict(accounts.mainAccounts).instruction()
+    return exponentCore.createInitializeYieldPositionInstruction(accounts.mainAccounts)
   }
 
   /** Collect interest (as SY) from a yield position */
-  ixCollectInterest({ owner, amount, syDst }: { owner: web3.PublicKey; amount: ClaimAmount; syDst?: web3.PublicKey }) {
+  ixCollectInterest({ owner, amount, syDst }: { owner: PublicKey; amount: exponentCore.Amount; syDst?: PublicKey }): TransactionInstruction {
     const accounts = this.collectInterestAccounts({ owner, syDst })
-    return this.coreProgram.methods
-      .collectInterest(amount)
-      .accountsStrict(accounts.mainAccounts)
-      .remainingAccounts(accounts.remainingAccounts)
-      .instruction()
+    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 */
   /** Administrative action to configure a vault */
   ixConfigureVault({
     signer,
     action,
   }: {
-    signer: web3.PublicKey
-    action: AdminAction
-  }): Promise<web3.TransactionInstruction> {
+    signer: PublicKey
+    action: exponentCore.AdminAction
+  }): TransactionInstruction {
     const accounts = this.configureVaultAccounts({ signer })
 
-    return this.coreProgram.methods
-      .modifyVaultSetting(action)
-      .accountsStrict(accounts.mainAccounts)
-      .remainingAccounts(accounts.remainingAccounts)
-      .instruction()
+    const ix = exponentCore.createModifyVaultSettingInstruction(
+      accounts.mainAccounts,
+      { action },
+    )
+    ix.keys.push(...accounts.remainingAccounts)
+    return ix
   }
 
   collectEmissionAccounts({
@@ -565,9 +638,9 @@ export class Vault {
     emissionDst: emissionDstParam,
   }: {
     emissionIndex: number
-    owner: web3.PublicKey
-    emissionDst?: web3.PublicKey
-  }): InstructionAccounts<CollectEmissionAccounts> {
+    owner: PublicKey
+    emissionDst?: PublicKey
+  }): InstructionAccounts<CollectEmissionInstructionAccounts> {
     const syE = this.syEmissions[emissionIndex]
     if (!syE) {
       throw new Error("Emission index out of bounds")
@@ -600,7 +673,7 @@ export class Vault {
         position,
         tokenProgram,
         eventAuthority: this.eventAuthority,
-        program: this.coreProgram.programId,
+        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
       },
       remainingAccounts,
     }
@@ -612,11 +685,11 @@ export class Vault {
     ytDst: ytDstParam,
     sySrc: sySrcParam,
   }: {
-    depositor: web3.PublicKey
-    ptDst?: web3.PublicKey
-    ytDst?: web3.PublicKey
-    sySrc?: web3.PublicKey
-  }): InstructionAccounts<StripAccounts> {
+    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)
@@ -641,7 +714,7 @@ export class Vault {
         syProgram: this.state.syProgram,
         yieldPosition: this.state.yieldPositonAddress,
         eventAuthority: this.eventAuthority,
-        program: this.coreProgram.programId,
+        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
       },
       remainingAccounts,
     }
@@ -653,15 +726,13 @@ export class Vault {
     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: PublicKey
+    syDst: PublicKey
+    amount: exponentCore.Amount
+    kind: exponentCore.CollectTreasuryInterestKind
+  }): TransactionInstruction {
+    const ix = exponentCore.createCollectTreasuryInterestInstruction(
+      {
         signer,
         vault: this.selfAddress,
         admin: this.getAdminStatePda(),
@@ -670,10 +741,13 @@ export class Vault {
         syProgram: this.state.syProgram,
         tokenProgram: TOKEN_PROGRAM_ID,
         yieldPosition: this.state.yieldPositonAddress,
+        addressLookupTable: this.addressLookupTable,
         syDst,
-      })
-      .remainingAccounts(this.cpiAccounts.withdrawSy)
-      .instruction()
+      },
+      { amount, kind },
+    )
+    ix.keys.push(...this.cpiAccounts.withdrawSy)
+    return ix
   }
 
   ixCollectTreasuryEmission({
@@ -684,30 +758,31 @@ export class Vault {
     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,
+    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,
-        signer,
         syProgram: this.state.syProgram,
         tokenProgram: this.syEmissions[index].tokenProgramAddress,
         yieldPosition: this.state.yieldPositonAddress,
-      })
-      .remainingAccounts(this.cpiAccounts.claimEmission[index])
-      .instruction()
+        addressLookupTable: this.addressLookupTable,
+      },
+      { emissionIndex: index, amount, kind },
+    )
+    ix.keys.push(...this.cpiAccounts.claimEmission[index])
+    return ix
   }
 
-  async ixAddStandaloneEmission({
+  ixAddStandaloneEmission({
     signer,
     emissionMint,
     emissionTokenProgram = TOKEN_PROGRAM_ID,
@@ -716,20 +791,19 @@ export class Vault {
     altAddresses,
     cpiAccounts,
   }: {
-    signer: web3.PublicKey
-    emissionMint: web3.PublicKey
-    emissionTokenProgram?: web3.PublicKey
-    treasuryTokenAccountEmission: web3.PublicKey
+    signer: PublicKey
+    emissionMint: PublicKey
+    emissionTokenProgram?: PublicKey
+    treasuryTokenAccountEmission: PublicKey
     treasuryFeeBps: number
-    altAddresses: web3.PublicKey[]
+    altAddresses: 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({
+    const ix = exponentCore.createAddEmissionInstruction(
+      {
         vault: this.selfAddress,
         addressLookupTable: this.addressLookupTable,
         admin: this.getAdminStatePda(),
@@ -739,18 +813,19 @@ export class Vault {
         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()
+        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,
@@ -762,9 +837,9 @@ export class Vault {
     owner,
     syDst: syDstParam,
   }: {
-    owner: web3.PublicKey
-    syDst?: web3.PublicKey
-  }): InstructionAccounts<CollectInterestAccounts> {
+    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]
@@ -782,7 +857,7 @@ export class Vault {
         treasurySyTokenAccount: this.state.treasurySyTokenAccount,
         tokenSyDst: syDst,
         eventAuthority: this.eventAuthority,
-        program: this.coreProgram.programId,
+        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
       },
       remainingAccounts,
     }
@@ -795,11 +870,11 @@ export class Vault {
     ytSrc: ytSrcParam,
     syDst: syDstParam,
   }: {
-    owner: web3.PublicKey
-    ptSrc?: web3.PublicKey
-    ytSrc?: web3.PublicKey
-    syDst?: web3.PublicKey
-  }): InstructionAccounts<MergeAccounts> {
+    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)
@@ -820,7 +895,7 @@ export class Vault {
         tokenProgram: TOKEN_PROGRAM_ID,
         yieldPosition: this.state.yieldPositonAddress,
         eventAuthority: this.eventAuthority,
-        program: this.coreProgram.programId,
+        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
       },
       remainingAccounts,
     }
@@ -829,30 +904,30 @@ export class Vault {
   initializeYieldPositionAccounts({
     owner,
   }: {
-    owner: web3.PublicKey
-  }): InstructionAccounts<InitializeYieldPositionAccounts> {
+    owner: PublicKey
+  }): InstructionAccounts<InitializeYieldPositionInstructionAccounts> {
     const yieldPosition = this.pda.yieldPosition({ owner, vault: this.selfAddress })
     return {
       mainAccounts: {
         owner,
         vault: this.selfAddress,
         yieldPosition,
-        systemProgram: web3.SystemProgram.programId,
+        systemProgram: SystemProgram.programId,
         eventAuthority: this.eventAuthority,
-        program: this.coreProgram.programId,
+        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
       },
       remainingAccounts: [],
     }
   }
 
   /** Construct accounts for Merge instruction */
-  configureVaultAccounts({ signer }: { signer: web3.PublicKey }): InstructionAccounts<ConfigureVaultAccounts> {
+  configureVaultAccounts({ signer }: { signer: PublicKey }): InstructionAccounts<ModifyVaultSettingInstructionAccounts> {
     return {
       mainAccounts: {
         signer,
         vault: this.selfAddress,
         adminState: this.getAdminStatePda(),
-        systemProgram: web3.SystemProgram.programId,
+        systemProgram: SystemProgram.programId,
       },
       remainingAccounts: [],
     }
@@ -931,23 +1006,23 @@ export function deserializeVaultState(state: VaultStateJson): VaultState {
     syForPt: BigInt(state.syForPt),
     startTs: state.startTs,
     durationSeconds: state.durationSeconds,
-    authority: new web3.PublicKey(state.authority),
-    addressLookupTable: new web3.PublicKey(state.addressLookupTable),
+    authority: new PublicKey(state.authority),
+    addressLookupTable: new PublicKey(state.addressLookupTable),
     lastSeenSyExchangeRate: state.lastSeenSyExchangeRate,
     allTimeHighSyExchangeRate: state.allTimeHighSyExchangeRate,
-    escrowSy: new web3.PublicKey(state.escrowSy),
-    escrowYt: new web3.PublicKey(state.escrowYt),
-    syProgram: new web3.PublicKey(state.syProgram),
+    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 web3.PublicKey(state.mintPt),
+    mintPt: new PublicKey(state.mintPt),
     status: state.status,
     minOperationSizeStrip: BigInt(state.minOperationSizeStrip),
     minOperationSizeMerge: BigInt(state.minOperationSizeMerge),
-    mintYt: new web3.PublicKey(state.mintYt),
-    mintSy: new web3.PublicKey(state.mintSy),
-    yieldPositonAddress: new web3.PublicKey(state.yieldPositonAddress),
-    treasurySyTokenAccount: new web3.PublicKey(state.treasurySyTokenAccount),
+    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),
@@ -956,123 +1031,3 @@ export function deserializeVaultState(state: VaultStateJson): VaultState {
     maxPySupply: BigInt(state.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
-      }
-    }