@exponent-labs/exponent-sdk 0.0.9 → 0.1.0

package/src/ytPosition.ts

@@ -1,15 +1,17 @@
 import { AnchorProvider, BN, Program, web3 } from "@coral-xyz/anchor"
-import { ExponentCore, IDL } from "@exponent-labs/exponent-idl"
-import { Environment } from "./environment"
+import { TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync } from "@solana/spl-token"
+
 import { ExponentFetcher, YieldTokenTracker, YtPosition as YtPositionState } from "@exponent-labs/exponent-fetcher"
-import { Vault } from "./vault"
-import { getAssociatedTokenAddressSync, TOKEN_PROGRAM_ID } from "@solana/spl-token"
-import { InstructionAccounts } from "./utils"
+import { ExponentCore, IDL } from "@exponent-labs/exponent-idl"
 import { ExponentPDA } from "@exponent-labs/exponent-pda"
-import { MyWallet } from "./market"
 import { VaultJson } from "@exponent-labs/exponent-types"
-import { PreciseNumber } from "@exponent-labs/precise-number"
 import { ClaimAmount } from "@exponent-labs/marginfi-sy-sdk"
+import { PreciseNumber } from "@exponent-labs/precise-number"
+
+import { Environment } from "./environment"
+import { MyWallet } from "./market"
+import { InstructionAccounts } from "./utils"
+import { Vault } from "./vault"
 
 export class YtPosition {
   public coreProgram: Program<ExponentCore>
@@ -27,11 +29,11 @@ export class YtPosition {
   /** Loads the YT position by address, and loads Vault, too
    * DEPRECATED - use loadByOwner instead - loading the vault is expensive
    */
-  static async load(env: Environment, connection: web3.Connection, address: web3.PublicKey) {
+  static async load(env: Environment, connection: web3.Connection, address: web3.PublicKey, vault?: Vault) {
     const fetcher = new ExponentFetcher({ connection })
-    const x = await fetcher.fetchYtPosition(address)
-    const vault = await Vault.load(env, connection, x.vault)
-    return new YtPosition(env, connection, address, x, vault)
+    const ytPositionState = await fetcher.fetchYtPosition(address)
+    const loadedVault = vault ?? (await Vault.load(env, connection, ytPositionState.vault))
+    return new YtPosition(env, connection, address, ytPositionState, loadedVault)
   }
 
   /** Loads the YT position by owner, but require a loaded Vault */
@@ -39,12 +41,28 @@ export class YtPosition {
     const pda = new ExponentPDA(env.coreProgramId)
     const address = pda.yieldPosition({ vault: vault.selfAddress, owner })
     const fetcher = new ExponentFetcher({ connection })
-    const x = await fetcher.fetchYtPosition(address)
-    return new YtPosition(env, connection, address, x, vault)
+    const ytPositionState = await fetcher.fetchYtPosition(address)
+    return new YtPosition(env, connection, address, ytPositionState, vault)
   }
 
-  async reload(conn = this.connection) {
-    const x = await YtPosition.load(this.env, conn, this.selfAddress)
+  static async loadAllByOwner(
+    env: Environment,
+    connection: web3.Connection,
+    owner: web3.PublicKey,
+    vaults: (Vault | web3.PublicKey)[],
+  ) {
+    const pda = new ExponentPDA(env.coreProgramId)
+    const addresses = vaults.map((v) =>
+      pda.yieldPosition({
+        vault: v instanceof web3.PublicKey ? v : v.selfAddress,
+        owner,
+      }),
+    )
+    return Promise.all(addresses.map((addr) => YtPosition.load(env, connection, addr)))
+  }
+
+  async reload(connection = this.connection) {
+    const x = await YtPosition.load(this.env, connection, this.selfAddress)
     this.state = x.state
     return x
   }
@@ -72,16 +90,17 @@ export class YtPosition {
    */
   getClaimableInterest(currentIndex: number): number {
     const interestDelta = 1 / this.state.interest.lastSeenIndex - 1 / currentIndex
-    let toCollectSy = Math.floor(
+
+    const toCollectSy = Math.floor(
       Number(this.state.ytBalance.toString()) * interestDelta + Number(this.state.interest.staged),
     )
 
     // Ensure toCollectSy is not negative
-    toCollectSy = Math.max(0, toCollectSy)
+    const toCollectSySafe = Math.max(0, toCollectSy)
 
-    const feeSy = Math.floor((toCollectSy * this.vault.state.interestBpsFee + 9999) / 10000)
-    const userSy = Math.max(0, toCollectSy - feeSy)
-    let baseAmount = Math.floor(userSy * currentIndex)
+    const feeSy = Math.floor((toCollectSySafe * this.vault.state.interestBpsFee + 9999) / 10000)
+    const userSy = Math.max(0, toCollectSySafe - feeSy)
+    const baseAmount = Math.floor(userSy * currentIndex)
 
     // Ensure final amount is non-negative
     return Math.max(0, baseAmount > 0 ? baseAmount - 1 : baseAmount)
@@ -134,7 +153,7 @@ export class YtPosition {
         vault: this.vault.selfAddress,
         payer,
         syProgram: this.vault.state.syProgram,
-        yieldPosition: this.vault.state.yieldPositonAddress,
+        yieldPosition: this.vault.state.yieldPositonAddress, // Misspelled word
         systemProgram: web3.SystemProgram.programId,
         userYieldPosition: this.selfAddress,
         eventAuthority: this.vault.eventAuthority,
@@ -170,7 +189,7 @@ export class YtPosition {
   ixCollectEmission({
     owner,
     emissionIndex,
-    emissionDst,
+    emissionDst: emissionDstParam,
     amount,
   }: {
     owner: web3.PublicKey
@@ -180,7 +199,8 @@ export class YtPosition {
   }) {
     const emission = this.vault.state.emissions[emissionIndex]
     const emissionSy = this.vault.flavor.emissions[emissionIndex]
-    emissionDst = emissionDst || getAssociatedTokenAddressSync(emissionSy.mint, owner, true, emissionSy.tokenProgram)
+    const emissionDst =
+      emissionDstParam || getAssociatedTokenAddressSync(emissionSy.mint, owner, true, emissionSy.tokenProgram)
     const claimAmount: ClaimAmount = amount !== undefined ? { some: { 0: new BN(amount.toString()) } } : { all: {} }
 
     return this.coreProgram.methods
@@ -203,8 +223,8 @@ export class YtPosition {
       .instruction()
   }
 
-  depositYtAccounts({ ytSrc }: { ytSrc?: web3.PublicKey }): InstructionAccounts<DepositYtAccounts> {
-    ytSrc = ytSrc || getAssociatedTokenAddressSync(this.vault.mintYt, this.owner, true, TOKEN_PROGRAM_ID)
+  depositYtAccounts({ ytSrc: ytSrcParam }: { ytSrc?: web3.PublicKey }): InstructionAccounts<DepositYtAccounts> {
+    const ytSrc = ytSrcParam || getAssociatedTokenAddressSync(this.vault.mintYt, this.owner, true, TOKEN_PROGRAM_ID)
     return {
       mainAccounts: {
         depositor: this.owner,
@@ -224,8 +244,8 @@ export class YtPosition {
     }
   }
 
-  withdrawYtAccounts({ ytDst }: { ytDst?: web3.PublicKey }): InstructionAccounts<WithdrawYtAccounts> {
-    ytDst = ytDst || getAssociatedTokenAddressSync(this.vault.mintYt, this.owner, true, TOKEN_PROGRAM_ID)
+  withdrawYtAccounts({ ytDst: ytDstParam }: { ytDst?: web3.PublicKey }): InstructionAccounts<WithdrawYtAccounts> {
+    const ytDst = ytDstParam || getAssociatedTokenAddressSync(this.vault.mintYt, this.owner, true, TOKEN_PROGRAM_ID)
     return {
       mainAccounts: {
         owner: this.owner,
@@ -261,21 +281,21 @@ export type YieldTokenTrackerJson = {
   staged: string
 }
 
-function ytPositionToJson(x: YtPosition): YtPositionJson {
+function ytPositionToJson(ytPosition: YtPosition): YtPositionJson {
   return {
-    owner: x.owner.toBase58(),
-    ytBalance: x.ytBalance.toString(),
-    interest: yieldTokenTrackerToJson(x.state.interest),
-    emissions: x.state.emissions.map(yieldTokenTrackerToJson),
-    claimableInterest: x.getClaimableInterest(x.vault.currentSyExchangeRate),
-    vault: x.vault.toJson(),
+    owner: ytPosition.owner.toBase58(),
+    ytBalance: ytPosition.ytBalance.toString(),
+    interest: yieldTokenTrackerToJson(ytPosition.state.interest),
+    emissions: ytPosition.state.emissions.map(yieldTokenTrackerToJson),
+    claimableInterest: ytPosition.getClaimableInterest(ytPosition.vault.currentSyExchangeRate),
+    vault: ytPosition.vault.toJson(),
   }
 }
 
-function yieldTokenTrackerToJson(x: YieldTokenTracker): YieldTokenTrackerJson {
+function yieldTokenTrackerToJson(yieldTokenTracker: YieldTokenTracker): YieldTokenTrackerJson {
   return {
-    lastSeenIndex: x.lastSeenIndex,
-    staged: x.staged.toString(),
+    lastSeenIndex: yieldTokenTracker.lastSeenIndex,
+    staged: yieldTokenTracker.staged.toString(),
   }
 }