@glamsystems/glam-sdk 0.1.28 → 0.1.30

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.32",
+    version: "0.4.35",
     spec: "0.1.0",
     description: "Glam Protocol"
 };
@@ -6900,7 +6900,9 @@ var instructions = [
         docs: [
             "Extra accounts for pricing N vault depositors:",
             "- (vault_depositor, drift_vault, drift_user) x N",
-            "- markets and oracles used by all drift users (no specific order)"
+            "- spot_market used by drift users of vaults (no specific order)",
+            "- perp markets used by drift users of vaults (no specific order)",
+            "- oracles of spot markets and perp markets (no specific order)"
         ],
         discriminator: [
             234,
@@ -7021,6 +7023,14 @@ var instructions = [
             {
                 name: "num_vault_depositors",
                 type: "u8"
+            },
+            {
+                name: "num_spot_markets",
+                type: "u8"
+            },
+            {
+                name: "num_perp_markets",
+                type: "u8"
             }
         ]
     },
@@ -7166,6 +7176,16 @@ var instructions = [
     },
     {
         name: "price_kamino_vault_shares",
+        docs: [
+            "Price Kamino vault shares.",
+            "- `num_vaults` Number of kamino vaults to price.",
+            "",
+            "Extra accounts for pricing N kamino vault shares:",
+            "- (kvault_share_ata, kvault_share_mint, kvault_state, kvault_deposit_token_oracle) x N",
+            "- reserve x M",
+            "- M = number of reserves used by all kvaults' allocations",
+            "- reserve pubkeys must follow the same order of reserves used by each allocation"
+        ],
         discriminator: [
             112,
             92,
@@ -7207,10 +7227,6 @@ var instructions = [
                 writable: true,
                 signer: true
             },
-            {
-                name: "kamino_lending_program",
-                address: "KLend2g3cP87fffoy8q1mQqGKjrxjC8boSyAYavgmjD"
-            },
             {
                 name: "sol_oracle"
             },
@@ -7275,22 +7291,6 @@ var instructions = [
                         ]
                     }
                 }
-            },
-            {
-                name: "pyth_oracle",
-                optional: true
-            },
-            {
-                name: "switchboard_price_oracle",
-                optional: true
-            },
-            {
-                name: "switchboard_twap_oracle",
-                optional: true
-            },
-            {
-                name: "scope_prices",
-                optional: true
             }
         ],
         args: [
@@ -7301,6 +7301,10 @@ var instructions = [
                         name: "PriceDenom"
                     }
                 }
+            },
+            {
+                name: "num_vaults",
+                type: "u8"
             }
         ]
     },
