@exponent-labs/exponent-sdk 0.0.9 → 0.0.10

package/src/events.ts

@@ -50,15 +50,30 @@ export class EventDecoder {
     }
   }
 
-  parseCpiEvents(transactionResponse: web3.VersionedTransactionResponse | web3.TransactionResponse): CategorizedEvents {
+  async parseCpiEvents(
+    transactionResponse: web3.VersionedTransactionResponse | web3.TransactionResponse,
+    connection: web3.Connection,
+  ): Promise<CategorizedEvents> {
     const events: GenericEvent[] = []
     const inner: web3.CompiledInnerInstruction[] = transactionResponse?.meta?.innerInstructions ?? []
 
+    const addressTableLookups = transactionResponse?.transaction.message.addressTableLookups
+
+    const lookupTables = await Promise.all(
+      addressTableLookups.map(async (lookup) => {
+        const lookupTable = await connection.getAddressLookupTable(lookup.accountKey)
+        return lookupTable
+      }),
+    )
+
     for (let i = 0; i < inner.length; i++) {
       for (let j = 0; j < inner[i].instructions.length; j++) {
         const ix = inner[i].instructions[j]
 
-        const programPubkey = transactionResponse?.transaction.message.staticAccountKeys[ix.programIdIndex]
+        const accountKeys = transactionResponse?.transaction.message.getAccountKeys({
+          addressLookupTableAccounts: lookupTables.map((lookup) => lookup.value),
+        })
+        const programPubkey = accountKeys.get(ix.programIdIndex)
 
         if (programPubkey === undefined || !programPubkey.equals(this.programId)) {
           continue

package/src/lpPosition.ts

@@ -5,6 +5,7 @@ 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"
+import { ExponentPDA } from "@exponent-labs/exponent-pda"
 
 export interface EmissionTracker {
   lastSeenIndex: number
@@ -32,14 +33,14 @@ export class LpPosition {
     this.coreProgram = new Program(IDL as ExponentCore, new AnchorProvider(connection, mockWallet))
   }
 
-  static async load(env: Environment, connection: web3.Connection, address: web3.PublicKey) {
+  static async load(env: Environment, connection: web3.Connection, address: web3.PublicKey, market?: Market) {
     const fetcher = new ExponentFetcher({ connection })
     const x = await fetcher.fetchLpPosition(address)
-    const market = await Market.load(env, connection, x.market)
+    const loadedMarket = market ?? (await Market.load(env, connection, x.market))
     const state: LpPositionState = {
       owner: x.owner,
       balanceLp: x.lpBalance,
-      market,
+      market: loadedMarket,
       emissionTrackers: x.emissions,
       farms: x.farms,
       fetcher: fetcher,
@@ -47,6 +48,32 @@ export class LpPosition {
     return new LpPosition(env, connection, address, state)
   }
 
+  static async loadAllByOwner(
+    env: Environment,
+    connection: web3.Connection,
+    owner: web3.PublicKey,
+    markets: (Market | web3.PublicKey)[],
+  ) {
+    const pda = new ExponentPDA(env.coreProgramId)
+    const addresses = markets.map((m) =>
+      pda.marketLpPosition({
+        market: m instanceof web3.PublicKey ? m : m.selfAddress,
+        owner,
+      }),
+    )
+
+    const positionPromises = addresses.map((addr) => {
+      try {
+        return LpPosition.load(env, connection, addr)
+      } catch (e) {
+        return Promise.resolve(null)
+      }
+    })
+
+    const positions = await Promise.all(positionPromises)
+    return positions.filter((p): p is LpPosition => p !== null)
+  }
+
   async reload(conn = this.connection) {
     const x = await LpPosition.load(this.env, conn, this.selfAddress)
     this.state = x.state

package/src/market.ts

@@ -392,11 +392,19 @@ export class Market {
     return (r * SECONDS_PER_YEAR) / secondsRemaining
   }
 
+  static annualizeApy(r: number, secondsRemaining: number) {
+    return (1 + r) ** (SECONDS_PER_YEAR / secondsRemaining) - 1
+  }
+
   /** Annualized PT fixed rate */
   get ptApr(): number {
     return Market.annualize(this.absolutePtYield, this.secondsRemaining)
   }
 
+  get ptApy(): number {
+    return Market.annualizeApy(this.absolutePtYield, this.secondsRemaining)
+  }
+
   /** The fee rate taken off of trade fees (typically around 20%) expressed as a BPS number */
   get feeTreasuryBps(): number {
     return this.state.feeTreasurySyBps
@@ -1066,7 +1074,7 @@ export class Market {
     ])
 
     const ix = await this.coreProgram.methods
-      .wrapperBuyPt(new BN(ptOut.toString()), new BN(maxBaseIn.toString()), mintSyRemAccounts.length - 1)
+      .wrapperBuyPt(new BN(ptOut.toString()), new BN(maxBaseIn.toString()), mintSyRemAccounts.length)
       .accountsStrict({
         addressLookupTable: this.addressLookupTable,
         buyer: owner,
@@ -1227,7 +1235,7 @@ export class Market {
     const allRemainingAccounts = mintSyRemAccounts.concat(remainingAccounts)
 
     const ix1 = await this.coreProgram.methods
-      .wrapperBuyYt(new BN(ytOut.toString()), new BN(maxBaseIn.toString()), mintSyRemAccounts.length - 1)
+      .wrapperBuyYt(new BN(ytOut.toString()), new BN(maxBaseIn.toString()), mintSyRemAccounts.length)
       .accountsStrict({
         buyer: owner,
         market: this.selfAddress,
@@ -1563,7 +1571,7 @@ export class Market {
     const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner: depositor })
 
     const ix = await this.coreProgram.methods
-      .wrapperProvideLiquidity(amountBaseBn, minLpOutBn, mintSyRemAccounts.length - 1)
+      .wrapperProvideLiquidity(amountBaseBn, minLpOutBn, mintSyRemAccounts.length)
       .accountsStrict({
         depositor,
         authority: this.vault.authority,
@@ -1690,7 +1698,7 @@ export class Market {
       .wrapperProvideLiquidityBase(
         new BN(amountBase.toString()),
         new BN(minLpOut.toString()),
-        mintSyRemAccounts.length - 1,
+        mintSyRemAccounts.length,
         new BN(externalPtToBuy.toString()),
         new BN(externalSyConstraint.toString()),
       )
@@ -1804,7 +1812,7 @@ export class Market {
         new BN(amountBase.toString()),
         new BN(amountPt.toString()),
         new BN(minLpOut.toString()),
-        mintSyRemAccounts.length - 1,
+        mintSyRemAccounts.length,
       )
       .accountsStrict({
         depositor,
@@ -2244,6 +2252,8 @@ export type MarketJson = {
   /** Annualized yield for PT */
   ptApr: number
 
+  ptApy: number
+
   /** Emission tokens */
   emissions: {
     trackers: {
@@ -2314,6 +2324,7 @@ function toJson(m: Market): MarketJson {
       })),
     },
     ptApr: m.ptApr,
+    ptApy: m.ptApy,
     lpEscrowAmount: m.state.lpEscrowAmount.toString(),
     maxLpSupply: m.state.maxLpSupply.toString(),
     liquidityNetBalanceLimits: {

package/src/ytPosition.ts

@@ -27,11 +27,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 loadedVault = vault ?? (await Vault.load(env, connection, x.vault))
+    return new YtPosition(env, connection, address, x, loadedVault)
   }
 
   /** Loads the YT position by owner, but require a loaded Vault */
@@ -43,6 +43,22 @@ export class YtPosition {
     return new YtPosition(env, connection, address, x, vault)
   }
 
+  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(conn = this.connection) {
     const x = await YtPosition.load(this.env, conn, this.selfAddress)
     this.state = x.state