@exponent-labs/generic-sy-sdk 0.1.3 → 0.1.6

package/build/index.js

@@ -2,15 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initSy = exports.GenericSySdk = exports.getInterfaceTypeFromString = exports.getInterfaceTypeObj = exports.InterfaceType = void 0;
 const anchor_1 = require("@coral-xyz/anchor");
-const generic_sy_idl_1 = require("@exponent-labs/generic-sy-idl");
 const spl_token_1 = require("@solana/spl-token");
-const generic_sy_pda_1 = require("@exponent-labs/generic-sy-pda");
-const exponent_fetcher_1 = require("@exponent-labs/exponent-fetcher");
 const exponent_admin_pda_1 = require("@exponent-labs/exponent-admin-pda");
-const utils_1 = require("./utils");
+const exponent_fetcher_1 = require("@exponent-labs/exponent-fetcher");
 const fragmetric_pda_1 = require("@exponent-labs/fragmetric-pda");
-const generic_sy_idl_2 = require("@exponent-labs/generic-sy-idl");
+const generic_sy_idl_1 = require("@exponent-labs/generic-sy-idl");
+const generic_sy_pda_1 = require("@exponent-labs/generic-sy-pda");
 const precise_number_1 = require("@exponent-labs/precise-number");
+const utils_1 = require("./utils");
 async function loadAccountState(cnx, yieldBearingMint, genericStandardProgramId, interfaceType) {
     let interfaceIndex;
     if ("pyth" in interfaceType) {
@@ -28,9 +27,30 @@ async function loadAccountState(cnx, yieldBearingMint, genericStandardProgramId,
     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");
     }
@@ -50,6 +70,13 @@ var InterfaceType;
     InterfaceType[InterfaceType["Fragmetric"] = 3] = "Fragmetric";
     InterfaceType[InterfaceType["Meteora"] = 4] = "Meteora";
     InterfaceType[InterfaceType["FragmetricSupportedAsset"] = 5] = "FragmetricSupportedAsset";
+    InterfaceType[InterfaceType["Sanctum"] = 6] = "Sanctum";
+    InterfaceType[InterfaceType["JupiterPerps"] = 7] = "JupiterPerps";
+    InterfaceType[InterfaceType["Adrena"] = 8] = "Adrena";
+    InterfaceType[InterfaceType["HyloLpToken"] = 9] = "HyloLpToken";
+    InterfaceType[InterfaceType["JupiterLend"] = 10] = "JupiterLend";
+    InterfaceType[InterfaceType["KaminoVault"] = 11] = "KaminoVault";
+    InterfaceType[InterfaceType["Solstice"] = 12] = "Solstice";
 })(InterfaceType || (exports.InterfaceType = InterfaceType = {}));
 function getInterfaceTypeObj(interfaceType) {
     switch (interfaceType) {
@@ -65,6 +92,27 @@ function getInterfaceTypeObj(interfaceType) {
             return { fragmetricSupportedAsset: {} };
         case InterfaceType.Meteora:
             return { meteora: {} };
+        case InterfaceType.Sanctum:
+            return { sanctum: {} };
+        case InterfaceType.JupiterPerps:
+            return {
+                jupiterPerps: {
+                    lastFeeUsdResetUnixTimestamp: 0,
+                    lastRealizedFeeUsd: new anchor_1.BN(0),
+                    lastAumUsd: new anchor_1.BN(0),
+                    lastRealizedFeeUsdUpdateUnixTimestamp: 0,
+                },
+            };
+        case InterfaceType.Adrena:
+            return { adrena: { previousTotalFees: new anchor_1.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}`);
     }
@@ -84,6 +132,27 @@ function getInterfaceTypeFromString(interfaceType) {
             return { fragmetricSupportedAsset: {} };
         case "meteora":
             return { meteora: {} };
+        case "sanctum":
+            return { sanctum: {} };
+        case "jupiter-perps":
+            return {
+                jupiterPerps: {
+                    lastFeeUsdResetUnixTimestamp: 0,
+                    lastRealizedFeeUsd: new anchor_1.BN(0),
+                    lastAumUsd: new anchor_1.BN(0),
+                    lastRealizedFeeUsdUpdateUnixTimestamp: 0,
+                },
+            };
+        case "adrena":
+            return { adrena: { previousTotalFees: new anchor_1.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}`);
     }
@@ -95,7 +164,7 @@ class GenericSySdk {
     program;
     config;
     syPda;
-    constructor(state, programId = new anchor_1.web3.PublicKey(generic_sy_idl_2.PROGRAM_ID), config = {}) {
+    constructor(state, programId = new anchor_1.web3.PublicKey(generic_sy_idl_1.PROGRAM_ID), config = {}) {
         this.state = state;
         this.config = config;
         // create a fake AnchorProvider -- which is unused
@@ -120,6 +189,27 @@ class GenericSySdk {
         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");
         }
@@ -140,14 +230,24 @@ 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 (0, exponent_fetcher_1.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);
@@ -159,6 +259,98 @@ class GenericSySdk {
             const virtualPrice = await (0, exponent_fetcher_1.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 (0, exponent_fetcher_1.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 (0, exponent_fetcher_1.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 (0, exponent_fetcher_1.fetchJupiterPerpsIndex)({
+                connection: cnx,
+                pool: account.interfaceAccounts[0],
+                lastFeeUsdResetUnixTimestamp: j.lastFeeUsdResetUnixTimestamp,
+                lastRealizedFeeUsd: new anchor_1.BN(j.lastRealizedFeeUsd),
+                lastAumUsd: new anchor_1.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(precise_number_1.PreciseNumber.fromRaw(account.index[0]).valueString);
+            return { syRate };
+        }
+        else if ("jupiterLend" in interfaceType) {
+            const { index, baseTokenMint, tokenReservesLiquidity, lendingSupplyPosition, rewardsRateModel, rateModel } = await (0, exponent_fetcher_1.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 (0, exponent_fetcher_1.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 (0, exponent_fetcher_1.fetchSolsticeRedemptionRate)({
+                connection: cnx,
+                yieldPool: account.interfaceAccounts[0],
+                vestingSchedule: account.interfaceAccounts[1],
+            });
+            return { syRate: redemptionRate };
+        }
         else {
             return { syRate: 1 };
         }
@@ -166,7 +358,7 @@ class GenericSySdk {
     /** Load an instance of SyMeta */
     static async load({ cnx, yieldBearingMint, interfaceType, genericStandardProgramId, config = {}, }) {
         const account = await loadAccountState(cnx, yieldBearingMint, genericStandardProgramId, interfaceType);
-        const tokenProgramBase = spl_token_1.TOKEN_PROGRAM_ID;
+        const tokenProgramBase = (await cnx.getAccountInfo(yieldBearingMint))?.owner;
         let interfaceIndex;
         if ("pyth" in interfaceType) {
             interfaceIndex = InterfaceType.Pyth;
@@ -186,19 +378,40 @@ class GenericSySdk {
         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");
         }
         const selfAddress = new generic_sy_pda_1.GenericSyPda(genericStandardProgramId, interfaceIndex).syMeta({
             yieldBearingMint,
         });
-        const { syRate, fragmetricData } = await GenericSySdk.calculateSyRate(account, interfaceType, cnx);
+        const { syRate, additionalData } = await GenericSySdk.calculateSyRate(account, interfaceType, cnx);
         const state = {
             selfAddress,
             account,
             tokenProgramBase,
             syRate,
-            fragmetricData,
+            additionalData,
         };
         return new GenericSySdk(state, genericStandardProgramId, config);
     }
@@ -207,13 +420,13 @@ class GenericSySdk {
         const fetcher = new exponent_fetcher_1.ExponentFetcher({ connection: cnx, genericStandardProgramId });
         const account = await fetcher.fetchGenericSyMeta(syMetaAddress);
         const tokenProgramBase = spl_token_1.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 = {
             selfAddress: syMetaAddress,
             account,
             tokenProgramBase,
             syRate,
-            fragmetricData,
+            additionalData,
         };
         return new GenericSySdk(state, genericStandardProgramId, config);
     }
@@ -221,9 +434,9 @@ class GenericSySdk {
     async reload(cnx) {
         const account = await loadAccountState(cnx, this.state.account.yieldBearingMint, this.program.programId, 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() {
         return this.state.account;
@@ -256,7 +469,7 @@ class GenericSySdk {
         return this.state.tokenProgramBase;
     }
     get tokenVrtEscrow() {
-        return (0, spl_token_1.getAssociatedTokenAddressSync)(this.vrtMint, this.selfAddress, true, spl_token_1.TOKEN_PROGRAM_ID);
+        return (0, spl_token_1.getAssociatedTokenAddressSync)(this.vrtMint, this.selfAddress, true, this.tokenProgramBase);
     }
     get tokenSyEscrow() {
         return this.state.account.tokenSyEscrow;
@@ -269,10 +482,28 @@ class GenericSySdk {
             !("fragmetricSupportedAsset" in this.state.account.interfaceType)) {
             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() {
         const accounts = this.account.interfaceAccounts
@@ -284,7 +515,7 @@ class GenericSySdk {
             .concat(this.emissions.map((e) => ({ pubkey: e.escrowAccount, isSigner: false, isWritable: false })));
         return accounts;
     }
-    getAccountsWithSigner(signer) {
+    getAccountsWithSigner(signer, type = "mint") {
         const accounts = this.account.interfaceAccounts
             .map((a) => ({
             pubkey: a,
@@ -292,14 +523,19 @@ class GenericSySdk {
             isWritable: true,
         }))
             .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 fragmetric_pda_1.FragmetricPda();
             const fragmetricFundAccount = fragmetricPda.fundAccount(fragmetricReceiptTokenMint);
             const fragmetricRewardAccount = fragmetricPda.rewardAccount(fragmetricReceiptTokenMint);
@@ -325,19 +561,170 @@ class GenericSySdk {
                 isWritable: false,
             });
         }
+        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 anchor_1.web3.PublicKey("7s1da8DduuBFqGra5bJBjpnvL5E9mGzCuMk1Qkh4or2Z");
+            const vaultAta = (0, spl_token_1.getAssociatedTokenAddressSync)(jupiterLendData.baseTokenMint, vaultAuthority, true, this.tokenProgramBase);
+            if (type === "mint") {
+                const depositorTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(jupiterLendData.baseTokenMint, signer, true, this.tokenProgramBase);
+                const recipientTokenAccount = (0, spl_token_1.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 anchor_1.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 anchor_1.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: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false }, { pubkey: anchor_1.web3.SystemProgram.programId, isSigner: false, isWritable: false }, {
+                    pubkey: new anchor_1.web3.PublicKey("jup3YeL8QhtSx1e253b2FDvsMNC87fDrgQZivbrndc9"),
+                    isSigner: false,
+                    isWritable: false,
+                });
+            }
+            else if (type === "redeem") {
+                const recipientTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(jupiterLendData.baseTokenMint, signer, true, this.tokenProgramBase);
+                const depositorTokenAccount = (0, spl_token_1.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 anchor_1.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 anchor_1.web3.PublicKey("HN1r4VfkDn53xQQfeGDYrNuDKFdemAhZsHYRwBrFhsW"),
+                    isSigner: false,
+                    isWritable: true,
+                }, 
+                // liquidity
+                {
+                    pubkey: new anchor_1.web3.PublicKey("7s1da8DduuBFqGra5bJBjpnvL5E9mGzCuMk1Qkh4or2Z"),
+                    isSigner: false,
+                    isWritable: true,
+                }, 
+                // liquidity program
+                {
+                    pubkey: new anchor_1.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: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false }, { pubkey: anchor_1.web3.SystemProgram.programId, isSigner: false, isWritable: false }, {
+                    pubkey: new anchor_1.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 = (0, spl_token_1.getAssociatedTokenAddressSync)(kaminoVaultData.tokenMint, signer, true, spl_token_1.TOKEN_PROGRAM_ID);
+            const userSharesAta = (0, spl_token_1.getAssociatedTokenAddressSync)(this.vrtMint, signer, true, spl_token_1.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 anchor_1.web3.PublicKey("KLend2g3cP87fffoy8q1mQqGKjrxjC8boSyAYavgmjD"),
+                isSigner: false,
+                isWritable: false,
+            }, 
+            // token_program
+            { pubkey: spl_token_1.TOKEN_PROGRAM_ID, isSigner: false, isWritable: false }, 
+            // shares_token_program
+            { pubkey: spl_token_1.TOKEN_PROGRAM_ID, isSigner: false, isWritable: false }, 
+            // event_authority
+            {
+                pubkey: new anchor_1.web3.PublicKey("24tHwQyJJ9akVXxnvkekGfAoeUJXXS7mE6kQNioNySsK"),
+                isSigner: false,
+                isWritable: true,
+            }, 
+            // kamino vault program
+            {
+                pubkey: new anchor_1.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;
     }
     ixMintSy({ depositor, amountBase, baseSrc, syDst, }) {
         baseSrc = baseSrc || (0, spl_token_1.getAssociatedTokenAddressSync)(this.vrtMint, depositor, true, this.state.tokenProgramBase);
-        console.log("baseSrc", baseSrc.toBase58());
-        console.log("depositor", depositor.toBase58());
         syDst = syDst || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, depositor, true, spl_token_1.TOKEN_PROGRAM_ID);
-        console.log("this.selfAddress", this.selfAddress.toBase58());
         return this.program.methods
             .mint(new anchor_1.BN(amountBase))
             .accountsStrict({
             meta: this.selfAddress,
-            baseTokenProgram: this.tokenProgramBase,
+            baseTokenProgram: this.state.tokenProgramBase,
             depositor,
             mintSy: this.mintSy,
             tokenBaseDepositor: baseSrc,
@@ -363,9 +750,51 @@ 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 anchor_1.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 anchor_1.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()
@@ -398,30 +827,30 @@ class GenericSySdk {
             preMintHookDiscriminator: Buffer.from(hook.preMintHookDiscriminator),
             postRedeemHookDiscriminator: Buffer.from(hook.postRedeemHookDiscriminator),
         };
-        return this.program.methods.modifyHook(modifiedHook).accountsStrict({
+        return this.program.methods
+            .modifyHook(modifiedHook)
+            .accountsStrict({
             adminState: this.adminState,
             signer,
             feePayer: signer,
             meta: this.selfAddress,
             systemProgram: anchor_1.web3.SystemProgram.programId,
-        });
+        })
+            .instruction();
     }
 }
 exports.GenericSySdk = GenericSySdk;
-function initSy(signer, interfaceAccounts, yieldBearingMint, interfaceIndex, syToken, initConfig) {
+function initSy(signer, interfaceAccounts, yieldBearingMint, interfaceIndex, syToken, initConfig, yieldBearingMintTokenProgram = spl_token_1.TOKEN_PROGRAM_ID) {
     const program = new anchor_1.Program(generic_sy_idl_1.IDL, new anchor_1.AnchorProvider(new anchor_1.web3.Connection("https://api.devnet.solana.com"), new utils_1.MyWallet(anchor_1.web3.Keypair.generate())));
-    console.log("interfaceIndex", interfaceIndex);
     const pda = new generic_sy_pda_1.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 exponent_admin_pda_1.ExponentAdminPda(exponent_admin_pda_1.EXPONENT_ADMIN_PROGRAM_ID);
     const metaplexMetadataProgram = new anchor_1.web3.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
     const mintSyMetaplexMetadataPda = anchor_1.web3.PublicKey.findProgramAddressSync([Buffer.from("metadata"), metaplexMetadataProgram.toBuffer(), mintSy.toBuffer()], metaplexMetadataProgram)[0];
-    const tokenVrtEscrow = (0, spl_token_1.getAssociatedTokenAddressSync)(yieldBearingMint, syMetaAddress, true, spl_token_1.TOKEN_PROGRAM_ID);
+    const tokenVrtEscrow = (0, spl_token_1.getAssociatedTokenAddressSync)(yieldBearingMint, syMetaAddress, true, yieldBearingMintTokenProgram);
     const { minMintSize, minRedeemSize } = initConfig ? initConfig : { minMintSize: new anchor_1.BN(0), minRedeemSize: new anchor_1.BN(0) };
-    const { name: tokenName, uri: tokenUri, symbol: tokenSymbol, } = syToken ? syToken : { symbol: "ewfragBTC", name: "Exponent Wrapped wfragBTC", uri: "" };
+    const { name: tokenName, uri: tokenUri, symbol: tokenSymbol, } = syToken ? syToken : { symbol: "wjlSOL", name: "Exponent Wrapped jlSOL", uri: "" };
     const interfaceType = getInterfaceTypeObj(interfaceIndex);
     const ix = program.methods
         .initSy(minMintSize, minRedeemSize, tokenName, tokenSymbol, tokenUri, interfaceAccounts, interfaceType)
@@ -432,7 +861,7 @@ function initSy(signer, interfaceAccounts, yieldBearingMint, interfaceIndex, syT
         admin: signer,
         yieldBearingMint,
         syTokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-        yieldBearingTokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+        yieldBearingTokenProgram: yieldBearingMintTokenProgram,
         tokenSyEscrow: pda.syEscrow({ yieldBearingMint }),
         systemProgram: anchor_1.web3.SystemProgram.programId,
         metadata: mintSyMetaplexMetadataPda,