@exponent-labs/exponent-sdk 0.1.7 → 0.9.0

package/src/ytPosition.ts

@@ -1,33 +1,27 @@
-import { AnchorProvider, BN, Program, web3 } from "@coral-xyz/anchor"
 import { TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync } from "@solana/spl-token"
 
 import { ExponentFetcher, YieldTokenTracker, YtPosition as YtPositionState } from "@exponent-labs/exponent-fetcher"
-import { ExponentCore, IDL } from "@exponent-labs/exponent-idl"
 import { ExponentPDA } from "@exponent-labs/exponent-pda"
 import { VaultJson } from "@exponent-labs/exponent-types"
-import { ClaimAmount } from "@exponent-labs/marginfi-sy-sdk"
 import { PreciseNumber } from "@exponent-labs/precise-number"
+import * as exponentCore from "./client/core"
 
 import { Environment } from "./environment"
-import { MyWallet } from "./market"
 import { InstructionAccounts } from "./utils"
 import { Vault } from "./vault"
+import { Connection, PublicKey, SystemProgram } from "@solana/web3.js"
 
 export class YtPosition {
-  public coreProgram: Program<ExponentCore>
   constructor(
     public env: Environment,
-    public connection: web3.Connection,
-    public selfAddress: web3.PublicKey,
+    public connection: Connection,
+    public selfAddress: PublicKey,
     public state: YtPositionState,
     public vault: Vault,
-  ) {
-    const mockWallet = new MyWallet(web3.Keypair.generate())
-    this.coreProgram = new Program<ExponentCore>(IDL as ExponentCore, new AnchorProvider(connection, mockWallet))
-  }
+  ) {}
 
   /** Loads the YT position by address, and loads Vault, too */
