@exponent-labs/exponent-sdk 0.0.3

package/src/index.ts

@@ -0,0 +1,11 @@
+export { Market, LiquidityAdd, MarketAdminAction } from "./market"
+export { Vault } from "./vault"
+export { LpPosition, LpPositionState } from "./lpPosition"
+export { YtPosition } from "./ytPosition"
+export { EventDecoder } from "./events"
+export type { AdminAction } from "./vault"
+export type { CategorizedEvents } from "./events"
+export * as events from "./events"
+export * from "./environment"
+export * as flavors from "./flavors"
+export { makeSyPosition } from "./syPosition"

package/src/lpPosition.ts

@@ -0,0 +1,129 @@
+import { AnchorProvider, Program, web3 } from "@coral-xyz/anchor"
+import { Market, MyWallet } from "./market"
+import { Environment } from "./environment"
+import { ExponentCore, IDL } from "@exponent-labs/exponent-idl"
+import { ExponentFetcher } from "@exponent-labs/exponent-fetcher"
+import { PreciseNumber } from "@exponent-labs/precise-number"
+import { makeSyPosition } from "./syPosition"
+
+export interface EmissionTracker {
+  lastSeenIndex: number
+  staged: bigint
+}
+
+export interface LpPositionState {
+  owner: web3.PublicKey
+  balanceLp: bigint
+  market: Market
+  emissionTrackers: EmissionTracker[]
+  farms: EmissionTracker[]
+  fetcher: ExponentFetcher
+}
+
+export class LpPosition {
+  public coreProgram: Program<ExponentCore>
+  constructor(
+    public env: Environment,
+    public connection: web3.Connection,
+    public selfAddress: web3.PublicKey,
+    public state: LpPositionState,
+  ) {
+    const mockWallet = new MyWallet(web3.Keypair.generate())
+    this.coreProgram = new Program(IDL as ExponentCore, new AnchorProvider(connection, mockWallet))
+  }
+
+  static async load(env: Environment, connection: web3.Connection, address: web3.PublicKey) {
+    const fetcher = new ExponentFetcher({ connection })
+    const x = await fetcher.fetchLpPosition(address)
+    const market = await Market.load(env, connection, x.market)
+    const state: LpPositionState = {
+      owner: x.owner,
+      balanceLp: x.lpBalance,
+      market,
+      emissionTrackers: x.emissions,
+      farms: x.farms,
+      fetcher: fetcher,
+    }
+    return new LpPosition(env, connection, address, state)
+  }
+
+  async reload(conn = this.connection) {
+    const x = await LpPosition.load(this.env, conn, this.selfAddress)
+    this.state = x.state
+    return x
+  }
+
+  get lpBalance() {
+    return this.state.balanceLp
+  }
+
+  get owner() {
+    return this.state.owner
+  }
+
+  get marketSdk() {
+    return this.state.market
+  }
+
+  get marketAddress() {
+    return this.state.market.selfAddress
+  }
+
+  async ixDepositLp(amount: bigint): Promise<web3.TransactionInstruction> {
+    const ix = this.marketSdk.ixDepositLp({
+      owner: this.owner,
+      amount,
+    })
+    return ix
+  }
+
+  async ixWithdrawLp(amount: bigint): Promise<web3.TransactionInstruction> {
+    const ix = this.marketSdk.ixWithdrawLp({
+      owner: this.owner,
+      amount,
+    })
+    return ix
+  }
+
+  async claimableFarmEmissions(mint: web3.PublicKey) {
+    const marketFarmIndex = this.state.market.state.lpFarm.farmEmissions.findIndex((e) => e.mint.equals(mint))
+    if (marketFarmIndex === -1) return null
+
+    const marketFarm = this.state.market.state.lpFarm.farmEmissions[marketFarmIndex]
+    const positionFarm = this.state.farms[marketFarmIndex]
+
+    const ts = new Date().getTime() / 1000
+
+    const deltaTimeFarm = ts - this.marketSdk.state.lpFarm.lastSeenTimestamp
+    const lpStakedTotal = this.marketSdk.state.lpEscrowAmount
+    const tokensEmitted = Number(marketFarm.tokenRate) * deltaTimeFarm
+    const increaseAmount = Number(tokensEmitted) / Number(lpStakedTotal)
+    const virtualIndex = Number(PreciseNumber.fromRaw(marketFarm.index[0]).valueString) + increaseAmount
+
+    const deltaIndex = positionFarm ? virtualIndex - positionFarm.lastSeenIndex : virtualIndex
+
+    const claimableAmount = Number(this.lpBalance) * deltaIndex
+
+    return claimableAmount + (Number(positionFarm?.staged) || 0)
+  }
+
+  async getClaimableMarketEmissions() {
+    const syPosition = this.marketSdk.state.syPosition
+
+    return this.state.market.emissions.map((emission, index) => {
+      const marketEmission = this.state.market.marketEmissions.trackers[index]
+      const positionEmission = this.state.emissionTrackers[index]
+      if (!positionEmission) return 0
+
+      // First calculate the market's emission index update from syEmissions
+      const difference = Number(syPosition.emissions[index].staged) - Number(marketEmission.lastSeenStaged)
+      const lpStakedTotal = this.marketSdk.state.lpEscrowAmount
+      const indexIncrease = difference / Number(lpStakedTotal)
+      const currentIndex = marketEmission.lpShareIndex + indexIncrease
+
+      // Then calculate user's claimable amount based on the updated index
+      const earned = Number(this.lpBalance) * (currentIndex - positionEmission.lastSeenIndex)
+      return Math.floor(earned) + Number(positionEmission.staged)
+    })
+  }
+}