@exponent-labs/generic-sy-sdk 0.9.21 → 0.9.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exponent-labs/generic-sy-sdk",
-  "version": "0.9.21",
+  "version": "0.9.22",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "license": "AGPL-3.0",
@@ -12,14 +12,14 @@
     "@coral-xyz/anchor": "^0.31.0",
     "@solana/spl-stake-pool": "1.1.8",
     "@solana/spl-token": "0.4.6",
-    "@exponent-labs/exponent-admin-pda": "0.9.21",
-    "@exponent-labs/exponent-fetcher": "0.9.21",
-    "@exponent-labs/exponent-tranching-idl": "0.9.21",
-    "@exponent-labs/exponent-types": "0.9.21",
-    "@exponent-labs/fragmetric-pda": "0.9.21",
-    "@exponent-labs/generic-sy-idl": "0.9.21",
-    "@exponent-labs/generic-sy-pda": "0.9.21",
-    "@exponent-labs/precise-number": "0.9.21"
+    "@exponent-labs/exponent-admin-pda": "0.9.22",
+    "@exponent-labs/exponent-fetcher": "0.9.22",
+    "@exponent-labs/exponent-tranching-idl": "0.9.22",
+    "@exponent-labs/exponent-types": "0.9.22",
+    "@exponent-labs/fragmetric-pda": "0.9.22",
+    "@exponent-labs/generic-sy-idl": "0.9.22",
+    "@exponent-labs/generic-sy-pda": "0.9.22",
+    "@exponent-labs/precise-number": "0.9.22"
   },
   "devDependencies": {
     "typescript": "5.4.5"

package/src/index.ts

@@ -47,6 +47,67 @@ import { fetchGlowVaultRate } from "./interfaces/glowVault"
 import { SyInitializeConfig, SyTokenMetadata } from "./types"
 import { MyWallet } from "./utils"
 
+const GET_STATE_DISCRIMINATOR = Buffer.from([7])
+
+async function fetchOnChainSyRate({
+  connection,
+  programId,
+  meta,
+  mintSy,
+  tokenSyEscrow,
+  remainingAccounts,
+}: {
+  connection: web3.Connection
+  programId: web3.PublicKey
+  meta: web3.PublicKey
+  mintSy: web3.PublicKey
+  tokenSyEscrow: web3.PublicKey
+  remainingAccounts: web3.AccountMeta[]
+}): Promise<number> {
+  const instruction = new web3.TransactionInstruction({
+    programId,
+    keys: [
+      { pubkey: meta, isSigner: false, isWritable: true },
+      { pubkey: mintSy, isSigner: false, isWritable: false },
+      { pubkey: tokenSyEscrow, isSigner: false, isWritable: false },
+      ...remainingAccounts,
+    ],
+    data: GET_STATE_DISCRIMINATOR,
+  })
+  const [feePayer, { blockhash }] = await Promise.all([
+    connection.getSlotLeader("confirmed"),
+    connection.getLatestBlockhash("confirmed"),
+  ])
+  const message = new web3.TransactionMessage({
+    payerKey: new web3.PublicKey(feePayer),
+    recentBlockhash: blockhash,
+    instructions: [instruction],
+  }).compileToV0Message()
+  const simulation = await connection.simulateTransaction(new web3.VersionedTransaction(message), {
+    commitment: "confirmed",
+    replaceRecentBlockhash: true,
+    sigVerify: false,
+  })
+
+  if (simulation.value.err) {
+    const logs = simulation.value.logs?.join("\n") ?? "No simulation logs"
+    throw new Error(`Generic Standard get_state simulation failed: ${JSON.stringify(simulation.value.err)}\n${logs}`)
+  }
+
+  const returnData = simulation.value.returnData
+  if (!returnData || returnData.programId !== programId.toBase58()) {
+    throw new Error("Generic Standard get_state returned invalid program data")
+  }
+
+  const data = Buffer.from(returnData.data[0], "base64")
+  if (data.length < 32) {
+    throw new Error("Generic Standard get_state return data is too short")
+  }
+
+  const exchangeRate = Array.from({ length: 4 }, (_, index) => new BN(data.subarray(index * 8, (index + 1) * 8), "le"))
+  return Number(PreciseNumber.fromRaw(exchangeRate).valueString)
+}
+
 /**
  * Create a custom updateStakePoolBalance instruction using dynamic program ID
  */
@@ -126,6 +187,7 @@ export enum InterfaceType {
   SolsticeGlamVault = 18,
   ExponentTranching = 19,
   GlowVault = 20,
+  LoopscaleVaultLp = 21,
 }
 
 export function getInterfaceTypeIndex(interfaceType: InterfaceTypeGeneric): InterfaceType {
@@ -150,6 +212,7 @@ export function getInterfaceTypeIndex(interfaceType: InterfaceTypeGeneric): Inte
   if ("solsticeGlamVault" in interfaceType) return InterfaceType.SolsticeGlamVault
   if ("exponentTranching" in interfaceType) return InterfaceType.ExponentTranching
   if ("glowVault" in interfaceType) return InterfaceType.GlowVault
+  if ("loopscaleVaultLp" in interfaceType) return InterfaceType.LoopscaleVaultLp
 
   throw new Error("Unsupported interface type")
 }
@@ -218,6 +281,8 @@ export function getInterfaceTypeObj(
       return { exponentTranching: {} }
     case InterfaceType.GlowVault:
       return { glowVault: { padding: [] } }
+    case InterfaceType.LoopscaleVaultLp:
+      return { loopscaleVaultLp: { padding: [] } }
     default:
       throw new Error(`Unsupported interface type: ${interfaceType}`)
   }
@@ -281,6 +346,9 @@ export function getInterfaceTypeFromString(interfaceType: string): InterfaceType
       return { exponentTranching: {} }
     case "glow-vault":
       return { glowVault: { padding: [] } }
+    case "loopscale-vault":
+    case "loopscale-vault-lp":
+      return { loopscaleVaultLp: { padding: [] } }
     default:
       throw new Error(`Unsupported interface type: ${interfaceType}`)
   }
