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

package/src/index.ts

@@ -4,6 +4,7 @@ import {
   ASSOCIATED_TOKEN_PROGRAM_ID,
   TOKEN_2022_PROGRAM_ID,
   TOKEN_PROGRAM_ID,
+  createAssociatedTokenAccountIdempotentInstruction,
   getAssociatedTokenAddressSync,
 } from "@solana/spl-token"
 
@@ -30,12 +31,19 @@ import {
   GenericSyState,
   Hook,
   InterfaceTypeGeneric,
+  getGenericSyMetaInitInterfaceType,
+  getGenericSyMetaInterfaceType,
 } from "@exponent-labs/exponent-types"
 import { FRAGMETRIC_PROGRAM_ID, FragmetricPda } from "@exponent-labs/fragmetric-pda"
 import { PROGRAM_ID as GENERIC_STANDARD_PROGRAM_ID, GenericStandard, IDL } from "@exponent-labs/generic-sy-idl"
 import { GenericSyPda } from "@exponent-labs/generic-sy-pda"
 import { PreciseNumber } from "@exponent-labs/precise-number"
 
+import {
+  buildExponentTranchingUpdateMarketInstruction,
+  fetchExponentTranchingRate,
+} from "./interfaces/exponentTranching"
+import { fetchGlowVaultRate } from "./interfaces/glowVault"
 import { SyInitializeConfig, SyTokenMetadata } from "./types"
 import { MyWallet } from "./utils"
 
