@exponent-labs/generic-sy-sdk 0.1.0 → 0.1.5

package/src/index.ts

@@ -1,21 +1,39 @@
 import { AnchorProvider, BN, Program, web3 } from "@coral-xyz/anchor"
-import { IDL, GenericStandard } from "@exponent-labs/generic-sy-idl"
-import { getAssociatedTokenAddressSync, TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID } from "@solana/spl-token"
-import { GenericSyPda } from "@exponent-labs/generic-sy-pda"
-import { GenericSyState, GenericSyMetaAccount, InterfaceTypeGeneric, Hook } from "@exponent-labs/exponent-types"
+import {
+  ASSOCIATED_TOKEN_PROGRAM_ID,
+  TOKEN_2022_PROGRAM_ID,
+  TOKEN_PROGRAM_ID,
+  getAssociatedTokenAddressSync,
+} from "@solana/spl-token"
+
+import { EXPONENT_ADMIN_PROGRAM_ID, ExponentAdminPda } from "@exponent-labs/exponent-admin-pda"
 import {
   ExponentFetcher,
+  fetchAdrenaIndex,
   fetchFragmetricIndex,
   fetchFragmetricSupportedTokenIndex,
+  fetchJupiterLendIndex,
+  fetchKaminoVaultIndex,
   fetchMeteoraIndex,
+  fetchSanctumIndex,
   fetchSplStakePoolIndex,
+  fetchJupiterPerpsIndex,
+  fetchSolsticeRedemptionRate,
 } from "@exponent-labs/exponent-fetcher"