@@ -7545,16 +7549,22 @@ var instructions = [
         ]
     },
     {
-        name: "price_vault",
+        name: "price_vault_tokens",
+        docs: [
+            "Price vault SOL balance and tokens it holds.",
+            "",
+            "Extra accounts for pricing N tokens:",
+            "- (ata, mint, oracle) x N"
+        ],
         discriminator: [
-            47,
-            213,
-            36,
-            17,
+            54,
+            42,
+            16,
+            199,
+            20,
             183,
-            5,
-            141,
-            45
+            50,
+            137
         ],
         accounts: [
             {
@@ -9593,6 +9603,10 @@ var instructions = [
             {
                 name: "stake_history",
                 address: "SysvarStakeHistory1111111111111111111111111"
+            },
+            {
+                name: "system_program",
+                address: "11111111111111111111111111111111"
             }
         ],
         args: [
@@ -14561,6 +14575,7 @@ const KAMINO_LENDING_PROGRAM = new web3_js.PublicKey("KLend2g3cP87fffoy8q1mQqGKj
 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");
+const ALT_PROGRAM_ID = new web3_js.PublicKey("AddressLookupTab1e1111111111111111111111111");
 /**
  * Stake pools
  */ const JITO_STAKE_POOL = new web3_js.PublicKey("Jito4APyf642JPZPx3hGc6WWJ8zPKtRbRs4P815Awbb");
@@ -14969,12 +14984,6 @@ var ClusterNetwork = /*#__PURE__*/ function(ClusterNetwork) {
     return ClusterNetwork;
 }({});
 
-const LOOKUP_TABLES_MAP = new Map([
-    [
-        "3tfbxaHBDjczQo3eyNJGGG64ChZ9nG4V3Gywa4k59d5a",
-        new web3_js.PublicKey("8HUXT9abWS2z3z92QyDzg51nMcc18LyWFvaEQZJMPixu")
-    ]
-]);
 const findStakeAccounts = async (connection, withdrawAuthority)=>{
     // stake authority offset: 12
     // withdraw authority offset: 44
@@ -15079,45 +15088,6 @@ const parseMeteoraPosition = async (connection, position)=>{
         binArrayUpper
     };
 };
-async function fetchLookupTables(connection, authority, firstEntry) {
-    const ALT_PROGRAM_ID = new web3_js.PublicKey("AddressLookupTab1e1111111111111111111111111");
-    const tablePubkey = LOOKUP_TABLES_MAP.get(firstEntry.toBase58());
-    if (tablePubkey) {
-        const accountInfo = await connection.getAccountInfo(tablePubkey);
-        if (accountInfo) {
-            return [
-                new web3_js.AddressLookupTableAccount({
-                    key: tablePubkey,
-                    state: web3_js.AddressLookupTableAccount.deserialize(accountInfo.data)
-                })
-            ];
-        }
-    } else {
-        // Fetch all accounts owned by the ALT program
-        // This is currently disabled due to RPC error "Request deprioritized due to number of accounts requested. Slow down requests or add filters to narrow down results"
-        const accounts = await connection.getProgramAccounts(ALT_PROGRAM_ID, {
-            filters: [
-                {
-                    memcmp: {
-                        offset: 22,
-                        bytes: authority.toBase58()
-                    }
-                },
-                {
-                    memcmp: {
-                        offset: 56,
-                        bytes: firstEntry.toBase58()
-                    }
-                }
-            ]
-        });
-        return accounts.map(({ pubkey, account })=>new web3_js.AddressLookupTableAccount({
-                key: pubkey,
-                state: web3_js.AddressLookupTableAccount.deserialize(account.data)
-            }));
-    }
-    return [];
-}
 /**
  * Parses program logs to extract error message
  */ function parseProgramLogs(logs) {
@@ -15227,6 +15197,15 @@ const STAKE_POOLS = sanctumLstList.LstList.filter((lst)=>!lst.name.includes("San
         poolState: new web3_js.PublicKey(poolState)
     };
 });
+STAKE_POOLS.push({
+    name: "Phantom Staked SOL",
+    symbol: "PSOL",
+    mint: "pSo1f9nQXWgXibFtKf7NWYxb5enAM4qfP6UJSiXRQfL",
+    decimals: 9,
+    logoURI: "https://assets.phantom.app/assets/metadata/PSOL-512.png",
+    tokenProgram: splToken.TOKEN_PROGRAM_ID,
+    poolState: new web3_js.PublicKey("pSPcvR8GmG9aKDUbn9nbKYjkxt9hxMS7kF1qqKJaPqJ")
+});
 const STAKE_POOLS_MAP = new Map(STAKE_POOLS.map((p)=>[
         p.mint,
         p
@@ -15527,6 +15506,12 @@ const LOOKUP_TABLES = [
     new web3_js.PublicKey("D9cnvzswDikQDf53k4HpQ3KJ9y1Fv3HGGDFYMXnK5T6c"),
     new web3_js.PublicKey("EiWSskK5HXnBTptiS5DH6gpAJRVNQ3cAhTKBGaiaysAb")
 ];
+const STATES_LOOKUP_TABLES_MAP = new Map([
+    [
+        "3tfbxaHBDjczQo3eyNJGGG64ChZ9nG4V3Gywa4k59d5a",
+        new web3_js.PublicKey("8HUXT9abWS2z3z92QyDzg51nMcc18LyWFvaEQZJMPixu")
+    ]
+]);
 const isBrowser = process.env.ANCHOR_BROWSER || typeof window !== "undefined" && !window.process?.hasOwnProperty("type");
 class BaseClient {
     get detectedCluster() {
@@ -15608,6 +15593,59 @@ class BaseClient {
             })
         ];
     }
+    /**
+   * Fetches lookup tables for the current GLAM instance
+   */ async findLookupTables() {
+        const glamApi = process.env.NEXT_PUBLIC_GLAM_API || process.env.GLAM_API;
+        if (glamApi) {
+            const response = await fetch(`${glamApi}/v0/lut/glam/?state=${this.statePda}`);
+            const data = await response.json();
+            const { t: lookupTables } = data;
+            const pubkeys = Object.keys(lookupTables);
+            if (pubkeys.length > 0) {
+                return await this.fetchAddressLookupTableAccounts(pubkeys);
+            }
+        }
+        const tablePubkey = STATES_LOOKUP_TABLES_MAP.get(this.statePda.toBase58());
+        if (tablePubkey) {
+            return await this.fetchAddressLookupTableAccounts([
+                tablePubkey
+            ]);
+        }
+        // Fetch all accounts owned by the ALT program
+        // This is very likely to hit the RPC error "Request deprioritized due to number of accounts requested. Slow down requests or add filters to narrow down results"
+        const accounts = await this.provider.connection.getProgramAccounts(ALT_PROGRAM_ID, {
+            filters: [
+                {
+                    memcmp: {
+                        offset: 0,
+                        bytes: bytes.bs58.encode([
+                            1,
+                            0,
+                            0,
+                            0
+                        ])
+                    }
+                },
+                {
+                    memcmp: {
+                        offset: 56,
+                        bytes: this.statePda.toBase58()
+                    }
+                },
+                {
+                    memcmp: {
+                        offset: 88,
+                        bytes: this.vaultPda.toBase58()
+                    }
+                }
+            ]
+        });
+        return accounts.map(({ pubkey, account })=>new web3_js.AddressLookupTableAccount({
+                key: pubkey,
+                state: web3_js.AddressLookupTableAccount.deserialize(account.data)
+            }));
+    }
     async intoVersionedTransaction(tx, { lookupTables = [], signer, computeUnitLimit, getPriorityFeeMicroLamports, maxFeeLamports, useMaxFee = false, jitoTipLamports, simulate = false }) {
         signer = signer || this.getSigner();
         const instructions = tx.instructions;
@@ -15619,15 +15657,26 @@ class BaseClient {
                 lamports: jitoTipLamports
             }));
         }
-        lookupTables.push(...await this.getAdressLookupTableAccounts(LOOKUP_TABLES));
+        const lookupTableAccounts = [];
+        if (lookupTables.every((t)=>t instanceof web3_js.AddressLookupTableAccount)) {
+            const accounts = await this.fetchAddressLookupTableAccounts([
+                ...LOOKUP_TABLES
+            ]);
+            lookupTableAccounts.push(...lookupTables, ...accounts);
+        } else {
+            const accounts = await this.fetchAddressLookupTableAccounts([
+                ...lookupTables,
+                ...LOOKUP_TABLES
+            ]);
+            lookupTableAccounts.push(...accounts);
+        }
         const recentBlockhash = (await this.blockhashWithCache.get()).blockhash;
-        const { unitsConsumed, error, serializedTx } = await getSimulationResult(this.provider.connection, instructions, signer, lookupTables);
+        const { unitsConsumed, error, serializedTx } = await getSimulationResult(this.provider.connection, instructions, signer, lookupTableAccounts);
         computeUnitLimit = unitsConsumed;
         // by default, a simulation error doesn't prevent the tx from being sent
         // - gui: wallet apps usually do the simulation themselves, we should ignore the simulation error here by default
         // - cli: we should set simulate=true
         if (error && simulate) {
-            console.log("Lookup tables:", lookupTables.map((lt)=>lt.key.toString()));
             console.log("Tx (base64):", serializedTx);
             console.error("Simulation failed:", error.message);
             console.error("If error message is too obscure, inspect and simulate the tx in explorer: https://explorer.solana.com/tx/inspector");
@@ -15638,7 +15687,7 @@ class BaseClient {
                 payerKey: signer,
                 recentBlockhash,
                 instructions
-            }).compileToV0Message(lookupTables));
+            }).compileToV0Message(lookupTableAccounts));
             const cuIxs = await this.getComputeBudgetIxs(vTx, computeUnitLimit, getPriorityFeeMicroLamports, maxFeeLamports, useMaxFee);
             instructions.unshift(...cuIxs);
         }