@@ -86,48 +94,7 @@ async function loadAccountState(
   genericStandardProgramId: web3.PublicKey,
   interfaceType: InterfaceTypeGeneric,
 ) {
-  let interfaceIndex: number
-  if ("pyth" in interfaceType) {
-    interfaceIndex = InterfaceType.Pyth
-  } else if ("splStakePool" in interfaceType) {
-    interfaceIndex = InterfaceType.SplStakePool
-  } else if ("one" in interfaceType) {
-    interfaceIndex = InterfaceType.One
-  } else if ("fragmetric" in interfaceType) {
-    interfaceIndex = InterfaceType.Fragmetric
-  } else if ("meteora" in interfaceType) {
-    interfaceIndex = InterfaceType.Meteora
-  } else if ("sanctum" in interfaceType) {
-    interfaceIndex = InterfaceType.Sanctum
-  } else if ("fragmetricSupportedAsset" in interfaceType) {
-    interfaceIndex = InterfaceType.FragmetricSupportedAsset
-  } else if ("jupiterPerps" in interfaceType) {
-    interfaceIndex = InterfaceType.JupiterPerps
-  } else if ("adrena" in interfaceType) {
-    interfaceIndex = InterfaceType.Adrena
-  } else if ("hyloLpToken" in interfaceType) {
-    interfaceIndex = InterfaceType.HyloLpToken
-  } else if ("jupiterLend" in interfaceType) {
-    interfaceIndex = InterfaceType.JupiterLend
-  } else if ("kaminoVault" in interfaceType) {
-    interfaceIndex = InterfaceType.KaminoVault
-  } else if ("solstice" in interfaceType) {
-    interfaceIndex = InterfaceType.Solstice
-  } else if ("reflect" in interfaceType) {
-    interfaceIndex = InterfaceType.Reflect
-  } else if ("ore" in interfaceType) {
-    interfaceIndex = InterfaceType.Ore
-  } else if ("chainlink" in interfaceType) {
-    interfaceIndex = InterfaceType.Chainlink
-  } else if ("chainlinkDataStream" in interfaceType) {
-    interfaceIndex = InterfaceType.ChainlinkDataStream
-  } else if ("scope" in interfaceType) {
-    interfaceIndex = InterfaceType.Scope
-  } else if ("solsticeGlamVault" in interfaceType) {
-    interfaceIndex = InterfaceType.SolsticeGlamVault
-  } else {
-    throw new Error("Unsupported interface type")
-  }
+  const interfaceIndex = getInterfaceTypeIndex(interfaceType)
   const pda = new GenericSyPda(genericStandardProgramId, interfaceIndex)
   const fetcher = new ExponentFetcher({ connection: cnx, genericStandardProgramId })
   const syMetaAddress = pda.syMeta({ yieldBearingMint })
@@ -157,6 +124,34 @@ export enum InterfaceType {
   ChainlinkDataStream = 16,
   Scope = 17,
   SolsticeGlamVault = 18,
+  ExponentTranching = 19,
+  GlowVault = 20,
+}
+
+export function getInterfaceTypeIndex(interfaceType: InterfaceTypeGeneric): InterfaceType {
+  if ("pyth" in interfaceType) return InterfaceType.Pyth
+  if ("splStakePool" in interfaceType) return InterfaceType.SplStakePool
+  if ("one" in interfaceType) return InterfaceType.One
+  if ("fragmetricSupportedAsset" in interfaceType) return InterfaceType.FragmetricSupportedAsset
+  if ("fragmetric" in interfaceType) return InterfaceType.Fragmetric
+  if ("meteora" in interfaceType) return InterfaceType.Meteora
+  if ("sanctum" in interfaceType) return InterfaceType.Sanctum
+  if ("jupiterPerps" in interfaceType) return InterfaceType.JupiterPerps
+  if ("adrena" in interfaceType) return InterfaceType.Adrena
+  if ("hyloLpToken" in interfaceType) return InterfaceType.HyloLpToken
+  if ("jupiterLend" in interfaceType) return InterfaceType.JupiterLend
+  if ("kaminoVault" in interfaceType) return InterfaceType.KaminoVault
+  if ("solstice" in interfaceType) return InterfaceType.Solstice
+  if ("reflect" in interfaceType) return InterfaceType.Reflect
+  if ("ore" in interfaceType) return InterfaceType.Ore
+  if ("chainlinkDataStream" in interfaceType) return InterfaceType.ChainlinkDataStream
+  if ("chainlink" in interfaceType) return InterfaceType.Chainlink
+  if ("scope" in interfaceType) return InterfaceType.Scope
+  if ("solsticeGlamVault" in interfaceType) return InterfaceType.SolsticeGlamVault
+  if ("exponentTranching" in interfaceType) return InterfaceType.ExponentTranching
+  if ("glowVault" in interfaceType) return InterfaceType.GlowVault
+
+  throw new Error("Unsupported interface type")
 }
 
 export function getInterfaceTypeObj(
@@ -219,6 +214,10 @@ export function getInterfaceTypeObj(
       return { scope: { priceChain: scopePriceChain, maximumAgeSeconds: new BN(scopeMaximumAgeSeconds) } }
     case InterfaceType.SolsticeGlamVault:
       return { solsticeGlamVault: { padding: [] } }
+    case InterfaceType.ExponentTranching:
+      return { exponentTranching: {} }
+    case InterfaceType.GlowVault:
+      return { glowVault: { padding: [] } }
     default:
       throw new Error(`Unsupported interface type: ${interfaceType}`)
   }
@@ -278,6 +277,10 @@ export function getInterfaceTypeFromString(interfaceType: string): InterfaceType
       return { scope: { priceChain: [0, 512, 512, 512], maximumAgeSeconds: new BN(3600) } }
     case "solstice-glam-vault":
       return { solsticeGlamVault: { padding: [] } }
+    case "exponent-tranching":
+      return { exponentTranching: {} }
+    case "glow-vault":
+      return { glowVault: { padding: [] } }
     default:
       throw new Error(`Unsupported interface type: ${interfaceType}`)
   }
@@ -306,50 +309,7 @@ export class GenericSySdk {
       new AnchorProvider(new web3.Connection("https://api.devnet.solana.com"), new MyWallet(web3.Keypair.generate())),
     )
 
-    // Determine interface index based on the interface type from state
-    let interfaceIndex: number
-    if ("pyth" in this.state.account.interfaceType) {
-      interfaceIndex = InterfaceType.Pyth
-    } else if ("splStakePool" in this.state.account.interfaceType) {
-      interfaceIndex = InterfaceType.SplStakePool
-    } else if ("one" in this.state.account.interfaceType) {
-      interfaceIndex = InterfaceType.One
-    } else if ("fragmetricSupportedAsset" in this.state.account.interfaceType) {
-      interfaceIndex = InterfaceType.FragmetricSupportedAsset
-    } else if ("fragmetric" in this.state.account.interfaceType) {
-      interfaceIndex = InterfaceType.Fragmetric
-    } else if ("meteora" in this.state.account.interfaceType) {
-      interfaceIndex = InterfaceType.Meteora
-    } else if ("sanctum" in this.state.account.interfaceType) {
-      interfaceIndex = InterfaceType.Sanctum
-    } else if ("jupiterPerps" in this.state.account.interfaceType) {
-      interfaceIndex = InterfaceType.JupiterPerps
-    } else if ("adrena" in this.state.account.interfaceType) {
-      interfaceIndex = InterfaceType.Adrena
-    } else if ("hyloLpToken" in this.state.account.interfaceType) {
-      interfaceIndex = InterfaceType.HyloLpToken
-    } else if ("jupiterLend" in this.state.account.interfaceType) {
-      interfaceIndex = InterfaceType.JupiterLend
-    } else if ("kaminoVault" in this.state.account.interfaceType) {
-      interfaceIndex = InterfaceType.KaminoVault
-    } else if ("solstice" in this.state.account.interfaceType) {
-      interfaceIndex = InterfaceType.Solstice
-    } else if ("reflect" in this.state.account.interfaceType) {
-      interfaceIndex = InterfaceType.Reflect
-    } else if ("ore" in this.state.account.interfaceType) {
-      interfaceIndex = InterfaceType.Ore
-    } else if ("chainlink" in this.state.account.interfaceType) {
-      interfaceIndex = InterfaceType.Chainlink
-    } else if ("chainlinkDataStream" in this.state.account.interfaceType) {
-      interfaceIndex = InterfaceType.ChainlinkDataStream
-    } else if ("scope" in this.state.account.interfaceType) {
-      interfaceIndex = InterfaceType.Scope
-    } else if ("solsticeGlamVault" in this.state.account.interfaceType) {
-      interfaceIndex = InterfaceType.SolsticeGlamVault
-    } else {
-      throw new Error("Unsupported interface type")
-    }
-
+    const interfaceIndex = getInterfaceTypeIndex(getGenericSyMetaInitInterfaceType(this.state.account))
     this.syPda = new GenericSyPda(programId, interfaceIndex)
   }
 
