@exponent-labs/exponent-sdk 0.0.3

package/src/ytPosition.ts

@@ -0,0 +1,313 @@
+import { AnchorProvider, BN, Program, web3 } from "@coral-xyz/anchor"
+import { ExponentCore, IDL } from "@exponent-labs/exponent-idl"
+import { Environment } from "./environment"
+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 { ClaimAmount } from "@exponent-labs/exponent-ix"
+import { InstructionAccounts } from "./utils"
+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"
+
+export class YtPosition {
+  public coreProgram: Program<ExponentCore>
+  constructor(
+    public env: Environment,
+    public connection: web3.Connection,
+    public selfAddress: web3.PublicKey,
+    public state: YtPositionState,
+    public vault: Vault,
+  ) {
+    const mockWallet = new MyWallet(web3.Keypair.generate())
+    this.coreProgram = new Program(IDL as ExponentCore, new AnchorProvider(connection, mockWallet))
+  }
+
+  /** 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) {
+    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)
+  }
+
+  /** Loads the YT position by owner, but require a loaded Vault */
+  static async loadByOwner(env: Environment, connection: web3.Connection, owner: web3.PublicKey, vault: Vault) {
+    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)
+  }
+
+  async reload(conn = this.connection) {
+    const x = await YtPosition.load(this.env, conn, this.selfAddress)
+    this.state = x.state
+    return x
+  }
+
+  toJson(): YtPositionJson {
+    return ytPositionToJson(this)
+  }
+
+  get ytBalance() {
+    return this.state.ytBalance
+  }
+
+  get owner() {
+    return this.state.owner
+  }
+
+  get stagedInterest(): bigint {
+    return this.state.interest.staged
+  }
+
+  /**
+   * Returns the claimable interest in base amount
+   * @param currentIndex - The current SY exchange rate for the vault's SY token
+   * @returns The claimable interest in raw base token units
+   */
+  getClaimableInterest(currentIndex: number): number {
+    const interestDelta = 1 / this.state.interest.lastSeenIndex - 1 / currentIndex
+    let 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 feeSy = Math.floor((toCollectSy * this.vault.state.interestBpsFee + 9999) / 10000)
+    const userSy = Math.max(0, toCollectSy - feeSy)
+    let baseAmount = Math.floor(userSy * currentIndex)
+
+    // Ensure final amount is non-negative
+    return Math.max(0, baseAmount > 0 ? baseAmount - 1 : baseAmount)
+  }
+
+  getClaimableEmissions() {
+    // Calculate total SY balance (staged + converted YT balance)
+    const totalSyBalance =
+      Number(this.state.interest.staged) + Number(this.state.ytBalance) / this.vault.currentSyExchangeRate
+
+    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
+
+      const earnedEmission =
+        totalSyBalance * (Number(PreciseNumber.fromRaw(e.index[0]).valueString) - Number(lastSeenIndex))
+
+      return {
+        mint: e.mint,
+        amount: Math.floor(earnedEmission) + Number(this.state.emissions[index]?.staged ?? 0),
+      }
+    })
+  }
+
+  /** Instruction for depositing YT into the vault */
+  ixDepositYt({ amount, ytSrc }: { amount: bigint; ytSrc?: web3.PublicKey }) {
+    const { mainAccounts, remainingAccounts } = this.depositYtAccounts({ ytSrc })
+    return this.coreProgram.methods
+      .depositYt(new BN(amount.toString()))
+      .accountsStrict(mainAccounts)
+      .remainingAccounts(remainingAccounts)
+      .instruction()
+  }
+
+  /** Instruction for withdrawing YT from the vault */
+  ixWithdrawYt({ amount, ytDst }: { amount: bigint; ytDst?: web3.PublicKey }) {
+    const { mainAccounts, remainingAccounts } = this.withdrawYtAccounts({ ytDst })
+    return this.coreProgram.methods
+      .withdrawYt(new BN(amount.toString()))
+      .accountsStrict(mainAccounts)
+      .remainingAccounts(remainingAccounts)
+      .instruction()
+  }
+
+  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,
+        systemProgram: web3.SystemProgram.programId,
+        userYieldPosition: this.selfAddress,
+        eventAuthority: this.vault.eventAuthority,
+        program: this.coreProgram.programId,
+      })
+      .remainingAccounts(this.vault.cpiAccounts.getSyState)
+      .instruction()
+  }
+
+  ixCollectInterest({ signer, syDst, amount }: { signer: web3.PublicKey; syDst?: web3.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,
+        owner: signer,
+        escrowSy: this.vault.state.escrowSy,
+        treasurySyTokenAccount: this.vault.state.treasurySyTokenAccount,
+        tokenSyDst,
+        eventAuthority: this.vault.eventAuthority,
+        program: this.coreProgram.programId,
+      })
+      .remainingAccounts(this.vault.cpiAccounts.withdrawSy)
+      .instruction()
+  }
+
+  ixCollectEmission({
+    owner,
+    emissionIndex,
+    emissionDst,
+    amount,
+  }: {
+    owner: web3.PublicKey
+    emissionIndex: number
+    emissionDst?: web3.PublicKey
+    amount?: bigint
+  }) {
+    const emission = this.vault.state.emissions[emissionIndex]
+    const emissionSy = this.vault.flavor.emissions[emissionIndex]
+    emissionDst = emissionDst || getAssociatedTokenAddressSync(emissionSy.mint, owner, true, emissionSy.tokenProgram)
+    const claimAmount: ClaimAmount = amount !== undefined ? { some: { 0: new BN(amount.toString()) } } : { all: {} }
+
+    return this.coreProgram.methods
+      .collectEmission(emissionIndex, claimAmount)
+      .accountsStrict({
+        addressLookupTable: this.vault.addressLookupTable,
+        authority: this.vault.authority,
+        emissionEscrow: emission.tokenAccount,
+        vault: this.selfAddress,
+        syProgram: this.vault.state.syProgram,
+        owner,
+        treasuryEmissionTokenAccount: emission.treasuryTokenAccount,
+        emissionDst,
+        position: this.selfAddress,
+        tokenProgram: this.vault.flavor.emissions[emissionIndex].tokenProgram,
+        eventAuthority: this.vault.eventAuthority,
+        program: this.coreProgram.programId,
+      })
+      .remainingAccounts(this.vault.cpiAccounts.claimEmission[emissionIndex])
+      .instruction()
+  }
+
+  depositYtAccounts({ ytSrc }: { ytSrc?: web3.PublicKey }): InstructionAccounts<DepositYtAccounts> {
+    ytSrc = ytSrc || getAssociatedTokenAddressSync(this.vault.mintYt, this.owner, true, TOKEN_PROGRAM_ID)
+    return {
+      mainAccounts: {
+        depositor: this.owner,
+        ytSrc,
+        vault: this.vault.selfAddress,
+        userYieldPosition: this.selfAddress,
+        escrowYt: this.vault.state.escrowYt,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        syProgram: this.vault.state.syProgram,
+        addressLookupTable: this.vault.addressLookupTable,
+        yieldPosition: this.vault.state.yieldPositonAddress,
+        systemProgram: web3.SystemProgram.programId,
+        eventAuthority: this.vault.eventAuthority,
+        program: this.coreProgram.programId,
+      },
+      remainingAccounts: this.vault.cpiAccounts.getSyState,
+    }
+  }
+
+  withdrawYtAccounts({ ytDst }: { ytDst?: web3.PublicKey }): InstructionAccounts<WithdrawYtAccounts> {
+    ytDst = ytDst || getAssociatedTokenAddressSync(this.vault.mintYt, this.owner, true, TOKEN_PROGRAM_ID)
+    return {
+      mainAccounts: {
+        owner: this.owner,
+        vault: this.vault.selfAddress,
+        userYieldPosition: this.selfAddress,
+        ytDst,
+        escrowYt: this.vault.state.escrowYt,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        authority: this.vault.authority,
+        syProgram: this.vault.state.syProgram,
+        addressLookupTable: this.vault.addressLookupTable,
+        yieldPosition: this.vault.state.yieldPositonAddress,
+        systemProgram: web3.SystemProgram.programId,
+        eventAuthority: this.vault.eventAuthority,
+        program: this.coreProgram.programId,
+      },
+      remainingAccounts: this.vault.cpiAccounts.getSyState,
+    }
+  }
+}
+
+export type YtPositionJson = {
+  owner: string
+  ytBalance: string
+  interest: YieldTokenTrackerJson
+  claimableInterest: number
+  emissions: YieldTokenTrackerJson[]
+  vault: VaultJson
+}
+
+export type YieldTokenTrackerJson = {
+  lastSeenIndex: number
+  staged: string
+}
+
+function ytPositionToJson(x: 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(),
+  }
+}
+
+function yieldTokenTrackerToJson(x: YieldTokenTracker): YieldTokenTrackerJson {
+  return {
+    lastSeenIndex: x.lastSeenIndex,
+    staged: x.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

@@ -0,0 +1,38 @@
+{
+  "compilerOptions": {
+    "rootDir": "src",
+    "sourceMap": true,
+    "incremental": true /* Save .tsbuildinfo files to allow for incremental compilation of projects. */,
+    "composite": true /* Enable constraints that allow a TypeScript project to be used with project references. */,
+    "target": "ESNext" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
+    "module": "CommonJS" /* Specify what module code is generated. */,
+    "declaration": true /* Generate .d.ts files from TypeScript and JavaScript files in your project. */,
+    "outDir": "./build" /* Specify an output folder for all emitted files. */,
+    "esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */,
+    "forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,
+    "skipLibCheck": true /* Skip type checking all .d.ts files. */,
+    "types": ["jest"]
+  },
+
+  "include": ["src"],
+  "exclude": ["build"],
+  "references": [
+    { "path": "../exponent-idl" },
+    { "path": "../exponent-fetcher" },
+    { "path": "../marginfi-sy-pda" },
+    { "path": "../market-math" },
+    { "path": "../marginfi-util" },
+    { "path": "../exponent-pda" },
+    { "path": "../marginfi-sy-sdk" },
+    { "path": "../kamino-sy-sdk" },
+    { "path": "../exponent-types" },
+    { "path": "../jito-restaking-sy-sdk" },
+    { "path": "../jito-restaking-sy-idl" },
+    { "path": "../perena-sy-sdk" },
+    { "path": "../perena-sy-idl" },
+    { "path": "../perena-sy-pda" },
+    { "path": "../generic-sy-sdk" },
+    { "path": "../generic-sy-idl" },
+    { "path": "../generic-sy-pda" }
+  ]
+}