@exponent-labs/exponent-sdk 0.9.2 → 0.9.3

package/src/ytPosition.ts

@@ -1,319 +0,0 @@
-import { TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync } from "@solana/spl-token"
-
-import { ExponentFetcher, YieldTokenTracker, YtPosition as YtPositionState } from "@exponent-labs/exponent-fetcher"
-import { ExponentPDA } from "@exponent-labs/exponent-pda"
-import { VaultJson } from "@exponent-labs/exponent-types"
-import { PreciseNumber } from "@exponent-labs/precise-number"
-import * as exponentCore from "./client/core"
-
-import { Environment } from "./environment"
-import { InstructionAccounts } from "./utils"
-import { Vault } from "./vault"
-import { Connection, PublicKey, SystemProgram } from "@solana/web3.js"
-
-export class YtPosition {
-  constructor(
-    public env: Environment,
-    public connection: Connection,
-    public selfAddress: PublicKey,
-    public state: YtPositionState,
-    public vault: Vault,
-  ) {}
-
-  /** Loads the YT position by address, and loads Vault, too */
-  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))
-    return new YtPosition(env, connection, address, ytPositionState, loadedVault)
-  }
-
-  /** Loads the YT position by owner, but require a loaded 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 })
-    const ytPositionState = await fetcher.fetchYtPosition(address)
-    return new YtPosition(env, connection, address, ytPositionState, vault)
-  }
-
-  static async loadAllByOwner(
-    env: Environment,
-    connection: Connection,
-    owner: PublicKey,
-    vaults: (Vault | PublicKey)[],
-  ) {
-    const pda = new ExponentPDA(env.coreProgramId)
-    const addresses = vaults.map((v) =>
-      pda.yieldPosition({
-        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
-    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
-
-    const toCollectSy = Math.floor(
-      Number(this.state.ytBalance.toString()) * interestDelta + Number(this.state.interest.staged),
-    )
-
-    // Ensure toCollectSy is not negative
-    const toCollectSySafe = Math.max(0, toCollectSy)
-
-    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)
-  }
-
-  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
-      // 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,
-      )
-
-      const earnedEmission = totalSyBalance * (finalIndex - 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?: PublicKey }) {
-    const { mainAccounts, remainingAccounts } = this.depositYtAccounts({ ytSrc })
-    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?: PublicKey }) {
-    const { mainAccounts, remainingAccounts } = this.withdrawYtAccounts({ ytDst })
-    const ix = exponentCore.createWithdrawYtInstruction(mainAccounts, { amount })
-    ix.keys.push(...remainingAccounts)
-    return ix
-  }
-
-  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: PublicKey; syDst?: PublicKey; amount?: bigint }) {
-    const tokenSyDst = syDst || getAssociatedTokenAddressSync(this.vault.mintSy, signer, true, TOKEN_PROGRAM_ID)
-    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,
-        addressLookupTable: this.vault.addressLookupTable,
-        eventAuthority: this.vault.eventAuthority,
-        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
-      },
-      { amount: claimAmount },
-    )
-    ix.keys.push(...this.vault.cpiAccounts.withdrawSy)
-    return ix
-  }
-
-  ixCollectEmission({
-    owner,
-    emissionIndex,
-    emissionDst: emissionDstParam,
-    amount,
-  }: {
-    owner: PublicKey
-    emissionIndex: number
-    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 = amount !== undefined ? exponentCore.amount("Some", [amount]) : exponentCore.amount("All")
-
-    const ix = exponentCore.createCollectEmissionInstruction(
-      {
-        owner,
-        vault: this.selfAddress,
-        position: this.selfAddress,
-        syProgram: this.vault.state.syProgram,
-        authority: this.vault.authority,
-        emissionEscrow: emission.tokenAccount,
-        emissionDst,
-        addressLookupTable: this.vault.addressLookupTable,
-        treasuryEmissionTokenAccount: emission.treasuryTokenAccount,
-        tokenProgram: this.vault.flavor.emissions[emissionIndex].tokenProgram,
-        eventAuthority: this.vault.eventAuthority,
-        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
-      },
-      { index: emissionIndex, amount: claimAmount },
-    )
-    ix.keys.push(...this.vault.cpiAccounts.claimEmission[emissionIndex])
-    return ix
-  }
-
-  depositYtAccounts({ ytSrc: ytSrcParam }: { ytSrc?: PublicKey }): InstructionAccounts<exponentCore.DepositYtInstructionAccounts> {
-    const ytSrc = ytSrcParam || 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: SystemProgram.programId,
-        eventAuthority: this.vault.eventAuthority,
-        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
-      },
-      remainingAccounts: this.vault.cpiAccounts.getSyState,
-    }
-  }
-
-  withdrawYtAccounts({ ytDst: ytDstParam }: { ytDst?: PublicKey }): InstructionAccounts<exponentCore.WithdrawYtInstructionAccounts> {
-    const ytDst = ytDstParam || 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: SystemProgram.programId,
-        eventAuthority: this.vault.eventAuthority,
-        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
-      },
-      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(ytPosition: YtPosition): YtPositionJson {
-  return {
-    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(yieldTokenTracker: YieldTokenTracker): YieldTokenTrackerJson {
-  return {
-    lastSeenIndex: yieldTokenTracker.lastSeenIndex,
-    staged: yieldTokenTracker.staged.toString(),
-  }
-}

package/tsconfig.json

@@ -1,46 +0,0 @@
-{
-  "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": "../loopscale-deserializer" },
-    { "path": "../exponent-pda" },
-    { "path": "../exponent-clmm-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" },
-    { "path": "../exponent-orderbook-idl" },
-    { "path": "../exponent-vaults-idl" },
-    { "path": "../exponent-vaults-pda" },
-    { "path": "../exponent-vaults-fetcher" },
-    { "path": "../market-three-math" },
-    { "path": "../klend-idl" }
-  ]
-}