-import { EXPONENT_ADMIN_PROGRAM_ID, ExponentAdminPda } from "@exponent-labs/exponent-admin-pda"
-import { MyWallet } from "./utils"
-import { FragmetricPda, FRAGMETRIC_PROGRAM_ID } from "@exponent-labs/fragmetric-pda"
-import { PROGRAM_ID as GENERIC_STANDARD_PROGRAM_ID } from "@exponent-labs/generic-sy-idl"
+import {
+  GenericSyMetaAccount,
+  GenericSyState,
+  Hook,
+  InterfaceTypeGeneric,
+  AdditionalDataGeneric,
+} 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 { SyInitializeConfig, SyTokenMetadata } from "./types"
+import { MyWallet } from "./utils"
 
 async function loadAccountState(
   cnx: web3.Connection,
@@ -34,8 +52,22 @@ async function loadAccountState(
     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 {
     throw new Error("Unsupported interface type")
   }
@@ -55,6 +87,13 @@ export enum InterfaceType {
   Fragmetric = 3,
   Meteora = 4,
   FragmetricSupportedAsset = 5,
+  Sanctum = 6,
+  JupiterPerps = 7,
+  Adrena = 8,
+  HyloLpToken = 9,
+  JupiterLend = 10,
+  KaminoVault = 11,
+  Solstice = 12,
 }
 
 export function getInterfaceTypeObj(interfaceType: number): InterfaceTypeGeneric {
@@ -71,7 +110,27 @@ export function getInterfaceTypeObj(interfaceType: number): InterfaceTypeGeneric
       return { fragmetricSupportedAsset: {} }
     case InterfaceType.Meteora:
       return { meteora: {} }
-
+    case InterfaceType.Sanctum:
+      return { sanctum: {} }
+    case InterfaceType.JupiterPerps:
+      return {
+        jupiterPerps: {
+          lastFeeUsdResetUnixTimestamp: 0,
+          lastRealizedFeeUsd: new BN(0),
+          lastAumUsd: new BN(0),
+          lastRealizedFeeUsdUpdateUnixTimestamp: 0,
+        },
+      }
+    case InterfaceType.Adrena:
+      return { adrena: { previousTotalFees: new BN(0) } }
+    case InterfaceType.HyloLpToken:
+      return { hyloLpToken: {} }
+    case InterfaceType.JupiterLend:
+      return { jupiterLend: { padding: [] } }
+    case InterfaceType.KaminoVault:
+      return { kaminoVault: { padding: [] } }
+    case InterfaceType.Solstice:
+      return { solstice: { padding: [] } }
     default:
       throw new Error(`Unsupported interface type: ${interfaceType}`)
   }
@@ -91,13 +150,34 @@ export function getInterfaceTypeFromString(interfaceType: string): InterfaceType
       return { fragmetricSupportedAsset: {} }
     case "meteora":
       return { meteora: {} }
+    case "sanctum":
+      return { sanctum: {} }
+    case "jupiter-perps":
+      return {
+        jupiterPerps: {
+          lastFeeUsdResetUnixTimestamp: 0,
+          lastRealizedFeeUsd: new BN(0),
+          lastAumUsd: new BN(0),
+          lastRealizedFeeUsdUpdateUnixTimestamp: 0,
+        },
+      }
+    case "adrena":
+      return { adrena: { previousTotalFees: new BN(0) } }
+    case "hylo-lp-token":
+      return { hyloLpToken: {} }
+    case "jupiter-lend":
+      return { jupiterLend: { padding: [] } }
+    case "kamino-vault":
+      return { kaminoVault: { padding: [] } }
+    case "solstice":
+      return { solstice: { padding: [] } }
     default:
       throw new Error(`Unsupported interface type: ${interfaceType}`)
   }
 }
 
 interface GenericSyConfig {
-  skipFragmetricWrap?: boolean
+  skipWrap?: boolean
 }
 
 export class GenericSySdk {
@@ -118,6 +198,7 @@ export class GenericSySdk {
       IDL,
       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) {
@@ -132,9 +213,24 @@ export class GenericSySdk {
       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 {
       throw new Error("Unsupported interface type")
     }
+
     this.syPda = new GenericSyPda(programId, interfaceIndex)
   }
 
@@ -144,7 +240,7 @@ export class GenericSySdk {
     cnx: web3.Connection,
   ): Promise<{
     syRate: number
-    fragmetricData?: { receiptTokenMint: web3.PublicKey; wrappedTokenMint: web3.PublicKey }
+    additionalData?: AdditionalDataGeneric
   }> {
     if ("pyth" in interfaceType) {
       const syRate = Number(PreciseNumber.fromRaw(account.index[0]).valueString)
@@ -158,13 +254,23 @@ export class GenericSySdk {
         fragmetricFund: account.interfaceAccounts[0],
         index: 0,
       })
-      return { syRate: index, fragmetricData: { receiptTokenMint, wrappedTokenMint } }
+      return {
+        syRate: index,
+        additionalData: {
+          fragmetricData: { receiptTokenMint, wrappedTokenMint },
+        },
+      }
     } else if ("fragmetric" in interfaceType) {
       const { index, receiptTokenMint, wrappedTokenMint } = await fetchFragmetricIndex({
         connection: cnx,
         fragmetricFund: account.interfaceAccounts[0],
       })
-      return { syRate: index, fragmetricData: { receiptTokenMint, wrappedTokenMint } }
+      return {
+        syRate: index,
+        additionalData: {
+          fragmetricData: { receiptTokenMint, wrappedTokenMint },
+        },
+      }
     } else if ("meteora" in interfaceType) {
       const currentTs = Math.floor(Date.now() / 1000)
 
@@ -177,6 +283,98 @@ export class GenericSySdk {
       const virtualPrice = await fetchMeteoraIndex({ connection: cnx, accounts, onChainTime: currentTs })
 
       return { syRate: virtualPrice.virtualPrice }
+    } else if ("sanctum" in interfaceType) {
+      const accounts = {
+        lpMint: account.interfaceAccounts[0],
+        poolState: account.interfaceAccounts[1],
+      }
+
+      const exchangeRate = await fetchSanctumIndex({ connection: cnx, accounts })
+
+      return { syRate: exchangeRate }
+    } else if ("adrena" in interfaceType) {
+      // @ts-ignore
+      const previousTotalFees = account.interfaceType.adrena.previousTotalFees
+      const currentIndex = account.index
+
+      let accounts = {
+        pool: account.interfaceAccounts[0],
+        custody1: account.interfaceAccounts[1],
+        custody2: account.interfaceAccounts[2],
+        custody3: account.interfaceAccounts[3],
+        custody4: account.interfaceAccounts[4],
+      }
+
+      const syRate = await fetchAdrenaIndex({ connection: cnx, accounts, currentIndex, previousTotalFees })
+
+      return { syRate: syRate.index }
+    } else if ("jupiterPerps" in interfaceType) {
+      // @ts-ignore
+      const j = account.interfaceType.jupiterPerps
+      const { index } = await fetchJupiterPerpsIndex({
+        connection: cnx,
+        pool: account.interfaceAccounts[0],
+        lastFeeUsdResetUnixTimestamp: j.lastFeeUsdResetUnixTimestamp,
+        lastRealizedFeeUsd: new BN(j.lastRealizedFeeUsd),
+        lastAumUsd: new BN(j.lastAumUsd),
+        currentIndex: account.index,
+        lastRealizedFeeUsdUpdateUnixTimestamp: j.lastRealizedFeeUsdUpdateUnixTimestamp,
+      })
+      return { syRate: index }
+    } else if ("hyloLpToken" in interfaceType) {
+      // For HyloLpToken, the exchange rate is calculated by the Rust program using hylo_cpi
+      // and will be available in the index field
+      const syRate = Number(PreciseNumber.fromRaw(account.index[0]).valueString)
+      return { syRate }
+    } else if ("jupiterLend" in interfaceType) {
+      const { index, baseTokenMint, tokenReservesLiquidity, lendingSupplyPosition, rewardsRateModel, rateModel } =
+        await fetchJupiterLendIndex({
+          connection: cnx,
+          jupiterLendAccount: account.interfaceAccounts[0],
+        })
+
+      return {
+        syRate: index,
+        additionalData: {
+          jupiterLendData: {
+            baseTokenMint,
+            tokenReservesLiquidity,
+            lendingSupplyPosition,
+            rewardsRateModel,
+            rateModel,
+          },
+        },
+      }
+    } else if ("kaminoVault" in interfaceType) {
+      const { index, tokenVault, tokenMint, baseVaultAuthority, sharesMint, reserves } = await fetchKaminoVaultIndex({
+        connection: cnx,
+        kaminoVaultAccount: account.interfaceAccounts[0],
+      })
+      return {
+        syRate: index,
+        additionalData: {
+          kaminoVaultData: {
+            vault: account.interfaceAccounts[0],
+            reserves: reserves.map((r) => {
+              return {
+                reserveAddress: r.reserveAddress,
+                marketAddress: r.reserve,
+              }
+            }),
+            tokenVault,
+            tokenMint,
+            baseVaultAuthority,
+            sharesMint,
+          },
+        },
+      }
+    } else if ("solstice" in interfaceType) {
+      const { redemptionRate } = await fetchSolsticeRedemptionRate({
+        connection: cnx,
+        yieldPool: account.interfaceAccounts[0],
+        vestingSchedule: account.interfaceAccounts[1],
+      })
+      return { syRate: redemptionRate }
     } else {
       return { syRate: 1 }
     }
@@ -197,7 +395,7 @@ export class GenericSySdk {
     config?: GenericSyConfig
   }) {
     const account = await loadAccountState(cnx, yieldBearingMint, genericStandardProgramId, interfaceType)
-    const tokenProgramBase = TOKEN_PROGRAM_ID
+    const tokenProgramBase = (await cnx.getAccountInfo(yieldBearingMint))?.owner
 
     let interfaceIndex: number
     if ("pyth" in interfaceType) {
@@ -212,6 +410,20 @@ export class GenericSySdk {
       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 {
       throw new Error("Unsupported interface type")
     }
@@ -219,14 +431,14 @@ export class GenericSySdk {
       yieldBearingMint,
     })
 
-    const { syRate, fragmetricData } = await GenericSySdk.calculateSyRate(account, interfaceType, cnx)
+    const { syRate, additionalData } = await GenericSySdk.calculateSyRate(account, interfaceType, cnx)
 
     const state: GenericSyState = {
       selfAddress,
       account,
       tokenProgramBase,
       syRate,
-      fragmetricData,
+      additionalData,
     }
 
     return new GenericSySdk(state, genericStandardProgramId, config)
@@ -248,14 +460,14 @@ export class GenericSySdk {
     const account = await fetcher.fetchGenericSyMeta(syMetaAddress)
     const tokenProgramBase = TOKEN_PROGRAM_ID
 
-    const { syRate, fragmetricData } = await GenericSySdk.calculateSyRate(account, account.interfaceType, cnx)
+    const { syRate, additionalData } = await GenericSySdk.calculateSyRate(account, account.interfaceType, cnx)
 
     const state: GenericSyState = {
       selfAddress: syMetaAddress,
       account,
       tokenProgramBase,
       syRate,
-      fragmetricData,
+      additionalData,
     }
 
     return new GenericSySdk(state, genericStandardProgramId, config)
@@ -270,9 +482,9 @@ export class GenericSySdk {
       this.state.account.interfaceType,
     )
     this.state.account = account
-    const { syRate, fragmetricData } = await GenericSySdk.calculateSyRate(account, account.interfaceType, cnx)
+    const { syRate, additionalData } = await GenericSySdk.calculateSyRate(account, account.interfaceType, cnx)
     this.state.syRate = syRate
-    this.state.fragmetricData = fragmetricData
+    this.state.additionalData = additionalData
   }
 
   get account() {
@@ -316,7 +528,7 @@ export class GenericSySdk {
   }
 
   get tokenVrtEscrow() {
-    return getAssociatedTokenAddressSync(this.vrtMint, this.selfAddress, true, TOKEN_PROGRAM_ID)
+    return getAssociatedTokenAddressSync(this.vrtMint, this.selfAddress, true, this.tokenProgramBase)
   }
 
   get tokenSyEscrow() {
@@ -334,10 +546,30 @@ export class GenericSySdk {
     ) {
       throw new Error("Not a fragmetric interface")
     }
-    if (!this.state.fragmetricData) {
+    if (!this.state.additionalData?.fragmetricData) {
       throw new Error("Fragmetric data not loaded")
     }
-    return this.state.fragmetricData
+    return this.state.additionalData.fragmetricData
+  }
+
+  get jupiterLendData() {
+    if (!("jupiterLend" in this.state.account.interfaceType)) {
+      throw new Error("Not a Jupiter Lend interface")
+    }
+    if (!this.state.additionalData?.jupiterLendData) {
+      throw new Error("Jupiter Lend data not loaded")
+    }
+    return this.state.additionalData.jupiterLendData
+  }
+
+  get kaminoVaultData() {
+    if (!("kaminoVault" in this.state.account.interfaceType)) {
+      throw new Error("Not a Kamino Vault interface")
+    }
+    if (!this.state.additionalData?.kaminoVaultData) {
+      throw new Error("Kamino Vault data not loaded")
+    }
+    return this.state.additionalData.kaminoVaultData
   }
 
   get remainingAccounts() {
@@ -352,7 +584,7 @@ export class GenericSySdk {
     return accounts
   }
 
-  getAccountsWithSigner(signer?: web3.PublicKey) {
+  getAccountsWithSigner(signer?: web3.PublicKey, type: "mint" | "redeem" = "mint") {
     const accounts = this.account.interfaceAccounts
       .map((a) => ({
         pubkey: a,
@@ -361,15 +593,22 @@ export class GenericSySdk {
       }))
       .concat(this.emissions.map((e) => ({ pubkey: e.escrowAccount, isSigner: false, isWritable: false })))
 
-    if ("fragmetric" in this.state.account.interfaceType && signer) {
-      // If skipFragmetricWrap is true, return minimal accounts
-      if (this.config.skipFragmetricWrap) {
+    if (
+      ("fragmetric" in this.state.account.interfaceType ||
+        "fragmetricSupportedAsset" in this.state.account.interfaceType) &&
+      signer
+    ) {
+      // If skipWrap is true, return minimal accounts (skip additional interface-specific accounts)
+      if (this.config.skipWrap) {
         return accounts
       }
 
-      // Existing fragmetric account logic
-      const fragmetricReceiptTokenMint = this.state.fragmetricData.receiptTokenMint
-      const fragmetricWrappedTokenMint = this.state.fragmetricData.wrappedTokenMint
+      // Fragmetric interface account logic
+      if (!this.state.additionalData?.fragmetricData) {
+        throw new Error("Fragmetric data not loaded for fragmetric interface")
+      }
+      const fragmetricReceiptTokenMint = this.state.additionalData.fragmetricData.receiptTokenMint
+      const fragmetricWrappedTokenMint = this.state.additionalData.fragmetricData.wrappedTokenMint
       const fragmetricPda = new FragmetricPda()
       const fragmetricFundAccount = fragmetricPda.fundAccount(fragmetricReceiptTokenMint)
       const fragmetricRewardAccount = fragmetricPda.rewardAccount(fragmetricReceiptTokenMint)
@@ -431,6 +670,215 @@ export class GenericSySdk {
       )
     }
 
+    if ("jupiterLend" in this.state.account.interfaceType) {
+      // If skipWrap is true, return minimal accounts (skip additional interface-specific accounts)
+      if (this.config.skipWrap) {
+        return accounts
+      }
+
+      const jupiterLendData = this.state.additionalData?.jupiterLendData
+      if (!jupiterLendData) {
+        throw new Error("Jupiter lend data not loaded")
+      }
+
+      console.log("accounts before push", accounts)
+
+      const vaultAuthority = new web3.PublicKey("7s1da8DduuBFqGra5bJBjpnvL5E9mGzCuMk1Qkh4or2Z")
+      const vaultAta = getAssociatedTokenAddressSync(
+        jupiterLendData.baseTokenMint,
+        vaultAuthority,
+        true,
+        this.tokenProgramBase,
+      )
+
+      if (type === "mint") {
+        const depositorTokenAccount = getAssociatedTokenAddressSync(
+          jupiterLendData.baseTokenMint,
+          signer,
+          true,
+          this.tokenProgramBase,
+        )
+        const recipientTokenAccount = getAssociatedTokenAddressSync(this.vrtMint, signer, true, this.tokenProgramBase)
+        console.log("jupiter lend rate model: ", jupiterLendData.rateModel.toBase58())
+        accounts.push(
+          { pubkey: signer, isSigner: true, isWritable: true },
+          { pubkey: depositorTokenAccount, isSigner: false, isWritable: true },
+          { pubkey: recipientTokenAccount, isSigner: false, isWritable: true },
+          { pubkey: jupiterLendData.baseTokenMint, isSigner: false, isWritable: true },
+          // lending admin
+          {
+            pubkey: new web3.PublicKey("5nmGjA4s7ATzpBQXC5RNceRpaJ7pYw2wKsNBWyuSAZV6"),
+            isSigner: false,
+            isWritable: false,
+          },
+          { pubkey: this.account.interfaceAccounts[0], isSigner: false, isWritable: true },
+          { pubkey: this.vrtMint, isSigner: false, isWritable: true },
+          { pubkey: jupiterLendData.tokenReservesLiquidity, isSigner: false, isWritable: true },
+          { pubkey: jupiterLendData.lendingSupplyPosition, isSigner: false, isWritable: true },
+          { pubkey: jupiterLendData.rateModel, isSigner: false, isWritable: true },
+          // vault
+          {
+            pubkey: vaultAta,
+            isSigner: false,
+            isWritable: true,
+          },
+          // supply vault owner - can be hardcoded
+          {
+            pubkey: vaultAuthority,
+            isSigner: false,
+            isWritable: true,
+          },
+          // liquidity program - can be hardcoded
+          {
+            pubkey: new web3.PublicKey("jupeiUmn818Jg1ekPURTpr4mFo29p46vygyykFJ3wZC"),
+            isSigner: false,
+            isWritable: true,
+          },
+          { pubkey: jupiterLendData.rewardsRateModel, isSigner: false, isWritable: true },
+          // token program
+          { pubkey: this.tokenProgramBase, isSigner: false, isWritable: false },
+          // associated token program
+          { pubkey: ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+          { pubkey: web3.SystemProgram.programId, isSigner: false, isWritable: false },
+          {
+            pubkey: new web3.PublicKey("jup3YeL8QhtSx1e253b2FDvsMNC87fDrgQZivbrndc9"),
+            isSigner: false,
+            isWritable: false,
+          },
+        )
+      } else if (type === "redeem") {
+        const recipientTokenAccount = getAssociatedTokenAddressSync(
+          jupiterLendData.baseTokenMint,
+          signer,
+          true,
+          this.tokenProgramBase,
+        )
+
+        const depositorTokenAccount = getAssociatedTokenAddressSync(this.vrtMint, signer, true, this.tokenProgramBase)
+
+        accounts.push(
+          { pubkey: signer, isSigner: true, isWritable: true },
+          { pubkey: depositorTokenAccount, isSigner: false, isWritable: true },
+          { pubkey: recipientTokenAccount, isSigner: false, isWritable: true },
+          {
+            // lending admin
+            pubkey: new web3.PublicKey("5nmGjA4s7ATzpBQXC5RNceRpaJ7pYw2wKsNBWyuSAZV6"),
+            isSigner: false,
+            isWritable: false,
+          },
+          // lending
+          { pubkey: this.account.interfaceAccounts[0], isSigner: false, isWritable: true },
+          { pubkey: jupiterLendData.baseTokenMint, isSigner: false, isWritable: true },
+
+          { pubkey: this.vrtMint, isSigner: false, isWritable: true },
+          { pubkey: jupiterLendData.tokenReservesLiquidity, isSigner: false, isWritable: true },
+          { pubkey: jupiterLendData.lendingSupplyPosition, isSigner: false, isWritable: true },
+          { pubkey: jupiterLendData.rateModel, isSigner: false, isWritable: true },
+          // vault
+          {
+            pubkey: vaultAta,
+            isSigner: false,
+            isWritable: true,
+          },
+          // claim account
+          {
+            pubkey: new web3.PublicKey("HN1r4VfkDn53xQQfeGDYrNuDKFdemAhZsHYRwBrFhsW"),
+            isSigner: false,
+            isWritable: true,
+          },
+          // liquidity
+          {
+            pubkey: new web3.PublicKey("7s1da8DduuBFqGra5bJBjpnvL5E9mGzCuMk1Qkh4or2Z"),
+            isSigner: false,
+            isWritable: true,
+          },
+          // liquidity program
+          {
+            pubkey: new web3.PublicKey("jupeiUmn818Jg1ekPURTpr4mFo29p46vygyykFJ3wZC"),
+            isSigner: false,
+            isWritable: true,
+          },
+          { pubkey: jupiterLendData.rewardsRateModel, isSigner: false, isWritable: true },
+          // token program
+          { pubkey: this.tokenProgramBase, isSigner: false, isWritable: false },
+          // associated token program
+          { pubkey: ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+          { pubkey: web3.SystemProgram.programId, isSigner: false, isWritable: false },
+          {
+            pubkey: new web3.PublicKey("jup3YeL8QhtSx1e253b2FDvsMNC87fDrgQZivbrndc9"),
+            isSigner: false,
+            isWritable: false,
+          },
+        )
+      }
+    }
+
+    if ("kaminoVault" in this.state.account.interfaceType) {
+      // If skipWrap is true, return minimal accounts (skip additional interface-specific accounts)
+      if (this.config.skipWrap) {
+        return accounts
+      }
+
+      const kaminoVaultData = this.state.additionalData?.kaminoVaultData
+      if (!kaminoVaultData) {
+        throw new Error("Kamino vault data not loaded")
+      }
+
+      const userTokenAta = getAssociatedTokenAddressSync(kaminoVaultData.tokenMint, signer, true, TOKEN_PROGRAM_ID)
+      const userSharesAta = getAssociatedTokenAddressSync(this.vrtMint, signer, true, TOKEN_PROGRAM_ID)
+
+      accounts.push(
+        // user
+        { pubkey: signer, isSigner: true, isWritable: true },
+        // vault_state
+        { pubkey: kaminoVaultData.vault, isSigner: false, isWritable: true },
+        // token_vault
+        { pubkey: kaminoVaultData.tokenVault, isSigner: false, isWritable: true },
+        // token_mint
+        { pubkey: kaminoVaultData.tokenMint, isSigner: false, isWritable: true },
+        // base_vault_authority
+        { pubkey: kaminoVaultData.baseVaultAuthority, isSigner: false, isWritable: true },
+        // shares_mint
+        { pubkey: kaminoVaultData.sharesMint, isSigner: false, isWritable: true },
+        // user_token_ata
+        { pubkey: userTokenAta, isSigner: false, isWritable: true },
+        // user_shares_ata
+        { pubkey: userSharesAta, isSigner: false, isWritable: true },
+        // klend_program
+        {
+          pubkey: new web3.PublicKey("KLend2g3cP87fffoy8q1mQqGKjrxjC8boSyAYavgmjD"),
+          isSigner: false,
+          isWritable: false,
+        },
+        // token_program
+        { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        // shares_token_program
+        { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        // event_authority
+        {
+          pubkey: new web3.PublicKey("24tHwQyJJ9akVXxnvkekGfAoeUJXXS7mE6kQNioNySsK"),
+          isSigner: false,
+          isWritable: true,
+        },
+        // kamino vault program
+        {
+          pubkey: new web3.PublicKey("KvauGMspG5k6rtzrqqn7WNn3oZdyKqLKwK2XWQ8FLjd"),
+          isSigner: false,
+          isWritable: false,
+        },
+        ...kaminoVaultData.reserves.map((reserve) => ({
+          pubkey: reserve.reserveAddress,
+          isSigner: false,
+          isWritable: true,
+        })),
+        ...kaminoVaultData.reserves.map((reserve) => ({
+          pubkey: reserve.marketAddress,
+          isSigner: false,
+          isWritable: true,
+        })),
+      )
+    }
+
     return accounts
   }
 
@@ -446,16 +894,13 @@ export class GenericSySdk {
     syDst?: web3.PublicKey
   }) {
     baseSrc = baseSrc || getAssociatedTokenAddressSync(this.vrtMint, depositor, true, this.state.tokenProgramBase)
-    console.log("baseSrc", baseSrc.toBase58())
-    console.log("depositor", depositor.toBase58())
     syDst = syDst || getAssociatedTokenAddressSync(this.mintSy, depositor, true, TOKEN_PROGRAM_ID)
 
-    console.log("this.selfAddress", this.selfAddress.toBase58())
     return this.program.methods
       .mint(new BN(amountBase))
       .accountsStrict({
         meta: this.selfAddress,
-        baseTokenProgram: this.tokenProgramBase,
+        baseTokenProgram: this.state.tokenProgramBase,
         depositor,
         mintSy: this.mintSy,
         tokenBaseDepositor: baseSrc,
@@ -493,10 +938,55 @@ export class GenericSySdk {
         baseTokenProgram: this.tokenProgramBase,
         tokenYieldBearingEscrow: this.tokenVrtEscrow,
       })
-      .remainingAccounts(this.getAccountsWithSigner(redeemer))
+      .remainingAccounts(this.getAccountsWithSigner(redeemer, "redeem"))
       .instruction()
   }
 
+  preInstructions() {
+    let ixs = []
+    if ("jupiterLend" in this.state.account.interfaceType) {
+      const jupiterLendData = this.state.additionalData?.jupiterLendData
+      if (!jupiterLendData) {
+        throw new Error("Jupiter lend data not loaded")
+      }
+
+      const refreshInstruction = new web3.TransactionInstruction({
+        keys: [
+          {
+            pubkey: this.account.interfaceAccounts[0],
+            isSigner: false,
+            isWritable: true,
+          },
+          {
+            pubkey: jupiterLendData.baseTokenMint,
+            isSigner: false,
+            isWritable: true,
+          },
+          {
+            pubkey: this.vrtMint,
+            isSigner: false,
+            isWritable: true,
+          },
+          {
+            pubkey: jupiterLendData.tokenReservesLiquidity,
+            isSigner: false,
+            isWritable: true,
+          },
+          {
+            pubkey: jupiterLendData.rewardsRateModel,
+            isSigner: false,
+            isWritable: true,
+          },
+        ],
+        programId: new web3.PublicKey("jup3YeL8QhtSx1e253b2FDvsMNC87fDrgQZivbrndc9"),
+        data: Buffer.from([24, 225, 53, 189, 72, 212, 225, 178]),
+      })
+      ixs.push(refreshInstruction)
+    }
+
+    return ixs
+  }
+
   getSyState() {
     return this.program.methods
       .getState()
@@ -540,13 +1030,16 @@ export class GenericSySdk {
       postRedeemHookDiscriminator: Buffer.from(hook.postRedeemHookDiscriminator),
     }
 
-    return this.program.methods.modifyHook(modifiedHook).accountsStrict({
-      adminState: this.adminState,
-      signer,
-      feePayer: signer,
-      meta: this.selfAddress,
-      systemProgram: web3.SystemProgram.programId,
-    })
+    return this.program.methods
+      .modifyHook(modifiedHook)
+      .accountsStrict({
+        adminState: this.adminState,
+        signer,
+        feePayer: signer,
+        meta: this.selfAddress,
+        systemProgram: web3.SystemProgram.programId,
+      })
+      .instruction()
   }
 }
 
@@ -557,18 +1050,18 @@ export function initSy(
   interfaceIndex: number,
   syToken?: SyTokenMetadata,
   initConfig?: SyInitializeConfig,
+  yieldBearingMintTokenProgram: web3.PublicKey = TOKEN_PROGRAM_ID,
 ) {
   const program = new Program<GenericStandard>(
     IDL,
     new AnchorProvider(new web3.Connection("https://api.devnet.solana.com"), new MyWallet(web3.Keypair.generate())),
   )
 
-  console.log("interfaceIndex", interfaceIndex)
   const pda = new GenericSyPda(program.programId, interfaceIndex)
   const syMetaAddress = pda.syMeta({ yieldBearingMint })
-  console.log("this.selfAddress in sdk", syMetaAddress.toBase58())
+
   const mintSy = pda.mintSy({ yieldBearingMint })
-  console.log("mintSy in sdk", mintSy.toBase58())
+
   const exponentAdminPda = new ExponentAdminPda(EXPONENT_ADMIN_PROGRAM_ID)
 
   const metaplexMetadataProgram = new web3.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s")
@@ -577,14 +1070,19 @@ export function initSy(
     metaplexMetadataProgram,
   )[0]
 
-  const tokenVrtEscrow = getAssociatedTokenAddressSync(yieldBearingMint, syMetaAddress, true, TOKEN_PROGRAM_ID)
+  const tokenVrtEscrow = getAssociatedTokenAddressSync(
+    yieldBearingMint,
+    syMetaAddress,
+    true,
+    yieldBearingMintTokenProgram,
+  )
 
   const { minMintSize, minRedeemSize } = initConfig ? initConfig : { minMintSize: new BN(0), minRedeemSize: new BN(0) }
   const {
     name: tokenName,
     uri: tokenUri,
     symbol: tokenSymbol,
-  } = syToken ? syToken : { symbol: "ewfragBTC", name: "Exponent Wrapped wfragBTC", uri: "" }
+  } = syToken ? syToken : { symbol: "wjlSOL", name: "Exponent Wrapped jlSOL", uri: "" }
 
   const interfaceType = getInterfaceTypeObj(interfaceIndex)
   const ix = program.methods
@@ -596,7 +1094,7 @@ export function initSy(
       admin: signer,
       yieldBearingMint,
       syTokenProgram: TOKEN_PROGRAM_ID,
-      yieldBearingTokenProgram: TOKEN_PROGRAM_ID,
+      yieldBearingTokenProgram: yieldBearingMintTokenProgram,
       tokenSyEscrow: pda.syEscrow({ yieldBearingMint }),
       systemProgram: web3.SystemProgram.programId,
       metadata: mintSyMetaplexMetadataPda,