@@ -414,7 +374,7 @@ export class GenericSySdk {
     } else if ("meteora" in interfaceType) {
       const currentTs = Math.floor(Date.now() / 1000)
 
-      const accounts = {
+      let accounts = {
         pool: account.interfaceAccounts[0],
         vaultA: account.interfaceAccounts[4],
         vaultB: account.interfaceAccounts[5],
@@ -434,11 +394,10 @@ export class GenericSySdk {
 
       return { syRate: exchangeRate }
     } else if ("adrena" in interfaceType) {
-      // @ts-ignore
-      const previousTotalFees = account.interfaceType.adrena.previousTotalFees
+      const previousTotalFees = interfaceType.adrena.previousTotalFees
       const currentIndex = account.index
 
-      let accounts = {
+      const accounts = {
         pool: account.interfaceAccounts[0],
         custody1: account.interfaceAccounts[1],
         custody2: account.interfaceAccounts[2],
@@ -450,8 +409,7 @@ export class GenericSySdk {
 
       return { syRate: syRate.index }
     } else if ("jupiterPerps" in interfaceType) {
-      // @ts-ignore
-      const j = account.interfaceType.jupiterPerps
+      const j = interfaceType.jupiterPerps
       const { index } = await fetchJupiterPerpsIndex({
         connection: cnx,
         pool: account.interfaceAccounts[0],
@@ -574,6 +532,28 @@ export class GenericSySdk {
         stslxMint,
       })
       return { syRate }
+    } else if ("exponentTranching" in interfaceType) {
+      const marketAddress = account.interfaceAccounts[0]
+      if (account.interfaceAccounts.length !== 1 || !marketAddress) {
+        throw new Error("Exponent Tranching interface requires exactly one market account")
+      }
+      const syRate = await fetchExponentTranchingRate({
+        connection: cnx,
+        marketAddress,
+        yieldBearingMint: account.yieldBearingMint,
+      })
+      return { syRate }
+    } else if ("glowVault" in interfaceType) {
+      const vaultAddress = account.interfaceAccounts[0]
+      if (account.interfaceAccounts.length !== 1 || !vaultAddress) {
+        throw new Error("Glow Vault interface requires exactly one vault account")
+      }
+      const syRate = await fetchGlowVaultRate({
+        connection: cnx,
+        vaultAddress,
+        expectedShareMint: account.yieldBearingMint,
+      })
+      return { syRate }
     } else {
       return { syRate: 1 }
     }
@@ -596,53 +576,16 @@ export class GenericSySdk {
     const account = await loadAccountState(cnx, yieldBearingMint, genericStandardProgramId, interfaceType)
     const tokenProgramBase = (await cnx.getAccountInfo(yieldBearingMint))?.owner
 
-    let interfaceIndex: number
-    if ("pyth" in interfaceType) {
-      interfaceIndex = InterfaceType.Pyth
-    } else if ("splStakePool" in interfaceType) {
-      interfaceIndex = InterfaceType.SplStakePool
-    } else if ("one" in interfaceType) {
-      interfaceIndex = InterfaceType.One
-    } else if ("fragmetricSupportedAsset" in interfaceType) {
-      interfaceIndex = InterfaceType.FragmetricSupportedAsset
-    } else if ("fragmetric" in interfaceType) {
-      interfaceIndex = InterfaceType.Fragmetric
-    } else if ("meteora" in interfaceType) {
-      interfaceIndex = InterfaceType.Meteora
-    } else if ("sanctum" in interfaceType) {
-      interfaceIndex = InterfaceType.Sanctum
-    } else if ("jupiterPerps" in interfaceType) {
-      interfaceIndex = InterfaceType.JupiterPerps
-    } else if ("adrena" in interfaceType) {
-      interfaceIndex = InterfaceType.Adrena
-    } else if ("hyloLpToken" in interfaceType) {
-      interfaceIndex = InterfaceType.HyloLpToken
-    } else if ("jupiterLend" in interfaceType) {
-      interfaceIndex = InterfaceType.JupiterLend
-    } else if ("kaminoVault" in interfaceType) {
-      interfaceIndex = InterfaceType.KaminoVault
-    } else if ("solstice" in interfaceType) {
-      interfaceIndex = InterfaceType.Solstice
-    } else if ("reflect" in interfaceType) {
-      interfaceIndex = InterfaceType.Reflect
-    } else if ("ore" in interfaceType) {
-      interfaceIndex = InterfaceType.Ore
-    } else if ("chainlink" in interfaceType) {
-      interfaceIndex = InterfaceType.Chainlink
-    } else if ("chainlinkDataStream" in interfaceType) {
-      interfaceIndex = InterfaceType.ChainlinkDataStream
-    } else if ("scope" in interfaceType) {
-      interfaceIndex = InterfaceType.Scope
-    } else if ("solsticeGlamVault" in interfaceType) {
-      interfaceIndex = InterfaceType.SolsticeGlamVault
-    } else {
-      throw new Error("Unsupported interface type")
-    }
+    const interfaceIndex = getInterfaceTypeIndex(getGenericSyMetaInitInterfaceType(account))
     const selfAddress = new GenericSyPda(genericStandardProgramId, interfaceIndex).syMeta({
       yieldBearingMint,
     })
 
-    const { syRate, additionalData } = await GenericSySdk.calculateSyRate(account, interfaceType, cnx)
+    const { syRate, additionalData } = await GenericSySdk.calculateSyRate(
+      account,
+      getGenericSyMetaInterfaceType(account),
+      cnx,
+    )
 
     const state: GenericSyState = {
       selfAddress,
@@ -671,7 +614,11 @@ export class GenericSySdk {
     const account = await fetcher.fetchGenericSyMeta(syMetaAddress)
     const tokenProgramBase = (await cnx.getAccountInfo(account.yieldBearingMint))?.owner
 
-    const { syRate, additionalData } = await GenericSySdk.calculateSyRate(account, account.interfaceType, cnx)
+    const { syRate, additionalData } = await GenericSySdk.calculateSyRate(
+      account,
+      getGenericSyMetaInterfaceType(account),
+      cnx,
+    )
 
     const state: GenericSyState = {
       selfAddress: syMetaAddress,
@@ -686,14 +633,14 @@ export class GenericSySdk {
 
   /** Reload the state of the account */
   async reload(cnx: web3.Connection) {
-    const account = await loadAccountState(
+    const fetcher = new ExponentFetcher({ connection: cnx, genericStandardProgramId: this.program.programId })
+    const account = await fetcher.fetchGenericSyMeta(this.state.selfAddress)
+    this.state.account = account
+    const { syRate, additionalData } = await GenericSySdk.calculateSyRate(
+      account,
+      getGenericSyMetaInterfaceType(account),
       cnx,
-      this.state.account.yieldBearingMint,
-      this.program.programId,
-      this.state.account.interfaceType,
     )
-    this.state.account = account
-    const { syRate, additionalData } = await GenericSySdk.calculateSyRate(account, account.interfaceType, cnx)
     this.state.syRate = syRate
     this.state.additionalData = additionalData
   }
@@ -702,6 +649,14 @@ export class GenericSySdk {
     return this.state.account
   }
 
+  get interfaceType() {
+    return getGenericSyMetaInterfaceType(this.account)
+  }
+
+  get initInterfaceType() {
+    return getGenericSyMetaInitInterfaceType(this.account)
+  }
+
   get mintSy() {
     return this.account.mintSy
   }
@@ -751,10 +706,7 @@ export class GenericSySdk {
   }
 
   get fragmetricData() {
-    if (
-      !("fragmetric" in this.state.account.interfaceType) &&
-      !("fragmetricSupportedAsset" in this.state.account.interfaceType)
-    ) {
+    if (!("fragmetric" in this.interfaceType) && !("fragmetricSupportedAsset" in this.interfaceType)) {
       throw new Error("Not a fragmetric interface")
     }
     if (!this.state.additionalData?.fragmetricData) {
@@ -764,7 +716,7 @@ export class GenericSySdk {
   }
 
   get jupiterLendData() {
-    if (!("jupiterLend" in this.state.account.interfaceType)) {
+    if (!("jupiterLend" in this.interfaceType)) {
       throw new Error("Not a Jupiter Lend interface")
     }
     if (!this.state.additionalData?.jupiterLendData) {
@@ -774,7 +726,7 @@ export class GenericSySdk {
   }
 
   get kaminoVaultData() {
-    if (!("kaminoVault" in this.state.account.interfaceType)) {
+    if (!("kaminoVault" in this.interfaceType)) {
       throw new Error("Not a Kamino Vault interface")
     }
     if (!this.state.additionalData?.kaminoVaultData) {
@@ -804,11 +756,7 @@ export class GenericSySdk {
       }))
       .concat(this.emissions.map((e) => ({ pubkey: e.escrowAccount, isSigner: false, isWritable: false })))
 
-    if (
-      ("fragmetric" in this.state.account.interfaceType ||
-        "fragmetricSupportedAsset" in this.state.account.interfaceType) &&
-      signer
-    ) {
+    if (("fragmetric" in this.interfaceType || "fragmetricSupportedAsset" in this.interfaceType) && signer) {
       // If skipWrap is true, return minimal accounts (skip additional interface-specific accounts)
       if (this.config.skipWrap) {
         return accounts
@@ -881,7 +829,7 @@ export class GenericSySdk {
       )
     }
 
-    if ("jupiterLend" in this.state.account.interfaceType) {
+    if ("jupiterLend" in this.interfaceType) {
       // If skipWrap is true, return minimal accounts (skip additional interface-specific accounts)
       if (this.config.skipWrap) {
         return accounts
@@ -1024,7 +972,7 @@ export class GenericSySdk {
       }
     }
 
-    if ("kaminoVault" in this.state.account.interfaceType) {
+    if ("kaminoVault" in this.interfaceType) {
       // If skipWrap is true, return minimal accounts (skip additional interface-specific accounts)
       if (this.config.skipWrap) {
         return accounts
@@ -1155,9 +1103,33 @@ export class GenericSySdk {
       .instruction()
   }
 
-  preInstructions() {
-    let ixs = []
-    if ("jupiterLend" in this.state.account.interfaceType) {
+  private getFragmetricReceiptTokenAccountSetupInstruction(signer?: web3.PublicKey) {
+    const isFragmetric = "fragmetric" in this.interfaceType || "fragmetricSupportedAsset" in this.interfaceType
+    if (!signer || !isFragmetric || this.config.skipWrap) {
+      return null
+    }
+
+    const { receiptTokenMint } = this.fragmetricData
+    const userReceiptTokenAccount = getAssociatedTokenAddressSync(receiptTokenMint, signer, true, TOKEN_2022_PROGRAM_ID)
+
+    return createAssociatedTokenAccountIdempotentInstruction(
+      signer,
+      userReceiptTokenAccount,
+      signer,
+      receiptTokenMint,
+      TOKEN_2022_PROGRAM_ID,
+    )
+  }
+
+  /** Returns interface-specific setup instructions for the signer. */
+  preInstructions(signer?: web3.PublicKey) {
+    const ixs: web3.TransactionInstruction[] = []
+    const receiptTokenAccountSetupIx = this.getFragmetricReceiptTokenAccountSetupInstruction(signer)
+    if (receiptTokenAccountSetupIx) {
+      ixs.push(receiptTokenAccountSetupIx)
+    }
+
+    if ("jupiterLend" in this.interfaceType) {
       const jupiterLendData = this.state.additionalData?.jupiterLendData
       if (!jupiterLendData) {
         throw new Error("Jupiter lend data not loaded")
@@ -1197,7 +1169,7 @@ export class GenericSySdk {
       ixs.push(refreshInstruction)
     }
 
-    if ("splStakePool" in this.state.account.interfaceType) {
+    if ("splStakePool" in this.interfaceType) {
       const splStakePoolData = this.state.additionalData?.splStakePoolData
       if (!splStakePoolData) {
         throw new Error("SPL stake pool data not loaded")
@@ -1226,6 +1198,23 @@ export class GenericSySdk {
     return ixs
   }
 
+  /** Returns signer setup and refresh instructions, including those that require live interface state. */
+  async getPreInstructions(cnx: web3.Connection, signer?: web3.PublicKey): Promise<web3.TransactionInstruction[]> {
+    const instructions = this.preInstructions(signer)
+    if (!("exponentTranching" in this.interfaceType)) return instructions
+
+    const marketAddress = this.account.interfaceAccounts[0]
+    if (this.account.interfaceAccounts.length !== 1 || !marketAddress) {
+      throw new Error("Exponent Tranching interface requires exactly one market account")
+    }
+
+    const updateMarket = await buildExponentTranchingUpdateMarketInstruction({
+      connection: cnx,
+      marketAddress,
+    })
+    return [updateMarket, ...instructions]
+  }
+
   getSyState() {
     return this.program.methods
       .getState()
@@ -1304,6 +1293,37 @@ export class GenericSySdk {
       })
       .instruction()
   }
+
+  ixChangeInterfaceType({
+    signer,
+    interfaceAccounts,
+    interfaceType,
+  }: {
+    signer: web3.PublicKey
+    interfaceAccounts: web3.PublicKey[]
+    interfaceType: InterfaceTypeGeneric
+  }) {
+    return this.program.methods
+      .changeInterfaceType(interfaceAccounts, interfaceType)
+      .accountsStrict({
+        adminState: this.adminState,
+        feePayer: signer,
+        meta: this.selfAddress,
+        mintSy: this.mintSy,
+        signer,
+        systemProgram: web3.SystemProgram.programId,
+        tokenSyEscrow: this.tokenSyEscrow,
+        yieldBearingMint: this.vrtMint,
+      })
+      .remainingAccounts(
+        interfaceAccounts.map((pubkey) => ({
+          pubkey,
+          isSigner: false,
+          isWritable: true,
+        })),
+      )
+      .instruction()
+  }
 }
 
 export function initSy(

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,
+    ],
+  })
+}