@@ -313,14 +381,22 @@ export class GenericSySdk {
     this.syPda = new GenericSyPda(programId, interfaceIndex)
   }
 
-  private static async calculateSyRate(
-    account: GenericSyMetaAccount,
-    interfaceType: InterfaceTypeGeneric,
-    cnx: web3.Connection,
-  ): Promise<{
+  private static async calculateSyRate({
+    account,
+    cnx,
+    syMetaAddress,
+    genericStandardProgramId,
+  }: {
+    account: GenericSyMetaAccount
+    cnx: web3.Connection
+    syMetaAddress: web3.PublicKey
+    genericStandardProgramId: web3.PublicKey
+  }): Promise<{
     syRate: number
     additionalData?: AdditionalDataGeneric
   }> {
+    const interfaceType = getGenericSyMetaInterfaceType(account)
+
     if ("pyth" in interfaceType) {
       const syRate = Number(PreciseNumber.fromRaw(account.index[0]).valueString)
       return { syRate: syRate }
@@ -554,6 +630,28 @@ export class GenericSySdk {
         expectedShareMint: account.yieldBearingMint,
       })
       return { syRate }
+    } else if ("loopscaleVaultLp" in interfaceType) {
+      if (account.interfaceAccounts.length !== 3) {
+        throw new Error("Loopscale Vault LP interface requires exactly three accounts")
+      }
+
+      const syRate = await fetchOnChainSyRate({
+        connection: cnx,
+        programId: genericStandardProgramId,
+        meta: syMetaAddress,
+        mintSy: account.mintSy,
+        tokenSyEscrow: account.tokenSyEscrow,
+        remainingAccounts: account.interfaceAccounts
+          .map((pubkey) => ({ pubkey, isSigner: false, isWritable: false }))
+          .concat(
+            account.emissions.map((emission) => ({
+              pubkey: emission.escrowAccount,
+              isSigner: false,
+              isWritable: false,
+            })),
+          ),
+      })
+      return { syRate }
     } else {
       return { syRate: 1 }
     }
@@ -581,11 +679,12 @@ export class GenericSySdk {
       yieldBearingMint,
     })
 
-    const { syRate, additionalData } = await GenericSySdk.calculateSyRate(
+    const { syRate, additionalData } = await GenericSySdk.calculateSyRate({
       account,
-      getGenericSyMetaInterfaceType(account),
       cnx,
-    )
+      syMetaAddress: selfAddress,
+      genericStandardProgramId,
+    })
 
     const state: GenericSyState = {
       selfAddress,
@@ -614,11 +713,12 @@ export class GenericSySdk {
     const account = await fetcher.fetchGenericSyMeta(syMetaAddress)
     const tokenProgramBase = (await cnx.getAccountInfo(account.yieldBearingMint))?.owner
 
-    const { syRate, additionalData } = await GenericSySdk.calculateSyRate(
+    const { syRate, additionalData } = await GenericSySdk.calculateSyRate({
       account,
-      getGenericSyMetaInterfaceType(account),
       cnx,
-    )
+      syMetaAddress,
+      genericStandardProgramId,
+    })
 
     const state: GenericSyState = {
       selfAddress: syMetaAddress,
@@ -633,14 +733,16 @@ export class GenericSySdk {
 
   /** Reload the state of the account */
   async reload(cnx: web3.Connection) {
-    const fetcher = new ExponentFetcher({ connection: cnx, genericStandardProgramId: this.program.programId })
+    const genericStandardProgramId = this.syPda.programId
+    const fetcher = new ExponentFetcher({ connection: cnx, genericStandardProgramId })
     const account = await fetcher.fetchGenericSyMeta(this.state.selfAddress)
     this.state.account = account
-    const { syRate, additionalData } = await GenericSySdk.calculateSyRate(
+    const { syRate, additionalData } = await GenericSySdk.calculateSyRate({
       account,
-      getGenericSyMetaInterfaceType(account),
       cnx,
-    )
+      syMetaAddress: this.state.selfAddress,
+      genericStandardProgramId,
+    })
     this.state.syRate = syRate
     this.state.additionalData = additionalData
   }