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

package/src/interfaces/exponentTranching.ts

@@ -0,0 +1,125 @@
+import { BN, BorshAccountsCoder, type Idl, web3 } from "@coral-xyz/anchor"
+
+import { IDL as EXPONENT_TRANCHING_IDL, PROGRAM_ID } from "@exponent-labs/exponent-tranching-idl"
+
+const EXPONENT_TRANCHING_PROGRAM_ID = new web3.PublicKey(PROGRAM_ID)
+const UPDATE_MARKET_DISCRIMINATOR = Buffer.from([153, 39, 2, 197, 179, 50, 199, 217])
+const NUMBER_DENOMINATOR = 1_000_000_000_000n
+
+type TranchingNumber = { 0: BN[] }
+
+type CpiInterfaceContext = {
+  alt_index: number
+  is_signer: boolean
+  is_writable: boolean
+}
+
+type ExponentTranchingMarketAccount = {
+  address_lookup_table: web3.PublicKey
+  sy_program: web3.PublicKey
+  mint_lp_senior: web3.PublicKey
+  mint_lp_junior: web3.PublicKey
+  return_model_storage: web3.PublicKey
+  financials: {
+    sr_effective_net_asset: TranchingNumber
+    jr_effective_net_asset: TranchingNumber
+  }
+  tranche_supply_state: {
+    total_senior_lp_supply: BN
+    total_junior_lp_supply: BN
+  }
+  sy_cpi_accounts: {
+    get_sy_state: CpiInterfaceContext[]
+  }
+}
+
+const accountCoder = new BorshAccountsCoder(EXPONENT_TRANCHING_IDL as Idl)
+
+function tranchingNumberToRaw(value: TranchingNumber): bigint {
+  if (value[0].length !== 4) {
+    throw new Error("Invalid Exponent Tranching number")
+  }
+
+  let raw = 0n
+  for (let index = 3; index >= 0; index--) {
+    raw = (raw << 64n) + BigInt(value[0][index]!.toString())
+  }
+  return raw
+}
+
+function calculateLpRate(effectiveNetAsset: TranchingNumber, totalLpSupply: BN): number {
+  const priceRaw =
+    (tranchingNumberToRaw(effectiveNetAsset) + NUMBER_DENOMINATOR) / (BigInt(totalLpSupply.toString()) + 1n)
+  return Number(priceRaw) / Number(NUMBER_DENOMINATOR)
+}
+
+async function fetchMarket(
+  connection: web3.Connection,
+  marketAddress: web3.PublicKey,
+): Promise<ExponentTranchingMarketAccount> {
+  const accountInfo = await connection.getAccountInfo(marketAddress)
+  if (!accountInfo) {
+    throw new Error(`Exponent Tranching market not found: ${marketAddress.toBase58()}`)
+  }
+  if (!accountInfo.owner.equals(EXPONENT_TRANCHING_PROGRAM_ID)) {
+    throw new Error(`Invalid Exponent Tranching market owner: ${accountInfo.owner.toBase58()}`)
+  }
+
+  return accountCoder.decode("ExponentTranchingMarket", accountInfo.data) as ExponentTranchingMarketAccount
+}
+
+/** Reads the selected tranche's virtual-supply NAV from an Exponent Tranching market. */
+export async function fetchExponentTranchingRate(params: {
+  connection: web3.Connection
+  marketAddress: web3.PublicKey
+  yieldBearingMint: web3.PublicKey
+}): Promise<number> {
+  const market = await fetchMarket(params.connection, params.marketAddress)
+
+  if (params.yieldBearingMint.equals(market.mint_lp_senior)) {
+    return calculateLpRate(market.financials.sr_effective_net_asset, market.tranche_supply_state.total_senior_lp_supply)
+  }
+  if (params.yieldBearingMint.equals(market.mint_lp_junior)) {
+    return calculateLpRate(market.financials.jr_effective_net_asset, market.tranche_supply_state.total_junior_lp_supply)
+  }
+
+  throw new Error(`Tranching market does not contain yield-bearing mint ${params.yieldBearingMint.toBase58()}`)
+}
+
+/** Builds the permissionless refresh required before reading a slot-fresh tranching NAV. */
+export async function buildExponentTranchingUpdateMarketInstruction(params: {
+  connection: web3.Connection
+  marketAddress: web3.PublicKey
+}): Promise<web3.TransactionInstruction> {
+  const market = await fetchMarket(params.connection, params.marketAddress)
+  const lookupTable = await params.connection.getAddressLookupTable(market.address_lookup_table)
+  if (!lookupTable.value) {
+    throw new Error(`Exponent Tranching lookup table not found: ${market.address_lookup_table.toBase58()}`)
+  }
+
+  const getSyStateAccounts = market.sy_cpi_accounts.get_sy_state.map((context) => {
+    const pubkey = lookupTable.value!.state.addresses[context.alt_index]
+    if (!pubkey) {
+      throw new Error(`Exponent Tranching get_sy_state ALT index ${context.alt_index} is out of bounds`)
+    }
+    return { pubkey, isSigner: context.is_signer, isWritable: context.is_writable }
+  })
+  const [eventAuthority] = web3.PublicKey.findProgramAddressSync(
+    [Buffer.from("__event_authority")],
+    EXPONENT_TRANCHING_PROGRAM_ID,
+  )
+
+  return new web3.TransactionInstruction({
+    programId: EXPONENT_TRANCHING_PROGRAM_ID,
+    data: UPDATE_MARKET_DISCRIMINATOR,
+    keys: [
+      { pubkey: params.marketAddress, isSigner: false, isWritable: true },
+      { pubkey: market.return_model_storage, isSigner: false, isWritable: true },
+      { pubkey: market.address_lookup_table, isSigner: false, isWritable: false },
+      { pubkey: market.sy_program, isSigner: false, isWritable: false },
+      { pubkey: eventAuthority, isSigner: false, isWritable: false },
+      { pubkey: EXPONENT_TRANCHING_PROGRAM_ID, isSigner: false, isWritable: false },
+      ...getSyStateAccounts,
+    ],
+  })
+}

