@glamsystems/glam-sdk 0.1.29 → 0.1.31

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.33",
+    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"
             }
         ]
     },
@@ -7167,9 +7177,14 @@ 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",
-            "- (lending_market, reserve) x M, M = number of unique markets used by all kvaults involved"
+            "- 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,
@@ -7212,10 +7227,6 @@ var instructions = [
                 writable: true,
                 signer: true
             },
-            {
-                name: "kamino_lending_program",
-                address: "KLend2g3cP87fffoy8q1mQqGKjrxjC8boSyAYavgmjD"
-            },
             {
                 name: "sol_oracle"
             },
@@ -7280,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: [
@@ -9608,6 +9603,10 @@ var instructions = [
             {
                 name: "stake_history",
                 address: "SysvarStakeHistory1111111111111111111111111"
+            },
+            {
+                name: "system_program",
+                address: "11111111111111111111111111111111"
             }
         ],
         args: [
@@ -10026,7 +10025,8 @@ var instructions = [
         ],
         accounts: [
             {
-                name: "glam_state"
+                name: "glam_state",
+                writable: true
             },
             {
                 name: "glam_vault",
@@ -13573,6 +13573,9 @@ var types = [
                 },
                 {
                     name: "Fulfill"
+                },
+                {
+                    name: "ClaimFees"
                 }
             ]
         }
@@ -14950,6 +14953,15 @@ class PriceDenom {
         }
         return PriceDenom.ASSET;
     }
+    static fromString(str) {
+        if (str === "SOL") {
+            return PriceDenom.SOL;
+        }
+        if (str === "USD") {
+            return PriceDenom.USD;
+        }
+        throw new Error("Invalid price denomination");
+    }
 }
 PriceDenom.SOL = {
     sol: {}
@@ -14985,6 +14997,67 @@ var ClusterNetwork = /*#__PURE__*/ function(ClusterNetwork) {
     return ClusterNetwork;
 }({});
 
+/**
+ * Fetches all the token accounts owned by the specified pubkey.
+ */ async function getTokenAccountsByOwner(connection, owner) {
+    const tokenAccounts = await connection.getTokenAccountsByOwner(owner, {
+        programId: splToken.TOKEN_PROGRAM_ID
+    });
+    const token2022Accounts = await connection.getTokenAccountsByOwner(owner, {
+        programId: splToken.TOKEN_2022_PROGRAM_ID
+    });
+    const mintPubkeys = [];
+    const parseTokenAccountInfo = (pubkey, account)=>{
+        const { mint, amount, state } = splToken.AccountLayout.decode(account.data);
+        mintPubkeys.push(mint);
+        return {
+            owner,
+            pubkey,
+            mint,
+            amount: amount.toString(),
+            frozen: state !== 1
+        };
+    };
+    // Parse token accounts
+    const partialTokenAccounts = tokenAccounts.value.map(({ pubkey, account })=>({
+            ...parseTokenAccountInfo(pubkey, account),
+            programId: splToken.TOKEN_PROGRAM_ID
+        })).concat(token2022Accounts.value.map(({ pubkey, account })=>({
+            ...parseTokenAccountInfo(pubkey, account),
+            programId: splToken.TOKEN_2022_PROGRAM_ID
+        })));
+    // Get mint decimals
+    const mintDecimalMap = new Map();
+    const mintAccountsInfo = await connection.getMultipleAccountsInfo(mintPubkeys);
+    mintAccountsInfo.forEach((accountInfo, i)=>{
+        if (accountInfo) {
+            const mint = splToken.unpackMint(mintPubkeys[i], accountInfo, accountInfo.owner);
+            mintDecimalMap.set(mintPubkeys[i].toBase58(), mint.decimals);
+        }
+    });
+    // Enrich token accounts with decimals and uiAmount
+    return partialTokenAccounts.map((ta)=>{
+        const decimals = mintDecimalMap.get(ta.mint.toBase58());
+        if (!decimals) {
+            return null;
+        }
+        return {
+            ...ta,
+            decimals,
+            uiAmount: Number(ta.amount) / 10 ** decimals
+        };
+    }).filter((ta)=>ta !== null);
+}
+async function getSolAndTokenBalances(connection, owner) {
+    const balanceLamports = await connection.getBalance(owner);
+    const tokenAccounts = await getTokenAccountsByOwner(connection, owner);
+    const uiAmount = balanceLamports / web3_js.LAMPORTS_PER_SOL;
+    return {
+        balanceLamports,
+        uiAmount,
+        tokenAccounts
+    };
+}
 const findStakeAccounts = async (connection, withdrawAuthority)=>{
     // stake authority offset: 12
     // withdraw authority offset: 44
@@ -15203,7 +15276,7 @@ STAKE_POOLS.push({
     symbol: "PSOL",
     mint: "pSo1f9nQXWgXibFtKf7NWYxb5enAM4qfP6UJSiXRQfL",
     decimals: 9,
-    logoURI: "https://assets.phantom.app/assets/metadata/PSOL-512.png",
+    logoURI: "https://coin-images.coingecko.com/coins/images/55849/large/PSOL.png",
     tokenProgram: splToken.TOKEN_PROGRAM_ID,
     poolState: new web3_js.PublicKey("pSPcvR8GmG9aKDUbn9nbKYjkxt9hxMS7kF1qqKJaPqJ")
 });
@@ -15284,6 +15357,15 @@ const ASSETS_MAINNET = new Map([
             oracle: new web3_js.PublicKey("9PgHM68FNGDK6nHb29ERDBcFrV6gNMD8LyUqwxbyyeb2")
         }
     ],
+    [
+        // USDG
+        "2u1tszSeqZ3qBWF3uNGPFc8TzMk2tdiwknnRMWGWjGWH",
+        {
+            decimals: 6,
+            oracle: new web3_js.PublicKey("6JkZmXGgWnzsyTQaqRARzP64iFYnpMNT4siiuUDUaB8s"),
+            programId: splToken.TOKEN_2022_PROGRAM_ID
+        }
+    ],
     [
         // PYUSD
         "2b1kV6DkPAnxd5ixfnxCpjxmKwqjjaYmCZfHsFu24GXo",
@@ -15507,12 +15589,6 @@ 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() {
@@ -15601,17 +15677,16 @@ class BaseClient {
         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.fetchAdressLookupTableAccounts(pubkeys);
+            const lookupTables = data.t || {};
+            const lookupTableAccounts = [];
+            for (const [key, lookupTableData] of Object.entries(lookupTables)){
+                const account = new web3_js.AddressLookupTableAccount({
+                    key: new web3_js.PublicKey(key),
+                    state: web3_js.AddressLookupTableAccount.deserialize(new Uint8Array(Buffer.from(lookupTableData, "base64")))
+                });
+                lookupTableAccounts.push(account);
             }
-        }
-        const tablePubkey = STATES_LOOKUP_TABLES_MAP.get(this.statePda.toBase58());
-        if (tablePubkey) {
-            return await this.fetchAdressLookupTableAccounts([
-                tablePubkey
-            ]);
+            return lookupTableAccounts;
         }
         // 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"
@@ -15660,17 +15735,35 @@ class BaseClient {
         }
         const lookupTableAccounts = [];
         if (lookupTables.every((t)=>t instanceof web3_js.AddressLookupTableAccount)) {
-            const accounts = await this.fetchAdressLookupTableAccounts([
+            const accounts = await this.fetchAddressLookupTableAccounts([
                 ...LOOKUP_TABLES
             ]);
             lookupTableAccounts.push(...lookupTables, ...accounts);
         } else {
-            const accounts = await this.fetchAdressLookupTableAccounts([
+            const accounts = await this.fetchAddressLookupTableAccounts([
                 ...lookupTables,
                 ...LOOKUP_TABLES
             ]);
             lookupTableAccounts.push(...accounts);
         }
+        const glamApi = process.env.NEXT_PUBLIC_GLAM_API || process.env.GLAM_API;
+        if (glamApi) {
+            try {
+                const response = await fetch(`${glamApi}/v0/lut/glam/?state=${this.statePda}`);
+                const data = await response.json();
+                const lookupTables = data.t || {};
+                for (const [key, lookupTableData] of Object.entries(lookupTables)){
+                    const account = new web3_js.AddressLookupTableAccount({
+                        key: new web3_js.PublicKey(key),
+                        state: web3_js.AddressLookupTableAccount.deserialize(new Uint8Array(Buffer.from(lookupTableData, "base64")))
+                    });
+                    lookupTableAccounts.push(account);
+                }
+            } catch (e) {
+                console.error("Failed to fetch lookup tables:", e); // Fail open
+            }
+        }
+        console.log("lookupTableAccounts:", lookupTableAccounts.map((t)=>t.key.toBase58()));
         const recentBlockhash = (await this.blockhashWithCache.get()).blockhash;
         const { unitsConsumed, error, serializedTx } = await getSimulationResult(this.provider.connection, instructions, signer, lookupTableAccounts);
         computeUnitLimit = unitsConsumed;
@@ -15749,7 +15842,7 @@ class BaseClient {
    *
    * @param pubkeys Array of lookup table public keys.
    * @returns
-   */ async fetchAdressLookupTableAccounts(pubkeys) {
+   */ async fetchAddressLookupTableAccounts(pubkeys) {
         if (!pubkeys) {
             throw new Error("addressLookupTableAddresses is undefined");
         }
@@ -19762,176 +19855,6 @@ const DEFAULT_OBLIGATION_ARGS = {
     id: 0
 };
 const EVENT_AUTHORITY$1 = new web3_js.PublicKey("24tHwQyJJ9akVXxnvkekGfAoeUJXXS7mE6kQNioNySsK");
-function refreshObligation(accounts, programId = KAMINO_LENDING_PROGRAM) {
-    const keys = [
-        {
-            pubkey: accounts.lendingMarket,
-            isSigner: false,
-            isWritable: false
-        },
-        {
-            pubkey: accounts.obligation,
-            isSigner: false,
-            isWritable: true
-        }
-    ];
-    accounts.reserves.forEach((reserve)=>{
-        keys.push({
-            pubkey: reserve,
-            isSigner: false,
-            isWritable: false
-        });
-    });
-    const identifier = Buffer.from([
-        33,
-        132,
-        147,
-        228,
-        151,
-        192,
-        72,
-        89
-    ]);
-    const data = identifier;
-    const ix = new web3_js.TransactionInstruction({
-        keys,
-        programId,
-        data
-    });
-    return ix;
-}
-function refreshReserve(accounts, programId = KAMINO_LENDING_PROGRAM) {
-    const keys = [
-        {
-            pubkey: accounts.reserve,
-            isSigner: false,
-            isWritable: true
-        },
-        {
-            pubkey: accounts.lendingMarket,
-            isSigner: false,
-            isWritable: false
-        },
-        {
-            pubkey: accounts.pythOracle,
-            isSigner: false,
-            isWritable: false
-        },
-        {
-            pubkey: accounts.switchboardPriceOracle,
-            isSigner: false,
-            isWritable: false
-        },
-        {
-            pubkey: accounts.switchboardTwapOracle,
-            isSigner: false,
-            isWritable: false
-        },
-        {
-            pubkey: accounts.scopePrices,
-            isSigner: false,
-            isWritable: false
-        }
-    ];
-    const identifier = Buffer.from([
-        2,
-        218,
-        138,
-        235,
-        79,
-        201,
-        25,
-        102
-    ]);
-    const data = identifier;
-    const ix = new web3_js.TransactionInstruction({
-        keys,
-        programId,
-        data
-    });
-    return ix;
-}
-function refreshObligationFarmsForReserve(args, accounts, programId = KAMINO_LENDING_PROGRAM) {
-    const keys = [
-        {
-            pubkey: accounts.crank,
-            isSigner: true,
-            isWritable: false
-        },
-        {
-            pubkey: accounts.baseAccounts.obligation,
-            isSigner: false,
-            isWritable: false
-        },
-        {
-            pubkey: accounts.baseAccounts.lendingMarketAuthority,
-            isSigner: false,
-            isWritable: true
-        },
-        {
-            pubkey: accounts.baseAccounts.reserve,
-            isSigner: false,
-            isWritable: false
-        },
-        {
-            pubkey: accounts.baseAccounts.reserveFarmState,
-            isSigner: false,
-            isWritable: true
-        },
-        {
-            pubkey: accounts.baseAccounts.obligationFarmUserState,
-            isSigner: false,
-            isWritable: true
-        },
-        {
-            pubkey: accounts.baseAccounts.lendingMarket,
-            isSigner: false,
-            isWritable: false
-        },
-        {
-            pubkey: accounts.farmsProgram,
-            isSigner: false,
-            isWritable: false
-        },
-        {
-            pubkey: accounts.rent,
-            isSigner: false,
-            isWritable: false
-        },
-        {
-            pubkey: accounts.systemProgram,
-            isSigner: false,
-            isWritable: false
-        }
-    ];
-    const identifier = Buffer.from([
-        140,
-        144,
-        253,
-        21,
-        10,
-        74,
-        248,
-        3
-    ]);
-    const buffer = Buffer.alloc(1000);
-    const layout = borsh__namespace.struct([
-        borsh__namespace.u8("mode")
-    ]);
-    const len = layout.encode({
-        mode: args.mode
-    }, buffer);
-    const data = Buffer.concat([
-        identifier,
-        buffer
-    ]).subarray(0, 8 + len);
-    const ix = new web3_js.TransactionInstruction({
-        keys,
-        programId,
-        data
-    });
-    return ix;
-}
 class KaminoLendingClient {
     /**
    * Initializes Kamino user metadata
@@ -20023,8 +19946,228 @@ class KaminoLendingClient {
         ], KAMINO_FARM_PROGRAM);
         return obligationFarm;
     }
+    refreshObligationIx(accounts, programId = KAMINO_LENDING_PROGRAM) {
+        const keys = [
+            {
+                pubkey: accounts.lendingMarket,
+                isSigner: false,
+                isWritable: false
+            },
+            {
+                pubkey: accounts.obligation,
+                isSigner: false,
+                isWritable: true
+            }
+        ];
+        accounts.reserves.forEach((reserve)=>{
+            keys.push({
+                pubkey: reserve,
+                isSigner: false,
+                isWritable: false
+            });
+        });
+        const identifier = Buffer.from([
+            33,
+            132,
+            147,
+            228,
+            151,
+            192,
+            72,
+            89
+        ]);
+        const data = identifier;
+        return new web3_js.TransactionInstruction({
+            keys,
+            programId,
+            data
+        });
+    }
+    refreshReserveIx(accounts, programId = KAMINO_LENDING_PROGRAM) {
+        const keys = [
+            {
+                pubkey: accounts.reserve,
+                isSigner: false,
+                isWritable: true
+            },
+            {
+                pubkey: accounts.lendingMarket,
+                isSigner: false,
+                isWritable: false
+            },
+            {
+                pubkey: accounts.pythOracle,
+                isSigner: false,
+                isWritable: false
+            },
+            {
+                pubkey: accounts.switchboardPriceOracle,
+                isSigner: false,
+                isWritable: false
+            },
+            {
+                pubkey: accounts.switchboardTwapOracle,
+                isSigner: false,
+                isWritable: false
+            },
+            {
+                pubkey: accounts.scopePrices,
+                isSigner: false,
+                isWritable: false
+            }
+        ];
+        const identifier = Buffer.from([
+            2,
+            218,
+            138,
+            235,
+            79,
+            201,
+            25,
+            102
+        ]);
+        const data = identifier;
+        return new web3_js.TransactionInstruction({
+            keys,
+            programId,
+            data
+        });
+    }
+    refreshObligationFarmsForReserveIx(args, accounts, programId = KAMINO_LENDING_PROGRAM) {
+        const keys = [
+            {
+                pubkey: accounts.crank,
+                isSigner: true,
+                isWritable: false
+            },
+            {
+                pubkey: accounts.baseAccounts.obligation,
+                isSigner: false,
+                isWritable: false
+            },
+            {
+                pubkey: accounts.baseAccounts.lendingMarketAuthority,
+                isSigner: false,
+                isWritable: true
+            },
+            {
+                pubkey: accounts.baseAccounts.reserve,
+                isSigner: false,
+                isWritable: false
+            },
+            {
+                pubkey: accounts.baseAccounts.reserveFarmState,
+                isSigner: false,
+                isWritable: true
+            },
+            {
+                pubkey: accounts.baseAccounts.obligationFarmUserState,
+                isSigner: false,
+                isWritable: true
+            },
+            {
+                pubkey: accounts.baseAccounts.lendingMarket,
+                isSigner: false,
+                isWritable: false
+            },
+            {
+                pubkey: accounts.farmsProgram,
+                isSigner: false,
+                isWritable: false
+            },
+            {
+                pubkey: accounts.rent,
+                isSigner: false,
+                isWritable: false
+            },
+            {
+                pubkey: accounts.systemProgram,
+                isSigner: false,
+                isWritable: false
+            }
+        ];
+        const identifier = Buffer.from([
+            140,
+            144,
+            253,
+            21,
+            10,
+            74,
+            248,
+            3
+        ]);
+        const buffer = Buffer.alloc(1000);
+        const layout = borsh__namespace.struct([
+            borsh__namespace.u8("mode")
+        ]);
+        const len = layout.encode({
+            mode: args.mode
+        }, buffer);
+        const data = Buffer.concat([
+            identifier,
+            buffer
+        ]).subarray(0, 8 + len);
+        return new web3_js.TransactionInstruction({
+            keys,
+            programId,
+            data
+        });
+    }
+    refreshReservesBatchIx(reserves, lendingMarkets, skipPriceUpdates, programId = KAMINO_LENDING_PROGRAM) {
+        const keys = [];
+        for(let i = 0; i < reserves.length; i++){
+            keys.push({
+                pubkey: reserves[i],
+                isSigner: false,
+                isWritable: false
+            });
+            keys.push({
+                pubkey: lendingMarkets[i],
+                isSigner: false,
+                isWritable: true
+            });
+            if (!skipPriceUpdates) {
+                [
+                    KAMINO_LENDING_PROGRAM,
+                    KAMINO_LENDING_PROGRAM,
+                    KAMINO_LENDING_PROGRAM,
+                    KAMINO_SCOPE_PRICES
+                ].forEach((p)=>keys.push({
+                        pubkey: p,
+                        isSigner: false,
+                        isWritable: false
+                    }));
+            }
+        }
+        const identifier = Buffer.from([
+            144,
+            110,
+            26,
+            103,
+            162,
+            204,
+            252,
+            147
+        ]);
+        const buffer = Buffer.alloc(1000);
+        const layout = borsh__namespace.struct([
+            borsh__namespace.bool("skipPriceUpdates")
+        ]);
+        const len = layout.encode({
+            skipPriceUpdates
+        }, buffer);
+        const data = Buffer.concat([
+            identifier,
+            buffer
+        ]).subarray(0, 8 + len);
+        return new web3_js.TransactionInstruction({
+            keys,
+            programId,
+            data
+        });
+    }
     refreshReserveIxs(lendingMarket, reserves) {
-        return reserves.map((reserve)=>refreshReserve({
+        return reserves.map((reserve)=>this.refreshReserveIx({
                 reserve,
                 lendingMarket,
                 pythOracle: KAMINO_LENDING_PROGRAM,
@@ -20040,7 +20183,7 @@ class KaminoLendingClient {
                 farmCollateral
             ].filter((farm)=>!!farm).map((farm)=>{
                 const obligationFarmUserState = this.getObligationFarmState(obligation, farm);
-                return refreshObligationFarmsForReserve({
+                return this.refreshObligationFarmsForReserveIx({
                     mode: 0
                 }, {
                     crank: this.base.getSigner(),
@@ -20066,7 +20209,7 @@ class KaminoLendingClient {
                 farmDebt
             ].filter((farm)=>!!farm).map((farm)=>{
                 const obligationFarmUserState = this.getObligationFarmState(obligation, farm);
-                return refreshObligationFarmsForReserve({
+                return this.refreshObligationFarmsForReserveIx({
                     mode: 0
                 }, {
                     crank: this.base.getSigner(),
@@ -20352,7 +20495,7 @@ class KaminoLendingClient {
         // Refresh reserves, including deposit reserve and reserves in use
         preInstructions.push(...this.refreshReserveIxs(market, reservesToRefresh));
         // Refresh obligation with reserves in use
-        preInstructions.push(refreshObligation({
+        preInstructions.push(this.refreshObligationIx({
             lendingMarket: market,
             obligation,
             reserves: reservesInUse
@@ -20442,7 +20585,7 @@ class KaminoLendingClient {
         // Refresh reserves, including deposit reserve and reserves in use
         preInstructions.push(...this.refreshReserveIxs(market, reservesToRefresh));
         // Refresh obligation with reserves in use
-        preInstructions.push(refreshObligation({
+        preInstructions.push(this.refreshObligationIx({
             lendingMarket: market,
             obligation,
             reserves: reservesInUse
@@ -20526,7 +20669,7 @@ class KaminoLendingClient {
         // Refresh reserves, including deposit reserve and reserves in use
         preInstructions.push(...this.refreshReserveIxs(market, reservesToRefresh));
         // Refresh obligation with reserves in use
-        preInstructions.push(refreshObligation({
+        preInstructions.push(this.refreshObligationIx({
             lendingMarket: market,
             obligation,
             reserves: reservesInUse
@@ -20608,7 +20751,7 @@ class KaminoLendingClient {
         // Refresh reserves, including deposit reserve and reserves in use
         preInstructions.push(...this.refreshReserveIxs(market, reservesToRefresh));
         // Refresh obligation with reserves in use
-        preInstructions.push(refreshObligation({
+        preInstructions.push(this.refreshObligationIx({
             lendingMarket: market,
             obligation,
             reserves: reservesInUse
@@ -20811,7 +20954,7 @@ class KaminoVaultsClient {
         if (this.vaultStates.size === 0) {
             await this.findAndParseKaminoVaults();
         }
-        return mints.map((mint)=>this.shareMintToVaultPdaMap.get(mint.toBase58()));
+        return mints.map((mint)=>this.shareMintToVaultPdaMap.get(mint.toBase58())).filter((p)=>!!p);
     }
     async fetchAndParseVaultState(vault) {
         const vaultAccount = await this.base.provider.connection.getAccountInfo(vault);
@@ -20824,9 +20967,7 @@ class KaminoVaultsClient {
         return vaultState;
     }
     async composeRemainingAccounts(allocationStrategies, pricingMode = false) {
-        // Iterate over allocation strategies and get reserve pubkeys, using a Set to avoid dupes
-        const reservesSet = new Set(allocationStrategies.map((strategy)=>strategy.reserve.toBase58()));
-        const reserves = Array.from(reservesSet).map((p)=>new web3_js.PublicKey(p));
+        const reserves = allocationStrategies.map((strategy)=>strategy.reserve);
         const parsedReserves = await this.kaminoLending.fetchAndParseReserves(reserves);
         const reserveMetas = reserves.map((pubkey)=>({
                 pubkey,
@@ -21368,6 +21509,21 @@ class InvestClient {
 }
 
 class PriceClient {
+    get stateModel() {
+        if (!this._stateModel) {
+            throw new Error("State model not cached");
+        }
+        return this._stateModel;
+    }
+    set stateModel(stateModel) {
+        this._stateModel = stateModel;
+    }
+    get lookupTables() {
+        return Array.from(this._lookupTables).map((k)=>new web3_js.PublicKey(k));
+    }
+    get kaminoVaults() {
+        return Array.from(this._kaminoVaults).map((k)=>new web3_js.PublicKey(k));
+    }
     /**
    * !! This is a convenience method that calculates the AUM of the vault based on priced assets.
    * !! It doesn't reflect the actual AUM of the vault.
@@ -21411,7 +21567,7 @@ class PriceClient {
     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
+        // All kvaut 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 = [];
@@ -21419,16 +21575,24 @@ class PriceClient {
         const kvaultStates = [];
         const oracles = []; // oracle of kvault deposit token
         possibleShareAtaAccountsInfo.forEach((info, i)=>{
-            if (info !== null) {
+            // share ata must exist and it must be tracked by glam state
+            // otherwise skip it for pricing
+            if (info !== null && this.stateModel.externalVaultAccounts?.find((a)=>a.equals(possibleShareAtas[i]))) {
                 shareAtas.push(possibleShareAtas[i]);
                 shareMints.push(allKvaultMints[i]);
                 kvaultStates.push(allKvaultStates[i]);
-                const { tokenMint } = allKvaultStates[i];
+                // get oracle and lookup table from kvault state
+                const { tokenMint, vaultLookupTable } = allKvaultStates[i];
                 const assetMeta = ASSETS_MAINNET.get(tokenMint.toBase58());
-                oracles.push(assetMeta?.oracle);
+                if (!assetMeta || !assetMeta.oracle) {
+                    throw new Error(`Oracle unavailable for asset ${tokenMint}`);
+                }
+                oracles.push(assetMeta.oracle);
+                this._lookupTables.add(vaultLookupTable.toBase58()); // cache lookup table
             }
         });
         const kvaultPdas = await this.kvaults.getVaultPdasByShareMints(shareMints);
+        kvaultPdas.forEach((p)=>this._kaminoVaults.add(p.toBase58())); // cache kvault keys
         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++){
@@ -21439,26 +21603,44 @@ class PriceClient {
                 oracles[i]
             ].map((pubkey)=>{
                 remainingAccounts.push({
-                    pubkey,
+                    pubkey: pubkey,
                     isSigner: false,
                     isWritable: false
                 });
             });
         }
-        // markets and reserves
         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();
-        remainingAccounts.push(...marketsAndReserves);
+        const processed = new Set();
+        const reserves = [];
+        const markets = [];
+        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]);
+            // record reserves and markets for refreshReservesBatchIx
+            if (!processed.has(reserve.toBase58())) {
+                reserves.push(reserve);
+                markets.push(market);
+                processed.add(reserve.toBase58());
+            }
+        }
+        const refreshReservesIx = this.klend.refreshReservesBatchIx(reserves, markets, false);
+        const preInstructions = [
+            refreshReservesIx
+        ];
         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.
@@ -21526,43 +21708,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();
@@ -21622,7 +21769,8 @@ class PriceClient {
         }
         // If there are no external assets, we don't need to price DeFi positions
         const stateModel = await this.base.fetchStateModel();
-        if ((stateModel.externalVaultAccounts || []).length === 0) {
+        this.stateModel = stateModel;
+        if ((this.stateModel.externalVaultAccounts || []).length === 0) {
             return [
                 priceVaultIx
             ];
@@ -21642,72 +21790,133 @@ class PriceClient {
         ];
         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);
     }
-    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
-                    }));
+    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 chunks.flat();
+        return {
+            remainingAccounts,
+            numSpotMarkets: spotMarketsSet.size,
+            numPerpMarkets: perpMarketsSet.size
         };
-        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
-                    }));
+    }
+    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");
             }
-            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,
+            // 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._stateModel = null;
+        this._lookupTables = new Set();
+        this._kaminoVaults = new Set();
     }
 }
 
@@ -22129,8 +22338,10 @@ exports.getOpenfundsPda = getOpenfundsPda;
 exports.getOrderParams = getOrderParams;
 exports.getPriorityFeeEstimate = getPriorityFeeEstimate;
 exports.getSimulationResult = getSimulationResult;
+exports.getSolAndTokenBalances = getSolAndTokenBalances;
 exports.getStakeAccountsWithStates = getStakeAccountsWithStates;
 exports.getStatePda = getStatePda;
+exports.getTokenAccountsByOwner = getTokenAccountsByOwner;
 exports.getTriggerLimitOrderParams = getTriggerLimitOrderParams;
 exports.getTriggerMarketOrderParams = getTriggerMarketOrderParams;
 exports.getVariant = getVariant;