@glamsystems/glam-sdk 0.1.26 → 0.1.27

package/index.cjs.js

@@ -34,7 +34,7 @@ var borsh__namespace = /*#__PURE__*/_interopNamespaceDefault(borsh);
 var address = "GLAMbTqav9N9witRjswJ8enwp9vv5G8bsSJ2kPJ4rcyc";
 var metadata = {
     name: "glam_protocol",
-    version: "0.4.28",
+    version: "0.4.29",
     spec: "0.1.0",
     description: "Glam Protocol"
 };
@@ -4284,10 +4284,12 @@ var instructions = [
         ],
         accounts: [
             {
-                name: "glam_state"
+                name: "glam_state",
+                writable: true
             },
             {
                 name: "glam_vault",
+                writable: true,
                 pda: {
                     seeds: [
                         {
@@ -4379,10 +4381,12 @@ var instructions = [
         ],
         accounts: [
             {
-                name: "glam_state"
+                name: "glam_state",
+                writable: true
             },
             {
                 name: "glam_vault",
+                writable: true,
                 pda: {
                     seeds: [
                         {
@@ -6662,6 +6666,146 @@ var instructions = [
             }
         ]
     },
+    {
+        name: "price_kamino_vault_shares",
+        discriminator: [
+            112,
+            92,
+            238,
+            224,
+            145,
+            105,
+            38,
+            249
+        ],
+        accounts: [
+            {
+                name: "glam_state",
+                writable: true
+            },
+            {
+                name: "glam_vault",
+                pda: {
+                    seeds: [
+                        {
+                            kind: "const",
+                            value: [
+                                118,
+                                97,
+                                117,
+                                108,
+                                116
+                            ]
+                        },
+                        {
+                            kind: "account",
+                            path: "glam_state"
+                        }
+                    ]
+                }
+            },
+            {
+                name: "signer",
+                writable: true,
+                signer: true
+            },
+            {
+                name: "kamino_lending_program",
+                address: "KLend2g3cP87fffoy8q1mQqGKjrxjC8boSyAYavgmjD"
+            },
+            {
+                name: "sol_oracle"
+            },
+            {
+                name: "glam_config",
+                pda: {
+                    seeds: [
+                        {
+                            kind: "const",
+                            value: [
+                                103,
+                                108,
+                                111,
+                                98,
+                                97,
+                                108,
+                                95,
+                                99,
+                                111,
+                                110,
+                                102,
+                                105,
+                                103
+                            ]
+                        }
+                    ],
+                    program: {
+                        kind: "const",
+                        value: [
+                            10,
+                            11,
+                            0,
+                            83,
+                            72,
+                            16,
+                            46,
+                            144,
+                            46,
+                            42,
+                            79,
+                            22,
+                            157,
+                            123,
+                            21,
+                            242,
+                            192,
+                            146,
+                            1,
+                            78,
+                            88,
+                            59,
+                            102,
+                            9,
+                            190,
+                            226,
+                            92,
+                            189,
+                            187,
+                            232,
+                            83,
+                            220
+                        ]
+                    }
+                }
+            },
+            {
+                name: "pyth_oracle",
+                optional: true
+            },
+            {
+                name: "switchboard_price_oracle",
+                optional: true
+            },
+            {
+                name: "switchboard_twap_oracle",
+                optional: true
+            },
+            {
+                name: "scope_prices",
+                optional: true
+            }
+        ],
+        args: [
+            {
+                name: "denom",
+                type: {
+                    defined: {
+                        name: "PriceDenom"
+                    }
+                }
+            }
+        ]
+    },
     {
         name: "price_meteora_positions",
         discriminator: [
@@ -13738,6 +13882,7 @@ const MERKLE_DISTRIBUTOR_PROGRAM = new web3_js.PublicKey("DiS3nNjFVMieMgmiQFm6wg
 const TRANSFER_HOOK_PROGRAM = new web3_js.PublicKey("po1iCYakK3gHCLbuju4wGzFowTMpAJxkqK1iwUqMonY");
 const METEORA_DLMM_PROGRAM = new web3_js.PublicKey("LBUZKhRxPF3XUpBCjp4YzTKgLccjZhTSDM9YuVaPwxo");
 const KAMINO_LENDING_PROGRAM = new web3_js.PublicKey("KLend2g3cP87fffoy8q1mQqGKjrxjC8boSyAYavgmjD");
+const KAMINO_VAULTS_PROGRAM = new web3_js.PublicKey("KvauGMspG5k6rtzrqqn7WNn3oZdyKqLKwK2XWQ8FLjd");
 const KAMINO_FARM_PROGRAM = new web3_js.PublicKey("FarmsPZpWu9i7Kky8tPN37rs2TpmMrAZrC7S7vJa91Hr");
 const MEMO_PROGRAM = new web3_js.PublicKey("MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr");
 /**
@@ -14681,7 +14826,7 @@ class BaseClient {
     set statePda(statePda) {
         this._statePda = statePda;
     }
-    isMainnet() {
+    get isMainnet() {
         return this.cluster === ClusterNetwork.Mainnet;
     }
     isPhantom() {
@@ -14696,7 +14841,7 @@ class BaseClient {
    * @returns Metadata of the asset
    */ getAssetMeta(assetMint) {
         let assetMeta = ASSETS_MAINNET.get(assetMint);
-        if (!assetMeta && !this.isMainnet()) {
+        if (!assetMeta && !this.isMainnet) {
             assetMeta = ASSETS_TESTS.get(assetMint);
         }
         if (!assetMeta) {
@@ -15086,9 +15231,9 @@ class BaseClient {
         if (stateAccount.mints.length > 0) {
             const mintPubkey = glamStatePda.equals(this.statePda) ? this.mintPda : getMintPda(glamStatePda, 0, this.program.programId);
             const { mint } = await this.fetchMintAndTokenProgram(mintPubkey);
-            return StateModel.fromOnchainAccounts(statePda, stateAccount, openfundsMetadataAccount, mint, this.program.programId);
+            return StateModel.fromOnchainAccounts(glamStatePda, stateAccount, openfundsMetadataAccount, mint, this.program.programId);
         }
-        return StateModel.fromOnchainAccounts(statePda, stateAccount, openfundsMetadataAccount, undefined, this.program.programId);
+        return StateModel.fromOnchainAccounts(glamStatePda, stateAccount, openfundsMetadataAccount, undefined, this.program.programId);
     }
     /**
    * Fetch all glam state models if no filter options provided
@@ -15308,6 +15453,12 @@ DepositDirection.WITHDRAW = {
     withdraw: {}
 };
 class OracleSource {
+    static fromString(name) {
+        const k = name.slice(0, 1).toLowerCase() + name.slice(1);
+        return {
+            [k]: {}
+        };
+    }
     static get(n) {
         const name = Object.entries(OracleSourceNum).find(([, v])=>v === n)?.[0];
         const source = Object.entries(OracleSource).find(([key, _])=>key.toLocaleLowerCase() === name?.toLocaleLowerCase())?.[1];
@@ -15763,6 +15914,24 @@ const DriftVaultLayout = borsh.struct([
     // Final padding
     borsh.array(borsh.u64(), 3, "padding")
 ]);
+borsh.struct([
+    borsh.array(borsh.u8(), 8, "discriminator"),
+    borsh.publicKey("marketPda"),
+    borsh.publicKey("oracle"),
+    borsh.publicKey("mint"),
+    borsh.publicKey("vault"),
+    borsh.array(borsh.u8(), 32, "name"),
+    // Padding for bytes between name and cumulativeDepositInterest
+    borsh.array(borsh.u8(), 464 - 168, "padding1"),
+    borsh.u128("cumulativeDepositInterest"),
+    borsh.u128("cumulativeBorrowInterest"),
+    // Padding for bytes between cumulativeBorrowInterest and decimals
+    borsh.array(borsh.u8(), 680 - 496, "padding2"),
+    borsh.u32("decimals"),
+    borsh.u16("marketIndex"),
+    borsh.u8("padding3"),
+    borsh.u8("oracleSource")
+]);
 
 function readUnsignedBigInt64LE(buffer, offset) {
     return new anchor.BN(buffer.subarray(offset, offset + 8), 10, "le");
@@ -16223,17 +16392,17 @@ class DriftClient {
             Buffer.from("drift_state")
         ], DRIFT_PROGRAM_ID)[0];
     }
-    async fetchAndParseSpotMarket(marketIndex) {
+    async fetchAndParseSpotMarket(marketIndex, skipCache = false) {
         const markets = await this.fetchAndParseSpotMarkets([
             marketIndex
-        ]);
+        ], skipCache);
         if (!markets || markets.length === 0) {
             throw new Error(`Spot market not found at index ${marketIndex}`);
         }
         return markets[0];
     }
-    async fetchAndParseSpotMarkets(marketIndexes) {
-        const indexesToFetch = marketIndexes.filter((marketIndex)=>!this.spotMarkets.has(marketIndex));
+    async fetchAndParseSpotMarkets(marketIndexes, skipCache = false) {
+        const indexesToFetch = marketIndexes.filter((marketIndex)=>skipCache || !this.spotMarkets.has(marketIndex));
         if (indexesToFetch.length > 0) {
             if (process.env.NODE_ENV === "development") {
                 console.log("Fetching spot markets:", indexesToFetch);
@@ -16256,17 +16425,17 @@ class DriftClient {
         }
         return spotMarkets;
     }
-    async fetchAndParsePerpMarket(marketIndex) {
+    async fetchAndParsePerpMarket(marketIndex, skipCache = false) {
         const markets = await this.fetchAndParsePerpMarkets([
             marketIndex
-        ]);
+        ], skipCache);
         if (!markets || markets.length === 0) {
             throw new Error(`Perp market not found at index ${marketIndex}`);
         }
         return markets[0];
     }
-    async fetchAndParsePerpMarkets(marketIndexes) {
-        const indexesToFetch = marketIndexes.filter((marketIndex)=>!this.perpMarkets.has(marketIndex));
+    async fetchAndParsePerpMarkets(marketIndexes, skipCache = false) {
+        const indexesToFetch = marketIndexes.filter((marketIndex)=>skipCache || !this.perpMarkets.has(marketIndex));
         if (indexesToFetch.length > 0) {
             if (process.env.NODE_ENV === "development") {
                 console.log("Fetching perp markets:", indexesToFetch);
@@ -16291,33 +16460,56 @@ class DriftClient {
         }
         return perpMarkets;
     }
-    async fetchMarketConfigs() {
-        // const response = await fetch(
-        //   "https://api.glam.systems/v0/drift/market_configs/",
-        // );
-        // if (!response.ok) {
-        //   throw new Error(`Failed to fetch market configs: ${response.status}`);
-        // }
-        // const data = await response.json();
-        // const { orderConstants, perp, spot } = data;
-        // // Transform perp market from API to `PerpMarket` type
-        // const perpMarkets = perp.map((m: any) => ({
-        //   marketIndex: m.marketIndex,
-        //   marketPda: m.marketPDA,
-        //   oracle: new PublicKey(m.oracle),
-        // }));
-        // // Transform spot market from API to `SpotMarket` type
-        // const spotMarkets = spot.map((m: any) => ({
-        //   marketIndex: m.marketIndex,
-        //   marketPda: m.marketPDA,
-        //   oracle: new PublicKey(m.oracle),
-        //   mint: new PublicKey(m.mint),
-        //   vault: new PublicKey(m.vaultPDA),
-        //   decimals: m.decimals,
-        // }));
+    async fetchMarketConfigs(skipCache = false) {
+        // Attempt to fetch market configs from glam API first
+        const glamApi = process.env.NEXT_PUBLIC_GLAM_API || process.env.GLAM_API;
+        if (glamApi) {
+            const response = await fetch(`${glamApi}/v0/drift/market_configs/`);
+            if (!response.ok) {
+                throw new Error(`Failed to fetch market configs from ${glamApi}: ${response.status}`);
+            }
+            const data = await response.json();
+            const { orderConstants, perp, spot } = data;
+            // Transform perp market from API to `PerpMarket` type
+            const perpMarkets = perp.map((m)=>({
+                    name: m.symbol,
+                    marketIndex: m.marketIndex,
+                    marketPda: new web3_js.PublicKey(m.marketPDA),
+                    oracle: new web3_js.PublicKey(m.oracle),
+                    oracleSource: OracleSource.fromString(m.oracleSource)
+                }));
+            perpMarkets.forEach((m)=>{
+                this.perpMarkets.set(m.marketIndex, m);
+            });
+            // Transform spot market from API to `SpotMarket` type
+            const spotMarkets = spot.map((m)=>({
+                    name: m.symbol,
+                    marketIndex: m.marketIndex,
+                    marketPda: new web3_js.PublicKey(m.marketPDA),
+                    vault: new web3_js.PublicKey(m.vaultPDA),
+                    oracle: new web3_js.PublicKey(m.oracle),
+                    oracleSource: OracleSource.fromString(m.oracleSource),
+                    mint: new web3_js.PublicKey(m.mint),
+                    decimals: m.decimals,
+                    tokenProgram: new web3_js.PublicKey(m.tokenProgram),
+                    cumulativeDepositInterest: new anchor.BN(m.cumulativeDepositInterest),
+                    cumulativeBorrowInterest: new anchor.BN(m.cumulativeBorrowInterest)
+                }));
+            spotMarkets.forEach((m)=>{
+                this.spotMarkets.set(m.marketIndex, m);
+            });
+            const marketConfigs = {
+                orderConstants,
+                perpMarkets,
+                spotMarkets
+            };
+            this.marketConfigs = marketConfigs;
+            return marketConfigs;
+        }
+        // If glam API is not available, fetch market configs from RPC
         if (!this.marketConfigs) {
-            const perpMarkets = await this.fetchAndParsePerpMarkets(Array.from(Array(100).keys()));
-            const spotMarkets = await this.fetchAndParseSpotMarkets(Array.from(Array(100).keys()));
+            const perpMarkets = await this.fetchAndParsePerpMarkets(Array.from(Array(100).keys()), skipCache);
+            const spotMarkets = await this.fetchAndParseSpotMarkets(Array.from(Array(100).keys()), skipCache);
             this.marketConfigs = {
                 orderConstants: {
                     perpBaseScale: 9,
@@ -16329,24 +16521,10 @@ class DriftClient {
         }
         return this.marketConfigs;
     }
-    // public async fetchGlamDriftUser(
-    //   glamState: PublicKey | string,
-    //   subAccountId: number = 0,
-    // ): Promise<GlamDriftUser> {
-    //   const vault = this.base.getVaultPda(new PublicKey(glamState));
-    //   const response = await fetch(
-    //     `https://api.glam.systems/v0/drift/user?authority=${vault.toBase58()}&accountId=${subAccountId}`,
-    //   );
-    //   const data = await response.json();
-    //   if (!data) {
-    //     throw new Error("Failed to fetch drift user.");
-    //   }
-    //   return data as GlamDriftUser;
-    // }
     charsToName(chars) {
         return String.fromCharCode(...chars).replace(/\0/g, "").trim();
     }
-    async fetchDriftUser(subAccountId = 0) {
+    async fetchDriftUser(subAccountId = 0, skipCache = false) {
         const { user } = this.getDriftUserPdas(subAccountId);
         const accountInfo = await this.base.provider.connection.getAccountInfo(user);
         if (!accountInfo) {
@@ -16354,7 +16532,7 @@ class DriftClient {
         }
         const { delegate, name, spotPositions, marginMode, perpPositions, isMarginTradingEnabled, maxMarginRatio, orders } = decodeUser(accountInfo.data);
         // Prefetch market configs
-        const marketConfigs = await this.fetchMarketConfigs();
+        const marketConfigs = await this.fetchMarketConfigs(skipCache);
         const spotPositionsExt = await Promise.all(spotPositions.map(async (p)=>{
             const { amount, uiAmount } = await this.calcSpotBalance(p.marketIndex, p.scaledBalance, p.balanceType);
             const spotMarket = marketConfigs.spotMarkets.find((m)=>m.marketIndex === p.marketIndex);
@@ -16379,22 +16557,10 @@ class DriftClient {
             maxMarginRatio
         };
     }
-    // async getPositions(statePda: PublicKey | string, subAccountId: number = 0) {
-    //   const driftUser = await this.fetchDriftUser(
-    //     new PublicKey(statePda),
-    //     subAccountId,
-    //   );
-    //   if (!driftUser) {
-    //     return { spotPositions: [], perpPositions: [] };
-    //   }
-    //   const marketConfigs = await this.fetchMarketConfigs();
-    //   const { spotPositions, perpPositions } = driftUser;
-    //   return { spotPositions, perpPositions };
-    // }
     /**
    * @deprecated
-   */ async fetchPolicyConfig(glamState) {
-        const driftUserAccount = glamState && glamState.id && await this.fetchDriftUser();
+   */ async fetchPolicyConfig(stateModel) {
+        const driftUserAccount = await this.fetchDriftUser();
         let delegate = driftUserAccount?.delegate;
         if (delegate && delegate.equals(web3_js.PublicKey.default)) {
             delegate = undefined;
@@ -16402,11 +16568,11 @@ class DriftClient {
         return {
             driftAccessControl: delegate ? 0 : 1,
             driftDelegatedAccount: delegate || null,
-            driftMarketIndexesPerp: glamState?.driftMarketIndexesPerp || [],
-            driftOrderTypes: glamState?.driftOrderTypes || [],
+            driftMarketIndexesPerp: stateModel?.driftMarketIndexesPerp || [],
+            driftOrderTypes: stateModel?.driftOrderTypes || [],
             driftMaxLeverage: driftUserAccount?.maxMarginRatio ? DRIFT_MARGIN_PRECISION / driftUserAccount?.maxMarginRatio : null,
             driftEnableSpot: driftUserAccount?.isMarginTradingEnabled || false,
-            driftMarketIndexesSpot: glamState?.driftMarketIndexesSpot || []
+            driftMarketIndexesSpot: stateModel?.driftMarketIndexesSpot || []
         };
     }
     async composeRemainingAccounts(subAccountId, marketType, marketIndex) {
@@ -16501,7 +16667,8 @@ class DriftClient {
         const glamSigner = txOptions.signer || this.base.getSigner();
         const { user } = this.getDriftUserPdas(subAccountId);
         // https://github.com/drift-labs/protocol-v2/blob/babed162b08b1fe34e49a81c5aa3e4ec0a88ecdf/programs/drift/src/math/constants.rs#L183-L184
-        const marginRatio = DRIFT_MARGIN_PRECISION / maxLeverage;
+        // 0 means No Limit
+        const marginRatio = maxLeverage === 0 ? 0 : DRIFT_MARGIN_PRECISION / maxLeverage;
         return await this.base.program.methods.driftUpdateUserCustomMarginRatio(subAccountId, marginRatio).accounts({
             glamState: this.base.statePda,
             glamSigner,
@@ -17525,7 +17692,8 @@ class MarinadeClient {
         // Fetch stake accounts by withdraw authority
         // Filter by state "active" does not work in localnet tests
         const stakeAccounts = await getStakeAccountsWithStates(this.base.provider.connection, stakeWithdrawAuthority);
-        const { stakeIndex, validatorIndex } = await this.getIndexes(stakeAccounts[0], stakeList, validatorList);
+        const idx = this.base.cluster === ClusterNetwork.Mainnet ? stakeAccounts.findIndex((s)=>s.state === "active") : 0;
+        const { stakeIndex, validatorIndex } = await this.getIndexes(stakeAccounts[idx], stakeList, validatorList);
         const burnMsolFrom = this.base.getVaultAta(MSOL);
         const newStake = web3_js.Keypair.generate();
         const postInstructions = deactivate ? [
@@ -17541,7 +17709,7 @@ class MarinadeClient {
             state: marinadeState.marinadeStateAddress,
             validatorList: validatorList.account,
             stakeList: stakeList.account,
-            stakeAccount: stakeAccounts[0].address,
+            stakeAccount: stakeAccounts[idx].address,
             stakeWithdrawAuthority,
             stakeDepositAuthority,
             treasuryMsolAccount: marinadeState.treasuryMsolAccount,
@@ -17712,7 +17880,7 @@ class VaultClient {
         const tx = new web3_js.Transaction().add(splToken.createAssociatedTokenAccountIdempotentInstruction(signer, vaultAta, this.base.vaultPda, asset, tokenProgram), splToken.createTransferCheckedInstruction(signerAta, asset, vaultAta, signer, new anchor.BN(amount).toNumber(), mint.decimals, [], tokenProgram));
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async withdrawIxs(asset, amount, txOptions) {
+    async withdrawIxs(asset, amount, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
         const { tokenProgram } = await this.base.fetchMintAndTokenProgram(asset);
         const signerAta = this.base.getAta(asset, glamSigner, tokenProgram);
@@ -18641,11 +18809,69 @@ class MintClient {
     }
 }
 
+const MAX_RESERVES = 25;
+const VaultAllocationLayout = borsh.struct([
+    borsh.publicKey("reserve"),
+    borsh.publicKey("ctokenVault"),
+    borsh.u64("targetAllocationWeight"),
+    borsh.u64("tokenAllocationCap"),
+    borsh.u64("ctokenVaultBump"),
+    borsh.array(borsh.u64(), 127, "configPadding"),
+    borsh.u64("ctokenAllocation"),
+    borsh.u64("lastInvestSlot"),
+    borsh.u128("tokenTargetAllocationSf"),
+    borsh.array(borsh.u64(), 128, "statePadding")
+]);
+const KVaultStateLayout = borsh.struct([
+    borsh.array(borsh.u8(), 8, "discriminator"),
+    // Admin
+    borsh.publicKey("vaultAdminAuthority"),
+    borsh.publicKey("baseVaultAuthority"),
+    borsh.u64("baseVaultAuthorityBump"),
+    borsh.publicKey("tokenMint"),
+    borsh.u64("tokenMintDecimals"),
+    borsh.publicKey("tokenVault"),
+    borsh.publicKey("tokenProgram"),
+    // shares
+    borsh.publicKey("sharesMint"),
+    borsh.u64("sharesMintDecimals"),
+    // accounting
+    borsh.u64("tokenAvailable"),
+    borsh.u64("sharesIssued"),
+    borsh.u64("availableCrankFunds"),
+    borsh.u64("padding0"),
+    borsh.u64("performanceFeeBps"),
+    borsh.u64("managementFeeBps"),
+    borsh.u64("lastFeeChargeTimestamp"),
+    borsh.u128("prevAumSf"),
+    borsh.u128("pendingFeesSf"),
+    borsh.array(VaultAllocationLayout, MAX_RESERVES, "vaultAllocationStrategy"),
+    borsh.array(borsh.u128(), 256, "padding1"),
+    // General config
+    borsh.u64("minDepositAmount"),
+    borsh.u64("minWithdrawAmount"),
+    borsh.u64("minInvestAmount"),
+    borsh.u64("minInvestDelaySlots"),
+    borsh.u64("crankFundFeePerReserve"),
+    borsh.publicKey("pendingAdmin"),
+    borsh.u128("cumulativeEarnedInterestSf"),
+    borsh.u128("cumulativeMgmtFeesSf"),
+    borsh.u128("cumulativePerfFeesSf"),
+    borsh.array(borsh.u8(), 40, "name"),
+    borsh.publicKey("vaultLookupTable"),
+    borsh.publicKey("vaultFarm"),
+    borsh.u64("creationTimestamp"),
+    borsh.u64("padding2"),
+    borsh.publicKey("allocationAdmin"),
+    borsh.array(borsh.u128(), 242, "padding3")
+]);
+
 const LOOKUP_TABLE = new web3_js.PublicKey("284iwGtA9X9aLy3KsyV8uT2pXLARhYbiSi5SiM2g47M2");
 const DEFAULT_OBLIGATION_ARGS = {
     tag: 0,
     id: 0
 };
+const EVENT_AUTHORITY$1 = new web3_js.PublicKey("24tHwQyJJ9akVXxnvkekGfAoeUJXXS7mE6kQNioNySsK");
 function refreshObligation(accounts, programId = KAMINO_LENDING_PROGRAM) {
     const keys = [
         {
@@ -19044,7 +19270,7 @@ class KaminoLendingClient {
     /**
    * Fetches and parses an obligation account
    */ async fetchAndParseObligation(obligation) {
-        const cached = this.obligations.get(obligation);
+        const cached = this.obligations.get(obligation.toBase58());
         if (cached) {
             return cached;
         }
@@ -19058,7 +19284,7 @@ class KaminoLendingClient {
             };
         }
         const parsedObligation = this.parseObligation(obligation, obligationAccount.data);
-        this.obligations.set(obligation, parsedObligation);
+        this.obligations.set(obligation.toBase58(), parsedObligation);
         return parsedObligation;
     }
     parseReserveAccount(reserve, data) {
@@ -19068,6 +19294,7 @@ class KaminoLendingClient {
         const liquidityMint = new web3_js.PublicKey(data.subarray(128, 160));
         return {
             address: reserve,
+            market,
             farmCollateral: farmCollateral.equals(web3_js.PublicKey.default) ? null : farmCollateral,
             farmDebt: farmDebt.equals(web3_js.PublicKey.default) ? null : farmDebt,
             liquidityMint,
@@ -19075,16 +19302,28 @@ class KaminoLendingClient {
         };
     }
     async fetchAndParseReserves(reserves) {
-        if (this.pubkeyArraysEqual(reserves, Array.from(this.reserves.keys()))) {
-            return Array.from(this.reserves.values());
-        }
-        const reserveAccounts = await this.base.provider.connection.getMultipleAccountsInfo(reserves);
-        if (reserveAccounts.find((a)=>!a)) {
+        const requestReservesSet = new Set(reserves.map((r)=>r.toBase58()));
+        const cachedReservesSet = new Set(this.reserves.keys());
+        // If all requested reserves are cached, return data from cache
+        if ([
+            ...requestReservesSet
+        ].every((r)=>cachedReservesSet.has(r))) {
+            return Array.from(this.reserves.values()).filter((r)=>requestReservesSet.has(r.address.toBase58()));
+        }
+        // Only fetch reserves that are not cached
+        const reservesToFetch = [
+            ...requestReservesSet
+        ].filter((r)=>!cachedReservesSet.has(r)).map((r)=>new web3_js.PublicKey(r));
+        if (process.env.NODE_ENV !== "production") {
+            console.log("Fetching reserves:", reservesToFetch.map((r)=>r.toBase58()));
+        }
+        const reserveAccounts = await this.base.provider.connection.getMultipleAccountsInfo(reservesToFetch);
+        if (reserveAccounts.some((a)=>!a)) {
             throw new Error("Not all reserves can be found");
         }
-        return reserveAccounts.filter((a)=>!!a).map((account, i)=>{
+        return reserveAccounts.map((account, i)=>{
             const parsedReserve = this.parseReserveAccount(reserves[i], account.data);
-            this.reserves.set(reserves[i], parsedReserve);
+            this.reserves.set(reserves[i].toBase58(), parsedReserve);
             return parsedReserve;
         });
     }
@@ -19112,7 +19351,7 @@ class KaminoLendingClient {
             throw new Error("Reserve not found");
         }
         const parsedReserve = this.parseReserveAccount(accounts[0].pubkey, accounts[0].account.data);
-        this.reserves.set(accounts[0].pubkey, parsedReserve);
+        this.reserves.set(accounts[0].pubkey.toBase58(), parsedReserve);
         return parsedReserve;
     }
     /**
@@ -19142,7 +19381,7 @@ class KaminoLendingClient {
         // Parse obligations and cache them
         return accounts.map((a)=>{
             const parsedObligation = this.parseObligation(a.pubkey, a.account.data);
-            this.obligations.set(a.pubkey, parsedObligation);
+            this.obligations.set(a.pubkey.toBase58(), parsedObligation);
             return parsedObligation;
         });
     }
@@ -19673,6 +19912,160 @@ class KaminoFarmClient {
             ], KAMINO_FARM_PROGRAM)[0];
     }
 }
+class KaminoVaultsClient {
+    async deposit(vault, amount, txOptions = {}) {
+        const tx = await this.depositTx(vault, amount, txOptions);
+        return await this.base.sendAndConfirm(tx);
+    }
+    async withdraw(vault, amount, txOptions = {}) {
+        const tx = await this.withdrawTx(vault, amount, txOptions);
+        return await this.base.sendAndConfirm(tx);
+    }
+    async findAndParseKaminoVaults() {
+        const accounts = await this.base.provider.connection.getProgramAccounts(KAMINO_VAULTS_PROGRAM, {
+            filters: [
+                {
+                    dataSize: 62552
+                },
+                {
+                    memcmp: {
+                        offset: 0,
+                        bytes: "5MRSpWLS65g=",
+                        encoding: "base64"
+                    }
+                }
+            ]
+        });
+        if (accounts.length === 0) {
+            throw new Error("Kamino vaults not found");
+        }
+        return accounts.map((a)=>{
+            const vaultState = KVaultStateLayout.decode(a.account.data);
+            this.vaultStates.set(a.pubkey.toBase58(), vaultState);
+            this.shareMintToVaultPdaMap.set(vaultState.sharesMint.toBase58(), a.pubkey);
+            return vaultState;
+        });
+    }
+    async getVaultPdasByShareMints(mints) {
+        if (this.vaultStates.size === 0) {
+            await this.findAndParseKaminoVaults();
+        }
+        return mints.map((mint)=>this.shareMintToVaultPdaMap.get(mint.toBase58()));
+    }
+    async fetchAndParseVaultState(vault) {
+        const vaultAccount = await this.base.provider.connection.getAccountInfo(vault);
+        if (!vaultAccount) {
+            throw new Error(`Kamino vault account not found:, ${vault}`);
+        }
+        const vaultState = KVaultStateLayout.decode(vaultAccount.data);
+        this.vaultStates.set(vault.toBase58(), vaultState);
+        this.shareMintToVaultPdaMap.set(vaultState.sharesMint.toBase58(), vault);
+        return vaultState;
+    }
+    async composeRemainingAccounts(allocationStrategies) {
+        // For each allocation get reserve and market pubkeys
+        const reserves = allocationStrategies.map((strategy)=>strategy.reserve);
+        const parsedReserves = await this.kaminoLending.fetchAndParseReserves(reserves);
+        const reserveMetas = reserves.map((pubkey)=>({
+                pubkey,
+                isSigner: false,
+                isWritable: true
+            }));
+        const marketMetas = parsedReserves.map(({ market })=>({
+                pubkey: market,
+                isSigner: false,
+                isWritable: false
+            }));
+        return [
+            ...reserveMetas,
+            ...marketMetas
+        ];
+    }
+    async depositTx(vault, amount, txOptions = {}) {
+        const glamSigner = txOptions.signer || this.base.getSigner();
+        const vaultState = await this.fetchAndParseVaultState(vault);
+        const amountBN = new anchor.BN(amount * 10 ** vaultState.tokenMintDecimals.toNumber());
+        const { tokenProgram: sharesTokenProgram } = await this.base.fetchMintAndTokenProgram(vaultState.sharesMint);
+        const userTokenAta = this.base.getVaultAta(vaultState.tokenMint, vaultState.tokenProgram);
+        const userSharesAta = this.base.getVaultAta(vaultState.sharesMint, sharesTokenProgram);
+        // Create user shares ata
+        const preInstructions = [
+            splToken.createAssociatedTokenAccountIdempotentInstruction(glamSigner, userSharesAta, this.base.vaultPda, vaultState.sharesMint, sharesTokenProgram)
+        ];
+        // Remaining accounts, skip empty allocation strategies
+        const remainingAccounts = await this.composeRemainingAccounts(vaultState.vaultAllocationStrategy.filter(({ reserve })=>!reserve.equals(web3_js.PublicKey.default)));
+        const tx = await this.base.program.methods.kaminoVaultsDeposit(amountBN).accounts({
+            glamState: this.base.statePda,
+            glamSigner,
+            vaultState: vault,
+            tokenVault: vaultState.tokenVault,
+            tokenMint: vaultState.tokenMint,
+            baseVaultAuthority: vaultState.baseVaultAuthority,
+            sharesMint: vaultState.sharesMint,
+            userTokenAta,
+            userSharesAta,
+            klendProgram: KAMINO_LENDING_PROGRAM,
+            tokenProgram: vaultState.tokenProgram,
+            sharesTokenProgram,
+            eventAuthority: EVENT_AUTHORITY$1,
+            program: KAMINO_VAULTS_PROGRAM
+        }).remainingAccounts(remainingAccounts).preInstructions(preInstructions).transaction();
+        const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
+        return vTx;
+    }
+    async withdrawTx(vault, amount, txOptions = {}) {
+        const glamSigner = txOptions.signer || this.base.getSigner();
+        const vaultState = await this.fetchAndParseVaultState(vault);
+        const userTokenAta = this.base.getVaultAta(vaultState.tokenMint, vaultState.tokenProgram);
+        const { tokenProgram: sharesTokenProgram } = await this.base.fetchMintAndTokenProgram(vaultState.sharesMint);
+        const userSharesAta = this.base.getVaultAta(vaultState.sharesMint, sharesTokenProgram);
+        const amountBN = new anchor.BN(amount * 10 ** vaultState.sharesMintDecimals.toNumber());
+        const reserves = vaultState.vaultAllocationStrategy.filter(({ reserve })=>!reserve.equals(web3_js.PublicKey.default));
+        // Withdraw from the first reserve when kvault does not have enough liquidity
+        const idx = 0;
+        const withdrawReserve = (await this.kaminoLending.fetchAndParseReserves(reserves.map((r)=>r.reserve)))[idx];
+        const vaultCollateralTokenVault = vaultState.vaultAllocationStrategy[idx].ctokenVault;
+        const remainingAccounts = await this.composeRemainingAccounts(reserves);
+        const preInstructions = [
+            splToken.createAssociatedTokenAccountIdempotentInstruction(glamSigner, userTokenAta, this.base.vaultPda, vaultState.tokenMint, vaultState.tokenProgram)
+        ];
+        const tx = await this.base.program.methods.kaminoVaultsWithdraw(amountBN).accounts({
+            glamState: this.base.statePda,
+            glamSigner,
+            withdrawFromAvailableVaultState: vault,
+            withdrawFromAvailableTokenVault: vaultState.tokenVault,
+            withdrawFromAvailableBaseVaultAuthority: vaultState.baseVaultAuthority,
+            withdrawFromAvailableUserTokenAta: userTokenAta,
+            withdrawFromAvailableTokenMint: vaultState.tokenMint,
+            withdrawFromAvailableUserSharesAta: userSharesAta,
+            withdrawFromAvailableSharesMint: vaultState.sharesMint,
+            withdrawFromAvailableTokenProgram: vaultState.tokenProgram,
+            withdrawFromAvailableSharesTokenProgram: sharesTokenProgram,
+            withdrawFromAvailableKlendProgram: KAMINO_LENDING_PROGRAM,
+            withdrawFromAvailableEventAuthority: EVENT_AUTHORITY$1,
+            withdrawFromAvailableProgram: KAMINO_VAULTS_PROGRAM,
+            withdrawFromReserveVaultState: vault,
+            withdrawFromReserveReserve: withdrawReserve.address,
+            withdrawFromReserveCtokenVault: vaultCollateralTokenVault,
+            withdrawFromReserveLendingMarket: withdrawReserve.market,
+            withdrawFromReserveLendingMarketAuthority: this.kaminoLending.getMarketAuthority(withdrawReserve.market),
+            withdrawFromReserveReserveLiquiditySupply: withdrawReserve.liquiditySupplyVault,
+            withdrawFromReserveReserveCollateralMint: withdrawReserve.collateralMint,
+            withdrawFromReserveReserveCollateralTokenProgram: splToken.TOKEN_PROGRAM_ID,
+            withdrawFromReserveInstructionSysvarAccount: web3_js.SYSVAR_INSTRUCTIONS_PUBKEY,
+            eventAuthority: EVENT_AUTHORITY$1,
+            program: KAMINO_VAULTS_PROGRAM
+        }).remainingAccounts(remainingAccounts).preInstructions(preInstructions).transaction();
+        const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
+        return vTx;
+    }
+    constructor(base, kaminoLending){
+        this.base = base;
+        this.kaminoLending = kaminoLending;
+        this.vaultStates = new Map();
+        this.shareMintToVaultPdaMap = new Map();
+    }
+}
 
 // Pubkey::find_program_address(&[b"__event_authority"], &dlmm_interface::ID)
 const EVENT_AUTHORITY = new web3_js.PublicKey("D1ZN9Wj1fRSUQfCjhvnu1hqDMT7hzjzBBpi12nVniYD6");
@@ -20171,6 +20564,46 @@ class PriceClient {
         }).remainingAccounts(remainingAccounts).instruction();
         return priceIx;
     }
+    async priceKaminoVaultSharesIx(priceDenom) {
+        const allKvaultStates = await this.kvaults.findAndParseKaminoVaults();
+        const allKvaultMints = allKvaultStates.map((kvault)=>kvault.sharesMint);
+        // All share token accounts GLAM vault could possibly hold
+        const possibleShareAtas = allKvaultMints.map((mint)=>this.base.getVaultAta(mint));
+        const possibleShareAtaAccountsInfo = await this.base.provider.connection.getMultipleAccountsInfo(possibleShareAtas);
+        const shareAtas = [];
+        const shareMints = [];
+        const kvaultStates = [];
+        possibleShareAtaAccountsInfo.forEach((info, i)=>{
+            if (info !== null) {
+                shareAtas.push(possibleShareAtas[i]);
+                shareMints.push(allKvaultMints[i]);
+                kvaultStates.push(allKvaultStates[i]);
+            }
+        });
+        const kvaultPdas = await this.kvaults.getVaultPdasByShareMints(shareMints);
+        const remainingAccounts = (await Promise.all(kvaultStates.map((kvault)=>{
+            return this.kvaults.composeRemainingAccounts(kvault.vaultAllocationStrategy.filter((alloc)=>!alloc.reserve.equals(web3_js.PublicKey.default)));
+        }))).flat();
+        [
+            ...kvaultPdas,
+            ...shareAtas
+        ].map((pubkey)=>{
+            remainingAccounts.unshift({
+                pubkey: pubkey,
+                isSigner: false,
+                isWritable: false
+            });
+        });
+        const priceIx = await this.base.program.methods.priceKaminoVaultShares(priceDenom).accounts({
+            glamState: this.base.statePda,
+            solOracle: SOL_ORACLE,
+            pythOracle: null,
+            switchboardPriceOracle: null,
+            switchboardTwapOracle: null,
+            scopePrices: KAMINO_SCOPE_PRICES
+        }).remainingAccounts(remainingAccounts).instruction();
+        return priceIx;
+    }
     /**
    * Returns an instruction that prices the all Drift users (aka sub-accounts) controlled by the GLAM vault.
    * These Drift users must share the same user_stats that's also controlled by the GLAM vault.
@@ -20204,7 +20637,7 @@ class PriceClient {
    * Returns an instruction that prices a drift vault depositor.
    * If there are no vault depositor accounts, returns null.
    */ async priceDriftVaultDepositorsIx(priceDenom) {
-        const parsedVaultDepositors = await this.driftVaults.findAndParseVaultDepositors();
+        const parsedVaultDepositors = await this.dvaults.findAndParseVaultDepositors();
         if (parsedVaultDepositors.length === 0) {
             return null;
         }
@@ -20219,9 +20652,9 @@ class PriceClient {
         for (const depositor of parsedVaultDepositors){
             remainingAccountsKeys.add(depositor.address.toBase58());
             remainingAccountsKeys.add(depositor.driftVault.toBase58());
-            const { user: driftUser } = await this.driftVaults.parseDriftVault(depositor.driftVault);
+            const { user: driftUser } = await this.dvaults.parseDriftVault(depositor.driftVault);
             remainingAccountsKeys.add(driftUser.toBase58());
-            const markets_and_oracles = (await this.driftVaults.composeRemainingAccounts(driftUser)).map((a)=>a.pubkey.toBase58());
+            const markets_and_oracles = (await this.dvaults.composeRemainingAccounts(driftUser)).map((a)=>a.pubkey.toBase58());
             for (const k of markets_and_oracles){
                 remainingAccountsKeys.add(k);
             }
@@ -20310,11 +20743,12 @@ class PriceClient {
             priceDriftVaultDepositorsIx
         ].filter((ix)=>ix !== null);
     }
-    constructor(base, klend, drift, driftVaults){
+    constructor(base, klend, kvaults, drift, dvaults){
         this.base = base;
         this.klend = klend;
+        this.kvaults = kvaults;
         this.drift = drift;
-        this.driftVaults = driftVaults;
+        this.dvaults = dvaults;
         this.remainingAccountsForPricingMeteora = async ()=>{
             const positions = await fetchMeteoraPositions(this.base.provider.connection, this.base.vaultPda);
             let chunks = await Promise.all(positions.map(async (pubkey)=>{
@@ -20429,7 +20863,7 @@ class PriceClient {
     }
     get price() {
         if (!this._price) {
-            this._price = new PriceClient(this, this.kaminoLending, this.drift, this.driftVaults);
+            this._price = new PriceClient(this, this.kaminoLending, this.kaminoVaults, this.drift, this.driftVaults);
         }
         return this._price;
     }
@@ -20457,6 +20891,12 @@ class PriceClient {
         }
         return this._kaminoFarm;
     }
+    get kaminoVaults() {
+        if (!this._kaminoVaults) {
+            this._kaminoVaults = new KaminoVaultsClient(this, this.kaminoLending);
+        }
+        return this._kaminoVaults;
+    }
     get meteoraDlmm() {
         if (!this._meteoraDlmm) {
             this._meteoraDlmm = new MeteoraDlmmClient(this);
@@ -20582,6 +21022,7 @@ exports.KAMINO_FARM_PROGRAM = KAMINO_FARM_PROGRAM;
 exports.KAMINO_LENDING_PROGRAM = KAMINO_LENDING_PROGRAM;
 exports.KAMINO_OBTRIGATION_SIZE = KAMINO_OBTRIGATION_SIZE;
 exports.KAMINO_SCOPE_PRICES = KAMINO_SCOPE_PRICES;
+exports.KAMINO_VAULTS_PROGRAM = KAMINO_VAULTS_PROGRAM;
 exports.LPAction = LPAction;
 exports.LiquidationType = LiquidationType;
 exports.MARINADE_NATIVE_STAKE_AUTHORITY = MARINADE_NATIVE_STAKE_AUTHORITY;