package/src/interfaces/glowVault.ts

@@ -0,0 +1,55 @@
+import { web3 } from "@coral-xyz/anchor"
+
+const GLOW_VAULT_PROGRAM_ID = new web3.PublicKey("gwv1ybUe2JVEpjdWARK1PjZUVY5xdNUCRhu24tgYtxa")
+const GLOW_VAULT_DISCRIMINATOR = Buffer.from([211, 8, 232, 43, 2, 152, 117, 119])
+const GLOW_VAULT_ACCOUNT_SIZE = 8 + 552
+const SHARE_MINT_OFFSET = 8 + 160
+const DEPOSIT_TOKENS_OFFSET = 8 + 320
+const DEPOSIT_SHARES_OFFSET = 8 + 336
+const UNCOLLECTED_MANAGEMENT_FEES_OFFSET = 8 + 344
+const MINIMUM_SHARES_DUST_THRESHOLD_OFFSET = 8 + 408
+const REALISED_PERFORMANCE_FEES_OFFSET = 8 + 488
+const NUMBER_DENOMINATOR = 1_000_000_000_000n
+
+/** Reads a Glow vault's net underlying-token value per share. */
+export async function fetchGlowVaultRate(params: {
+  connection: web3.Connection
+  vaultAddress: web3.PublicKey
+  expectedShareMint: web3.PublicKey
+}): Promise<number> {
+  const accountInfo = await params.connection.getAccountInfo(params.vaultAddress)
+  if (!accountInfo) {
+    throw new Error(`Glow vault not found: ${params.vaultAddress.toBase58()}`)
+  }
+  if (!accountInfo.owner.equals(GLOW_VAULT_PROGRAM_ID)) {
+    throw new Error(`Invalid Glow vault owner: ${accountInfo.owner.toBase58()}`)
+  }
+  if (accountInfo.data.length < GLOW_VAULT_ACCOUNT_SIZE) {
+    throw new Error(`Glow vault account is too short: ${accountInfo.data.length}`)
+  }
+  if (!accountInfo.data.subarray(0, 8).equals(GLOW_VAULT_DISCRIMINATOR)) {
+    throw new Error("Invalid Glow vault discriminator")
+  }
+
+  const shareMint = new web3.PublicKey(accountInfo.data.subarray(SHARE_MINT_OFFSET, SHARE_MINT_OFFSET + 32))
+  if (!shareMint.equals(params.expectedShareMint)) {
+    throw new Error(
+      `Glow vault share mint ${shareMint.toBase58()} does not match ${params.expectedShareMint.toBase58()}`,
+    )
+  }
+
+  const depositShares = accountInfo.data.readBigUInt64LE(DEPOSIT_SHARES_OFFSET)
+  const minimumSharesDustThreshold = accountInfo.data.readBigUInt64LE(MINIMUM_SHARES_DUST_THRESHOLD_OFFSET)
+  if (depositShares <= minimumSharesDustThreshold) return 1
+
+  const depositTokens = accountInfo.data.readBigUInt64LE(DEPOSIT_TOKENS_OFFSET)
+  const uncollectedManagementFees = accountInfo.data.readBigUInt64LE(UNCOLLECTED_MANAGEMENT_FEES_OFFSET)
+  const realisedPerformanceFees = accountInfo.data.readBigUInt64LE(REALISED_PERFORMANCE_FEES_OFFSET)
+  const netAfterManagementFees =
+    depositTokens > uncollectedManagementFees ? depositTokens - uncollectedManagementFees : 0n
+  const netTokens =
+    netAfterManagementFees > realisedPerformanceFees ? netAfterManagementFees - realisedPerformanceFees : 0n
+  const rateRaw = (netTokens * NUMBER_DENOMINATOR) / depositShares
+
+  return Number(rateRaw) / Number(NUMBER_DENOMINATOR)
+}

package/tsconfig.json

@@ -25,6 +25,9 @@
     {
       "path": "../exponent-fetcher"
     },
+    {
+      "path": "../exponent-tranching-idl"
+    },
     {
       "path": "../generic-sy-pda"
     },