@@ -15646,7 +15695,7 @@ class BaseClient {
             payerKey: signer,
             recentBlockhash,
             instructions
-        }).compileToV0Message(lookupTables));
+        }).compileToV0Message(lookupTableAccounts));
     }
     async sendAndConfirm(tx, additionalSigners = []) {
         const connection = this.provider.connection;
@@ -15694,13 +15743,21 @@ class BaseClient {
         }
         return txSig;
     }
-    async getAdressLookupTableAccounts(keys) {
-        if (!keys) {
+    /**
+   * Fetches multiple address lookup table accounts.
+   *
+   * @param pubkeys Array of lookup table public keys.
+   * @returns
+   */ async fetchAddressLookupTableAccounts(pubkeys) {
+        if (!pubkeys) {
             throw new Error("addressLookupTableAddresses is undefined");
         }
-        const addressLookupTableAccountInfos = await this.provider.connection.getMultipleAccountsInfo(keys.map((key)=>new web3_js.PublicKey(key)));
+        if (pubkeys.length === 0) {
+            return [];
+        }
+        const addressLookupTableAccountInfos = await this.provider.connection.getMultipleAccountsInfo(pubkeys.map((key)=>new web3_js.PublicKey(key)));
         return addressLookupTableAccountInfos.reduce((acc, accountInfo, index)=>{
-            const tableAddress = keys[index];
+            const tableAddress = pubkeys[index];
             if (accountInfo) {
                 const tableAccount = new web3_js.AddressLookupTableAccount({
                     key: new web3_js.PublicKey(tableAddress),
@@ -17997,7 +18054,7 @@ class JupiterSwapClient {
             swapInstruction = swapInstructions.swapInstruction;
             addressLookupTableAddresses = swapInstructions.addressLookupTableAddresses;
         }
-        const lookupTables = await this.base.getAdressLookupTableAccounts(addressLookupTableAddresses);
+        const lookupTables = addressLookupTableAddresses.map((pubkey)=>new web3_js.PublicKey(pubkey));
         const swapIx = this.toTransactionInstruction(swapInstruction, glamVault.toBase58());
         const [inputTokenProgram, outputTokenProgram] = (await this.base.fetchMintsAndTokenPrograms([
             inputMint,
@@ -19699,7 +19756,6 @@ const KVaultStateLayout = borsh.struct([
     borsh.array(borsh.u128(), 242, "padding3")
 ]);
 
-const LOOKUP_TABLE = new web3_js.PublicKey("284iwGtA9X9aLy3KsyV8uT2pXLARhYbiSi5SiM2g47M2");
 const DEFAULT_OBLIGATION_ARGS = {
     tag: 0,
     id: 0
@@ -20344,13 +20400,7 @@ class KaminoLendingClient {
             reserveFarmState: depositReserve.farmCollateral,
             farmsProgram: KAMINO_FARM_PROGRAM
         }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
-        const lookupTables = txOptions.lookupTables || await this.base.getAdressLookupTableAccounts([
-            LOOKUP_TABLE
-        ]);
-        const vTx = await this.base.intoVersionedTransaction(tx, {
-            ...txOptions,
-            lookupTables
-        });
+        const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
         return vTx;
     }
     async withdrawTx(market, asset, amount, txOptions) {
@@ -20435,13 +20485,7 @@ class KaminoLendingClient {
         // - refreshObligationFarmsForReserve (if farm exists)
         const tx = new web3_js.Transaction();
         tx.add(...preInstructions, withdrawIx, ...postInstructions);
-        const lookupTables = txOptions.lookupTables || await this.base.getAdressLookupTableAccounts([
-            LOOKUP_TABLE
-        ]);
-        const vTx = await this.base.intoVersionedTransaction(tx, {
-            ...txOptions,
-            lookupTables
-        });
+        const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
         return vTx;
     }
     async borrowTx(market, asset, amount, txOptions) {
@@ -20523,13 +20567,7 @@ class KaminoLendingClient {
         // - borrowObligationLiquidityV2
         const tx = new web3_js.Transaction();
         tx.add(...preInstructions, borrowIx);
-        const lookupTables = txOptions.lookupTables || await this.base.getAdressLookupTableAccounts([
-            LOOKUP_TABLE
-        ]);
-        const vTx = await this.base.intoVersionedTransaction(tx, {
-            ...txOptions,
-            lookupTables
-        });
+        const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
         return vTx;
     }
     async repayTx(market, asset, amount, txOptions = {}) {
@@ -20596,13 +20634,7 @@ class KaminoLendingClient {
         // - repayObligationLiquidityV2
         const tx = new web3_js.Transaction();
         tx.add(...preInstructions, repayIx);
-        const lookupTables = txOptions.lookupTables || await this.base.getAdressLookupTableAccounts([
-            LOOKUP_TABLE
-        ]);
-        const vTx = await this.base.intoVersionedTransaction(tx, {
-            ...txOptions,
-            lookupTables
-        });
+        const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
         return vTx;
     }
     constructor(base){
@@ -20724,13 +20756,7 @@ class KaminoFarmClient {
                 tx.add(createAtaIx, harvestIx);
             }
         }
-        const lookupTables = txOptions.lookupTables || await this.base.getAdressLookupTableAccounts([
-            LOOKUP_TABLE
-        ]);
-        const vTx = await this.base.intoVersionedTransaction(tx, {
-            ...txOptions,
-            lookupTables
-        });
+        const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
         return vTx;
     }
     constructor(base){
@@ -20796,8 +20822,7 @@ class KaminoVaultsClient {
         this.shareMintToVaultPdaMap.set(vaultState.sharesMint.toBase58(), vault);
         return vaultState;
     }
-    async composeRemainingAccounts(allocationStrategies) {
-        // For each allocation get reserve and market pubkeys
+    async composeRemainingAccounts(allocationStrategies, pricingMode = false) {
         const reserves = allocationStrategies.map((strategy)=>strategy.reserve);
         const parsedReserves = await this.kaminoLending.fetchAndParseReserves(reserves);
         const reserveMetas = reserves.map((pubkey)=>({
@@ -20810,15 +20835,21 @@ class KaminoVaultsClient {
                 isSigner: false,
                 isWritable: false
             }));
+        if (pricingMode) {
+            // (market, reserve) must be paired
+            return marketMetas.reduce((acc, marketMeta, i)=>{
+                acc.push(marketMeta, reserveMetas[i]);
+                return acc;
+            }, []);
+        }
         return [
             ...reserveMetas,
             ...marketMetas
-        ];
+        ]; // Non pricing mode
     }
     async depositTx(vault, amount, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
         const vaultState = await this.fetchAndParseVaultState(vault);
-        const amountBN = amount.mul(new anchor.BN(10).pow(vaultState.tokenMintDecimals));
         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);
@@ -20828,7 +20859,7 @@ class KaminoVaultsClient {
         ];
         // 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({
+        const tx = await this.base.program.methods.kaminoVaultsDeposit(amount).accounts({
             glamState: this.base.statePda,
             glamSigner,
             vaultState: vault,
@@ -20853,7 +20884,6 @@ class KaminoVaultsClient {
         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 = amount.mul(new anchor.BN(10).pow(vaultState.sharesMintDecimals));
         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;
@@ -20863,7 +20893,7 @@ class KaminoVaultsClient {
         const preInstructions = [
             splToken.createAssociatedTokenAccountIdempotentInstruction(glamSigner, userTokenAta, this.base.vaultPda, vaultState.tokenMint, vaultState.tokenProgram)
         ];
-        const tx = await this.base.program.methods.kaminoVaultsWithdraw(amountBN).accounts({
+        const tx = await this.base.program.methods.kaminoVaultsWithdraw(amount).accounts({
             glamState: this.base.statePda,
             glamSigner,
             withdrawFromAvailableVaultState: vault,
@@ -21384,36 +21414,63 @@ class PriceClient {
         const shareAtas = [];
         const shareMints = [];
         const kvaultStates = [];
+        const oracles = []; // oracle of kvault deposit token
         possibleShareAtaAccountsInfo.forEach((info, i)=>{
             if (info !== null) {
                 shareAtas.push(possibleShareAtas[i]);
                 shareMints.push(allKvaultMints[i]);
                 kvaultStates.push(allKvaultStates[i]);
+                const { tokenMint } = allKvaultStates[i];
+                const assetMeta = ASSETS_MAINNET.get(tokenMint.toBase58());
+                oracles.push(assetMeta?.oracle);
             }
         });
         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 remainingAccounts = [];
+        // first 3N remaining accounts are N tuples of (kvault_shares_ata, kvault_shares_mint, kvault_state)
+        for(let i = 0; i < shareAtas.length; i++){
+            [
+                shareAtas[i],
+                shareMints[i],
+                kvaultPdas[i],
+                oracles[i]
+            ].map((pubkey)=>{
+                remainingAccounts.push({
+                    pubkey: pubkey,
+                    isSigner: false,
+                    isWritable: false
+                });
             });
-        });
-        const priceIx = await this.base.program.methods.priceKaminoVaultShares(priceDenom).accounts({
+        }
+        const marketsAndReserves = (await Promise.all(kvaultStates.map((kvault)=>{
+            return this.kvaults.composeRemainingAccounts(kvault.vaultAllocationStrategy.filter((alloc)=>!alloc.reserve.equals(web3_js.PublicKey.default)), true);
+        }))).flat();
+        const processed = new Set();
+        const preInstructions = [];
+        const chunkSize = 2;
+        for(let i = 0; i < marketsAndReserves.length; i += chunkSize){
+            const chunk = marketsAndReserves.slice(i, i + chunkSize);
+            const market = chunk[0].pubkey;
+            const reserve = chunk[1].pubkey;
+            // reserve should always be added to remaining accounts
+            remainingAccounts.push(chunk[1]);
+            // each reserve should only be refreshed once
+            if (!processed.has(reserve.toBase58())) {
+                const ix = this.klend.refreshReserveIxs(market, [
+                    reserve
+                ]);
+                preInstructions.push(...ix);
+                processed.add(reserve.toBase58());
+            }
+        }
+        const priceIx = await this.base.program.methods.priceKaminoVaultShares(priceDenom, shareAtas.length).accounts({
             glamState: this.base.statePda,
-            solOracle: SOL_ORACLE,
-            pythOracle: null,
-            switchboardPriceOracle: null,
-            switchboardTwapOracle: null,
-            scopePrices: KAMINO_SCOPE_PRICES
+            solOracle: SOL_ORACLE
         }).remainingAccounts(remainingAccounts).instruction();
-        return priceIx;
+        return [
+            ...preInstructions,
+            priceIx
+        ];
     }
     /**
    * Returns an instruction that prices all Drift users (aka sub-accounts) controlled by the GLAM vault.
@@ -21481,43 +21538,8 @@ class PriceClient {
         if (parsedVaultDepositors.length === 0) {
             return null;
         }
-        // For each vault deposit, we need the following pubkeys in remaining accounts:
-        // - depositor
-        // - drift vault
-        // - drift user of the vault
-        // - oracles
-        // - spot & perp markets
-        // There might be overlaps between markets and oracles so we use a set to avoid duplicates
-        const remainingAccounts = [];
-        const marketsAndOracles = new Set();
-        for (const depositor of parsedVaultDepositors){
-            const { user: driftUser } = await this.dvaults.parseDriftVault(depositor.driftVault);
-            remainingAccounts.push({
-                pubkey: depositor.address,
-                isSigner: false,
-                isWritable: false
-            });
-            remainingAccounts.push({
-                pubkey: depositor.driftVault,
-                isSigner: false,
-                isWritable: false
-            });
-            remainingAccounts.push({
-                pubkey: driftUser,
-                isSigner: false,
-                isWritable: false
-            });
-            const markets_and_oracles = (await this.dvaults.composeRemainingAccounts(driftUser)).map((a)=>a.pubkey.toBase58());
-            for (const k of markets_and_oracles){
-                marketsAndOracles.add(k);
-            }
-        }
-        Array.from(marketsAndOracles).forEach((k)=>remainingAccounts.push({
-                pubkey: new web3_js.PublicKey(k),
-                isSigner: false,
-                isWritable: false
-            }));
-        const priceIx = await this.base.program.methods.priceDriftVaultDepositors(priceDenom, parsedVaultDepositors.length).accounts({
+        const { remainingAccounts, numSpotMarkets, numPerpMarkets } = await this.remainingAccountsForPricingDriftVaultDepositors(parsedVaultDepositors);
+        const priceIx = await this.base.program.methods.priceDriftVaultDepositors(priceDenom, parsedVaultDepositors.length, numSpotMarkets, numPerpMarkets).accounts({
             glamState: this.base.statePda,
             solOracle: SOL_ORACLE
         }).remainingAccounts(remainingAccounts).instruction();
@@ -21527,7 +21549,7 @@ class PriceClient {
    * Returns an instruction that prices vault balance and tokens the vault holds
    */ async priceVaultIx(priceDenom) {
         const remainingAccounts = await this.remainingAccountsForPricingVaultAssets(priceDenom == PriceDenom.ASSET);
-        const priceVaultIx = await this.base.program.methods.priceVault(priceDenom).accounts({
+        const priceVaultIx = await this.base.program.methods.priceVaultTokens(priceDenom).accounts({
             glamState: this.base.statePda,
             solOracle: SOL_ORACLE
         }).remainingAccounts(remainingAccounts).instruction();
@@ -21584,83 +21606,142 @@ class PriceClient {
         }
         const integrations = (stateModel.integrations || []).map((i)=>Object.keys(i)[0]);
         const integrationsToPricingFns = {
-            drift: this.priceDriftUsersIx.bind(this),
-            kaminoLending: this.priceKaminoObligationsIx.bind(this),
-            nativeStaking: this.priceStakesIx.bind(this),
-            meteoraDlmm: this.priceMeteoraPositionsIx.bind(this),
-            driftVaults: this.priceDriftVaultDepositorsIx.bind(this),
-            kaminoVaults: this.priceKaminoVaultSharesIx.bind(this)
+            // drift: this.priceDriftUsersIx.bind(this),
+            // kaminoLending: this.priceKaminoObligationsIx.bind(this),
+            // nativeStaking: this.priceStakesIx.bind(this),
+            // meteoraDlmm: this.priceMeteoraPositionsIx.bind(this),
+            driftVaults: this.priceDriftVaultDepositorsIx.bind(this)
         };
         const pricingFns = integrations.map((integration)=>integrationsToPricingFns[integration]).filter(Boolean);
-        const pricingIxs = [];
+        const pricingIxs = [
+            priceVaultIx
+        ];
         for (const fn of pricingFns){
             const ix = await fn(priceDenom);
-            pricingIxs.push(ix);
+            if (Array.isArray(ix)) {
+                pricingIxs.push(...ix);
+            } else {
+                pricingIxs.push(ix);
+            }
         }
         return pricingIxs.filter(Boolean);
     }
+    async remainingAccountsForPricingDriftVaultDepositors(parsedVaultDepositors) {
+        // Extra accounts for pricing N vault depositors:
+        // - (vault_depositor, drift_vault, drift_user) x N
+        // - spot_market used by drift users of vaults (no specific order)
+        // - perp markets used by drift users of vaults (no specific order)
+        // - oracles of spot markets and perp markets (no specific order)
+        const remainingAccounts = [];
+        const spotMarketsSet = new Set();
+        const perpMarketsSet = new Set();
+        const oraclesSet = new Set();
+        for (const { address: depositor, driftVault } of parsedVaultDepositors){
+            const { user } = await this.dvaults.parseDriftVault(driftVault); // get drift user used by the vault
+            [
+                depositor,
+                driftVault,
+                user
+            ].forEach((k)=>remainingAccounts.push({
+                    pubkey: k,
+                    isSigner: false,
+                    isWritable: false
+                }));
+            const { spotPositions, perpPositions } = await this.dvaults.fetchUserPositions(user);
+            const spotMarketIndexes = spotPositions.map((p)=>p.marketIndex);
+            const perpMarketIndexes = perpPositions.map((p)=>p.marketIndex);
+            // If there are perp positions, add spot market 0 as it's used as quote market for perp
+            if (perpMarketIndexes.length > 0 && !spotMarketIndexes.includes(0)) {
+                spotMarketIndexes.push(0);
+            }
+            const spotMarkets = await this.drift.fetchAndParseSpotMarkets(spotMarketIndexes);
+            const perpMarkets = await this.drift.fetchAndParsePerpMarkets(perpMarketIndexes);
+            spotMarkets.forEach((m)=>{
+                oraclesSet.add(m.oracle.toBase58());
+                spotMarketsSet.add(m.marketPda.toBase58());
+            });
+            perpMarkets.forEach((m)=>{
+                oraclesSet.add(m.oracle.toBase58());
+                perpMarketsSet.add(m.marketPda.toBase58());
+            });
+        }
+        [
+            ...spotMarketsSet,
+            ...perpMarketsSet,
+            ...oraclesSet
+        ].forEach((k)=>remainingAccounts.push({
+                pubkey: new web3_js.PublicKey(k),
+                isSigner: false,
+                isWritable: false
+            }));
+        return {
+            remainingAccounts,
+            numSpotMarkets: spotMarketsSet.size,
+            numPerpMarkets: perpMarketsSet.size
+        };
+    }
+    async remainingAccountsForPricingMeteora() {
+        const positions = await fetchMeteoraPositions(this.base.provider.connection, this.base.vaultPda);
+        let chunks = await Promise.all(positions.map(async (pubkey)=>{
+            const { lbPair, binArrayLower, binArrayUpper } = await parseMeteoraPosition(this.base.provider.connection, pubkey);
+            return [
+                pubkey,
+                lbPair,
+                binArrayLower,
+                binArrayUpper,
+                SOL_ORACLE,
+                USDC_ORACLE
+            ].map((k)=>({
+                    pubkey: k,
+                    isSigner: false,
+                    isWritable: false
+                }));
+        }));
+        return chunks.flat();
+    }
+    async remainingAccountsForPricingVaultAssets(baseAssetOnly = false) {
+        const stateModel = await this.base.fetchStateModel();
+        if (baseAssetOnly) {
+            if (!stateModel.baseAsset) {
+                throw new Error("Base asset not configured for the vault");
+            }
+            // FIXME: support token 2022 base asset
+            const ata = this.base.getVaultAta(stateModel.baseAsset);
+            // Set oracle to default pubkey (aka system program) to indicate oracle isn't needed
+            return [
+                ata,
+                stateModel.baseAsset,
+                web3_js.PublicKey.default
+            ].map((k)=>({
+                    pubkey: k,
+                    isSigner: false,
+                    isWritable: false
+                }));
+        }
+        const assetsForPricing = (stateModel.borrowableAssets || []).concat(stateModel.assets || []);
+        return assetsForPricing.map((mint)=>{
+            const assetMeta = ASSETS_MAINNET.get(mint.toBase58());
+            if (!assetMeta) {
+                throw new Error(`Asset meta not found for ${mint}`);
+            }
+            const ata = this.base.getVaultAta(mint, assetMeta?.programId);
+            return [
+                ata,
+                mint,
+                assetMeta?.oracle
+            ];
+        }).flat().map((a)=>({
+                pubkey: a,
+                isSigner: false,
+                isWritable: false
+            }));
+    }
     constructor(base, klend, kvaults, drift, dvaults){
         this.base = base;
         this.klend = klend;
         this.kvaults = kvaults;
         this.drift = drift;
         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)=>{
-                const { lbPair, binArrayLower, binArrayUpper } = await parseMeteoraPosition(this.base.provider.connection, pubkey);
-                return [
-                    pubkey,
-                    lbPair,
-                    binArrayLower,
-                    binArrayUpper,
-                    SOL_ORACLE,
-                    USDC_ORACLE
-                ].map((k)=>({
-                        pubkey: k,
-                        isSigner: false,
-                        isWritable: false
-                    }));
-            }));
-            return chunks.flat();
-        };
-        this.remainingAccountsForPricingVaultAssets = async (baseAssetOnly = false)=>{
-            const stateModel = await this.base.fetchStateModel();
-            if (baseAssetOnly) {
-                if (!stateModel.baseAsset) {
-                    throw new Error("Base asset not configured for the vault");
-                }
-                // FIXME: support token 2022 base asset
-                const ata = this.base.getVaultAta(stateModel.baseAsset);
-                // Set oracle to default pubkey (aka system program) to indicate oracle isn't needed
-                return [
-                    ata,
-                    stateModel.baseAsset,
-                    web3_js.PublicKey.default
-                ].map((k)=>({
-                        pubkey: k,
-                        isSigner: false,
-                        isWritable: false
-                    }));
-            }
-            const assetsForPricing = (stateModel.borrowableAssets || []).concat(stateModel.assets || []);
-            return assetsForPricing.map((mint)=>{
-                const assetMeta = ASSETS_MAINNET.get(mint.toBase58());
-                if (!assetMeta) {
-                    throw new Error(`Asset meta not found for ${mint}`);
-                }
-                const ata = this.base.getVaultAta(mint, assetMeta?.programId);
-                return [
-                    ata,
-                    mint,
-                    assetMeta?.oracle
-                ];
-            }).flat().map((a)=>({
-                    pubkey: a,
-                    isSigner: false,
-                    isWritable: false
-                }));
-        };
     }
 }
 
@@ -21957,6 +22038,7 @@ function getMarketOrderParams(params) {
     return Object.assign({}, DefaultOrderParams, optionalOrderParams, overridingParams);
 }
 
+exports.ALT_PROGRAM_ID = ALT_PROGRAM_ID;
 exports.ASSETS_MAINNET = ASSETS_MAINNET;
 exports.ASSETS_TESTS = ASSETS_TESTS;
 exports.AssetTier = AssetTier;
@@ -22064,7 +22146,6 @@ exports.VoteAuthorize = VoteAuthorize;
 exports.WSOL = WSOL;
 exports.ZERO = ZERO;
 exports.decodeUser = decodeUser;
-exports.fetchLookupTables = fetchLookupTables;
 exports.fetchMeteoraPositions = fetchMeteoraPositions;
 exports.fetchProgramLabels = fetchProgramLabels;
 exports.fetchTokenPrices = fetchTokenPrices;