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

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,15 +31,83 @@ 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"
 
+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
  */
@@ -86,48 +155,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 +185,36 @@ export enum InterfaceType {
   ChainlinkDataStream = 16,
   Scope = 17,
   SolsticeGlamVault = 18,
+  ExponentTranching = 19,
+  GlowVault = 20,
+  LoopscaleVaultLp = 21,
+}
+
+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
+  if ("loopscaleVaultLp" in interfaceType) return InterfaceType.LoopscaleVaultLp
+
+  throw new Error("Unsupported interface type")
 }
 
 export function getInterfaceTypeObj(
@@ -219,6 +277,12 @@ 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: [] } }
+    case InterfaceType.LoopscaleVaultLp:
+      return { loopscaleVaultLp: { padding: [] } }
     default:
       throw new Error(`Unsupported interface type: ${interfaceType}`)
   }
@@ -278,6 +342,13 @@ 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: [] } }
+    case "loopscale-vault":
+    case "loopscale-vault-lp":
+      return { loopscaleVaultLp: { padding: [] } }
     default:
       throw new Error(`Unsupported interface type: ${interfaceType}`)
   }
@@ -306,61 +377,26 @@ 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)
   }
 
-  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 }
@@ -414,7 +450,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 +470,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 +485,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 +608,50 @@ 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 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 }
     }
@@ -596,53 +674,17 @@ 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,
+      cnx,
+      syMetaAddress: selfAddress,
+      genericStandardProgramId,
+    })
 
     const state: GenericSyState = {
       selfAddress,
@@ -671,7 +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(account, account.interfaceType, cnx)
+    const { syRate, additionalData } = await GenericSySdk.calculateSyRate({
+      account,
+      cnx,
+      syMetaAddress,
+      genericStandardProgramId,
+    })
 
     const state: GenericSyState = {
       selfAddress: syMetaAddress,
@@ -686,14 +733,16 @@ export class GenericSySdk {
 
   /** Reload the state of the account */
   async reload(cnx: web3.Connection) {
-    const account = await loadAccountState(
-      cnx,
-      this.state.account.yieldBearingMint,
-      this.program.programId,
-      this.state.account.interfaceType,
-    )
+    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(account, account.interfaceType, cnx)
+    const { syRate, additionalData } = await GenericSySdk.calculateSyRate({
+      account,
+      cnx,
+      syMetaAddress: this.state.selfAddress,
+      genericStandardProgramId,
+    })
     this.state.syRate = syRate
     this.state.additionalData = additionalData
   }
@@ -702,6 +751,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 +808,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 +818,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 +828,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 +858,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 +931,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 +1074,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 +1205,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 +1271,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 +1300,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 +1395,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(