-  static async load(env: Environment, connection: web3.Connection, address: web3.PublicKey, vault?: Vault) {
+  static async load(env: Environment, connection: Connection, address: PublicKey, vault?: Vault) {
     const fetcher = new ExponentFetcher({ connection })
     const ytPositionState = await fetcher.fetchYtPosition(address)
     const loadedVault = vault ?? (await Vault.load(env, connection, ytPositionState.vault))
@@ -35,7 +29,7 @@ export class YtPosition {
   }
 
   /** Loads the YT position by owner, but require a loaded Vault */
-  static async loadByOwner(env: Environment, connection: web3.Connection, owner: web3.PublicKey, vault: Vault) {
+  static async loadByOwner(env: Environment, connection: Connection, owner: PublicKey, vault: Vault) {
     const pda = new ExponentPDA(env.coreProgramId)
     const address = pda.yieldPosition({ vault: vault.selfAddress, owner })
     const fetcher = new ExponentFetcher({ connection })
@@ -45,20 +39,46 @@ export class YtPosition {
 
   static async loadAllByOwner(
     env: Environment,
-    connection: web3.Connection,
-    owner: web3.PublicKey,
-    vaults: (Vault | web3.PublicKey)[],
+    connection: Connection,
+    owner: PublicKey,
+    vaults: (Vault | PublicKey)[],
   ) {
     const pda = new ExponentPDA(env.coreProgramId)
     const addresses = vaults.map((v) =>
       pda.yieldPosition({
-        vault: v instanceof web3.PublicKey ? v : v.selfAddress,
+        vault: v instanceof PublicKey ? v : v.selfAddress,
         owner,
       }),
     )
     return Promise.all(addresses.map((addr) => YtPosition.load(env, connection, addr)))
   }
 
+  /** Batch load multiple YT positions in a single RPC call */
+  static async loadBatch(
+    env: Environment,
+    connection: Connection,
+    owner: PublicKey,
+    vaults: Vault[],
+  ): Promise<(YtPosition | null)[]> {
+    if (vaults.length === 0) return []
+
+    const pda = new ExponentPDA(env.coreProgramId)
+    const addresses = vaults.map((vault) =>
+      pda.yieldPosition({
+        vault: vault.selfAddress,
+        owner,
+      }),
+    )
+
+    const fetcher = new ExponentFetcher({ connection })
+    const positions = await fetcher.fetchYtPositions(addresses)
+
+    return positions.map((state, index) => {
+      if (!state) return null
+      return new YtPosition(env, connection, addresses[index], state, vaults[index])
+    })
+  }
+
   async reload(connection = this.connection) {
     const x = await YtPosition.load(this.env, connection, this.selfAddress)
     this.state = x.state
@@ -112,19 +132,14 @@ export class YtPosition {
     return this.vault.syEmissions.map((e, index) => {
       // Use initial index if user doesn't have a position yet (lastSeenIndex is 0)
       const lastSeenIndex = this.state.emissions[index]?.lastSeenIndex ?? 0
-      console.log("lastSeenIndex: ", lastSeenIndex)
+      // console.log("lastSeenIndex: ", lastSeenIndex)
 
       // use finalIndex from the vault's emissions
       const finalIndex = Number(
         PreciseNumber.fromRaw(this.vault.state.emissions[index]?.finalIndex?.[0] || e.index[0]).valueString,
       )
 
-      console.log("finalIndex: ", finalIndex)
-      console.log("totalSyBalance: ", totalSyBalance)
-      console.log("finalIndex - lastSeenIndex: ", finalIndex - Number(lastSeenIndex))
-
       const earnedEmission = totalSyBalance * (finalIndex - Number(lastSeenIndex))
-      console.log("earnedEmission: ", earnedEmission)
 
       return {
         mint: e.mint,
@@ -134,64 +149,59 @@ export class YtPosition {
   }
 
   /** Instruction for depositing YT into the vault */
-  ixDepositYt({ amount, ytSrc }: { amount: bigint; ytSrc?: web3.PublicKey }) {
+  ixDepositYt({ amount, ytSrc }: { amount: bigint; ytSrc?: PublicKey }) {
     const { mainAccounts, remainingAccounts } = this.depositYtAccounts({ ytSrc })
-    return this.coreProgram.methods
-      .depositYt(new BN(amount.toString()))
-      .accountsStrict(mainAccounts)
-      .remainingAccounts(remainingAccounts)
-      .instruction()
+    const ix = exponentCore.createDepositYtInstruction(mainAccounts, { amount })
+    ix.keys.push(...remainingAccounts)
+    return ix
   }
 
   /** Instruction for withdrawing YT from the vault */
-  ixWithdrawYt({ amount, ytDst }: { amount: bigint; ytDst?: web3.PublicKey }) {
+  ixWithdrawYt({ amount, ytDst }: { amount: bigint; ytDst?: PublicKey }) {
     const { mainAccounts, remainingAccounts } = this.withdrawYtAccounts({ ytDst })
-    return this.coreProgram.methods
-      .withdrawYt(new BN(amount.toString()))
-      .accountsStrict(mainAccounts)
-      .remainingAccounts(remainingAccounts)
-      .instruction()
+    const ix = exponentCore.createWithdrawYtInstruction(mainAccounts, { amount })
+    ix.keys.push(...remainingAccounts)
+    return ix
   }
 
-  ixStageYield({ payer }: { payer: web3.PublicKey }) {
-    return this.coreProgram.methods
-      .stageYtYield()
-      .accountsStrict({
-        addressLookupTable: this.vault.addressLookupTable,
-        vault: this.vault.selfAddress,
-        payer,
-        syProgram: this.vault.state.syProgram,
-        yieldPosition: this.vault.state.yieldPositonAddress, // Misspelled word
-        systemProgram: web3.SystemProgram.programId,
-        userYieldPosition: this.selfAddress,
-        eventAuthority: this.vault.eventAuthority,
-        program: this.coreProgram.programId,
-      })
-      .remainingAccounts(this.vault.cpiAccounts.getSyState)
-      .instruction()
+  ixStageYield({ payer }: { payer: PublicKey }) {
+    const ix = exponentCore.createStageYtYieldInstruction({
+      payer,
+      vault: this.vault.selfAddress,
+      userYieldPosition: this.selfAddress,
+      yieldPosition: this.vault.state.yieldPositonAddress,
+      syProgram: this.vault.state.syProgram,
+      addressLookupTable: this.vault.addressLookupTable,
+      systemProgram: SystemProgram.programId,
+      eventAuthority: this.vault.eventAuthority,
+      program: exponentCore.EXPONENTCORE_PROGRAM_ID,
+    })
+    ix.keys.push(...this.vault.cpiAccounts.getSyState)
+    return ix
   }
 
-  ixCollectInterest({ signer, syDst, amount }: { signer: web3.PublicKey; syDst?: web3.PublicKey; amount?: bigint }) {
+  ixCollectInterest({ signer, syDst, amount }: { signer: PublicKey; syDst?: PublicKey; amount?: bigint }) {
     const tokenSyDst = syDst || getAssociatedTokenAddressSync(this.vault.mintSy, signer, true, TOKEN_PROGRAM_ID)
-    const claimAmount: ClaimAmount = amount !== undefined ? { some: { 0: new BN(amount.toString()) } } : { all: {} }
-    return this.coreProgram.methods
-      .collectInterest(claimAmount)
-      .accountsStrict({
-        addressLookupTable: this.vault.addressLookupTable,
-        authority: this.vault.authority,
-        vault: this.vault.selfAddress,
-        syProgram: this.vault.state.syProgram,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        yieldPosition: this.selfAddress,
+    const claimAmount = amount !== undefined ? exponentCore.amount("Some", [amount]) : exponentCore.amount("All")
+    const ix = exponentCore.createCollectInterestInstruction(
+      {
         owner: signer,
+        yieldPosition: this.selfAddress,
+        vault: this.vault.selfAddress,
+        tokenSyDst,
         escrowSy: this.vault.state.escrowSy,
+        authority: this.vault.authority,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        syProgram: this.vault.state.syProgram,
         treasurySyTokenAccount: this.vault.state.treasurySyTokenAccount,
-        tokenSyDst,
+        addressLookupTable: this.vault.addressLookupTable,
         eventAuthority: this.vault.eventAuthority,
-        program: this.coreProgram.programId,
-      })
-      .remainingAccounts(this.vault.cpiAccounts.withdrawSy)
-      .instruction()
+        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
+      },
+      { amount: claimAmount },
+    )
+    ix.keys.push(...this.vault.cpiAccounts.withdrawSy)
+    return ix
   }
 
   ixCollectEmission({
@@ -200,38 +210,39 @@ export class YtPosition {
     emissionDst: emissionDstParam,
     amount,
   }: {
-    owner: web3.PublicKey
+    owner: PublicKey
     emissionIndex: number
-    emissionDst?: web3.PublicKey
+    emissionDst?: PublicKey
     amount?: bigint
   }) {
     const emission = this.vault.state.emissions[emissionIndex]
     const emissionSy = this.vault.flavor.emissions[emissionIndex]
     const emissionDst =
       emissionDstParam || getAssociatedTokenAddressSync(emissionSy.mint, owner, true, emissionSy.tokenProgram)
-    const claimAmount: ClaimAmount = amount !== undefined ? { some: { 0: new BN(amount.toString()) } } : { all: {} }
+    const claimAmount = amount !== undefined ? exponentCore.amount("Some", [amount]) : exponentCore.amount("All")
 
-    return this.coreProgram.methods
-      .collectEmission(emissionIndex, claimAmount)
-      .accountsStrict({
-        addressLookupTable: this.vault.addressLookupTable,
-        authority: this.vault.authority,
-        emissionEscrow: emission.tokenAccount,
+    const ix = exponentCore.createCollectEmissionInstruction(
+      {
+        owner,
         vault: this.selfAddress,
+        position: this.selfAddress,
         syProgram: this.vault.state.syProgram,
-        owner,
-        treasuryEmissionTokenAccount: emission.treasuryTokenAccount,
+        authority: this.vault.authority,
+        emissionEscrow: emission.tokenAccount,
         emissionDst,
-        position: this.selfAddress,
+        addressLookupTable: this.vault.addressLookupTable,
+        treasuryEmissionTokenAccount: emission.treasuryTokenAccount,
         tokenProgram: this.vault.flavor.emissions[emissionIndex].tokenProgram,
         eventAuthority: this.vault.eventAuthority,
-        program: this.coreProgram.programId,
-      })
-      .remainingAccounts(this.vault.cpiAccounts.claimEmission[emissionIndex])
-      .instruction()
+        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
+      },
+      { index: emissionIndex, amount: claimAmount },
+    )
+    ix.keys.push(...this.vault.cpiAccounts.claimEmission[emissionIndex])
+    return ix
   }
 
-  depositYtAccounts({ ytSrc: ytSrcParam }: { ytSrc?: web3.PublicKey }): InstructionAccounts<DepositYtAccounts> {
+  depositYtAccounts({ ytSrc: ytSrcParam }: { ytSrc?: PublicKey }): InstructionAccounts<exponentCore.DepositYtInstructionAccounts> {
     const ytSrc = ytSrcParam || getAssociatedTokenAddressSync(this.vault.mintYt, this.owner, true, TOKEN_PROGRAM_ID)
     return {
       mainAccounts: {
@@ -244,15 +255,15 @@ export class YtPosition {
         syProgram: this.vault.state.syProgram,
         addressLookupTable: this.vault.addressLookupTable,
         yieldPosition: this.vault.state.yieldPositonAddress,
-        systemProgram: web3.SystemProgram.programId,
+        systemProgram: SystemProgram.programId,
         eventAuthority: this.vault.eventAuthority,
-        program: this.coreProgram.programId,
+        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
       },
       remainingAccounts: this.vault.cpiAccounts.getSyState,
     }
   }
 
-  withdrawYtAccounts({ ytDst: ytDstParam }: { ytDst?: web3.PublicKey }): InstructionAccounts<WithdrawYtAccounts> {
+  withdrawYtAccounts({ ytDst: ytDstParam }: { ytDst?: PublicKey }): InstructionAccounts<exponentCore.WithdrawYtInstructionAccounts> {
     const ytDst = ytDstParam || getAssociatedTokenAddressSync(this.vault.mintYt, this.owner, true, TOKEN_PROGRAM_ID)
     return {
       mainAccounts: {
@@ -266,9 +277,9 @@ export class YtPosition {
         syProgram: this.vault.state.syProgram,
         addressLookupTable: this.vault.addressLookupTable,
         yieldPosition: this.vault.state.yieldPositonAddress,
-        systemProgram: web3.SystemProgram.programId,
+        systemProgram: SystemProgram.programId,
         eventAuthority: this.vault.eventAuthority,
-        program: this.coreProgram.programId,
+        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
       },
       remainingAccounts: this.vault.cpiAccounts.getSyState,
     }
@@ -306,36 +317,3 @@ function yieldTokenTrackerToJson(yieldTokenTracker: YieldTokenTracker): YieldTok
     staged: yieldTokenTracker.staged.toString(),
   }
 }
-
-type DepositYtAccounts = {
-  [K in
-    | "depositor"
-    | "vault"
-    | "userYieldPosition"
-    | "ytSrc"
-    | "escrowYt"
-    | "tokenProgram"
-    | "syProgram"
-    | "addressLookupTable"
-    | "yieldPosition"
-    | "systemProgram"
-    | "eventAuthority"
-    | "program"]: web3.PublicKey
-}
-
-type WithdrawYtAccounts = {
-  [K in
-    | "owner"
-    | "vault"
-    | "userYieldPosition"
-    | "ytDst"
-    | "escrowYt"
-    | "tokenProgram"
-    | "authority"
-    | "syProgram"
-    | "addressLookupTable"
-    | "yieldPosition"
-    | "systemProgram"
-    | "eventAuthority"
-    | "program"]: web3.PublicKey
-}

package/tsconfig.json

@@ -22,7 +22,9 @@
     { "path": "../marginfi-sy-pda" },
     { "path": "../market-math" },
     { "path": "../marginfi-util" },
+    { "path": "../loopscale-deserializer" },
     { "path": "../exponent-pda" },
+    { "path": "../exponent-clmm-pda" },
     { "path": "../marginfi-sy-sdk" },
     { "path": "../kamino-sy-sdk" },
     { "path": "../exponent-types" },
@@ -33,6 +35,12 @@
     { "path": "../perena-sy-pda" },
     { "path": "../generic-sy-sdk" },
     { "path": "../generic-sy-idl" },
-    { "path": "../generic-sy-pda" }
+    { "path": "../generic-sy-pda" },
+    { "path": "../exponent-orderbook-idl" },
+    { "path": "../exponent-vaults-idl" },
+    { "path": "../exponent-vaults-pda" },
+    { "path": "../exponent-vaults-fetcher" },
+    { "path": "../market-three-math" },
+    { "path": "../klend-idl" }
   ]
 }