@kamino-finance/klend-sdk 6.1.0-beta.0 → 7.0.1

package/dist/classes/market.js

@@ -8,55 +8,55 @@ exports.getReservesForMarket = getReservesForMarket;
 exports.getSingleReserve = getSingleReserve;
 exports.getReservesActive = getReservesActive;
 exports.getTokenIdsForScopeRefresh = getTokenIdsForScopeRefresh;
-exports.getReserveFromMintAndMarket = getReserveFromMintAndMarket;
-const web3_js_1 = require("@solana/web3.js");
+const kit_1 = require("@solana/kit");
 const obligation_1 = require("./obligation");
 const reserve_1 = require("./reserve");
-const accounts_1 = require("../idl_codegen/accounts");
+const accounts_1 = require("../@codegen/klend/accounts");
 const utils_1 = require("../utils");
-const bs58_1 = __importDefault(require("bs58"));
-const anchor_1 = require("@coral-xyz/anchor");
+const bn_js_1 = __importDefault(require("bn.js"));
 const decimal_js_1 = __importDefault(require("decimal.js"));
 const farms_sdk_1 = require("@kamino-finance/farms-sdk");
-const programId_1 = require("../idl_codegen/programId");
-const bs58_2 = __importDefault(require("bs58"));
+const programId_1 = require("../@codegen/klend/programId");
 const scope_sdk_1 = require("@kamino-finance/scope-sdk");
 const fraction_1 = require("./fraction");
 const kliquidity_sdk_1 = require("@kamino-finance/kliquidity-sdk");
 const utils_2 = require("./utils");
-const sbv2_lite_1 = __importDefault(require("@switchboard-xyz/sbv2-lite"));
-const zero_padding_1 = require("../idl_codegen/zero_padding");
-const utils_3 = require("../utils");
+const zero_padding_1 = require("../@codegen/klend/zero_padding");
 const validations_1 = require("../utils/validations");
+const buffer_1 = require("buffer");
+const base58Decoder = (0, kit_1.getBase58Decoder)();
 class KaminoMarket {
-    connection;
+    rpc;
     address;
     state;
     reserves;
     reservesActive;
     programId;
     recentSlotDurationMs;
-    constructor(connection, state, marketAddress, reserves, recentSlotDurationMs, programId = programId_1.PROGRAM_ID) {
+    // scope feeds used by all market reserves
+    scopeFeeds;
+    constructor(rpc, state, marketAddress, reserves, recentSlotDurationMs, programId = programId_1.PROGRAM_ID) {
         this.address = marketAddress;
-        this.connection = connection;
+        this.rpc = rpc;
         this.state = state;
         this.reserves = reserves;
         this.reservesActive = getReservesActive(this.reserves);
         this.programId = programId;
         this.recentSlotDurationMs = recentSlotDurationMs;
+        this.scopeFeeds = new Set(Array.from(this.reserves.values())
+            .filter((r) => (0, utils_1.isNotNullPubkey)(r.state.config.tokenInfo.scopeConfiguration.priceFeed))
+            .map((r) => r.state.config.tokenInfo.scopeConfiguration.priceFeed));
     }
     /**
      * Load a new market with all of its associated reserves
-     * @param connection
+     * @param rpc
      * @param marketAddress
      * @param recentSlotDurationMs
      * @param programId
      * @param withReserves
-     * @param setupLocalTest
-     * @param withReserves
      */
-    static async load(connection, marketAddress, recentSlotDurationMs, programId = programId_1.PROGRAM_ID, withReserves = true) {
-        const market = await accounts_1.LendingMarket.fetch(connection, marketAddress, programId);
+    static async load(rpc, marketAddress, recentSlotDurationMs, programId = programId_1.PROGRAM_ID, withReserves = true) {
+        const market = await accounts_1.LendingMarket.fetch(rpc, marketAddress, programId);
         if (market === null) {
             return null;
         }
@@ -64,24 +64,24 @@ class KaminoMarket {
             throw new Error('Recent slot duration cannot be 0');
         }
         const reserves = withReserves
-            ? await getReservesForMarket(marketAddress, connection, programId, recentSlotDurationMs)
+            ? await getReservesForMarket(marketAddress, rpc, programId, recentSlotDurationMs)
             : new Map();
-        return new KaminoMarket(connection, market, marketAddress.toString(), reserves, recentSlotDurationMs, programId);
+        return new KaminoMarket(rpc, market, marketAddress, reserves, recentSlotDurationMs, programId);
     }
     static loadWithReserves(connection, market, reserves, marketAddress, recentSlotDurationMs, programId = programId_1.PROGRAM_ID) {
-        return new KaminoMarket(connection, market, marketAddress.toString(), reserves, recentSlotDurationMs, programId);
+        return new KaminoMarket(connection, market, marketAddress, reserves, recentSlotDurationMs, programId);
     }
     async reload() {
-        const market = await accounts_1.LendingMarket.fetch(this.connection, this.getAddress(), this.programId);
+        const market = await accounts_1.LendingMarket.fetch(this.rpc, this.getAddress(), this.programId);
         if (market === null) {
             return;
         }
         this.state = market;
-        this.reserves = await getReservesForMarket(this.getAddress(), this.connection, this.programId, this.recentSlotDurationMs);
+        this.reserves = await getReservesForMarket(this.getAddress(), this.rpc, this.programId, this.recentSlotDurationMs);
         this.reservesActive = getReservesActive(this.reserves);
     }
-    async reloadSingleReserve(reservePk, accountData) {
-        const reserve = await getSingleReserve(reservePk, this.connection, this.recentSlotDurationMs, accountData);
+    async reloadSingleReserve(reservePk, reserveData) {
+        const reserve = await getSingleReserve(reservePk, this.rpc, this.recentSlotDurationMs, reserveData);
         this.reserves.set(reservePk, reserve);
         this.reservesActive.set(reservePk, reserve);
     }
@@ -90,7 +90,7 @@ class KaminoMarket {
      * @return market address public key
      */
     getAddress() {
-        return new web3_js_1.PublicKey(this.address);
+        return this.address;
     }
     /**
      * Get a list of reserves for this market
@@ -118,8 +118,8 @@ class KaminoMarket {
      * Get the authority PDA of this market
      * @return market authority public key
      */
-    getLendingMarketAuthority() {
-        return (0, utils_1.lendingMarketAuthPda)(this.getAddress(), this.programId)[0];
+    async getLendingMarketAuthority() {
+        return (await (0, utils_1.lendingMarketAuthPda)(this.getAddress(), this.programId))[0];
     }
     getName() {
         return (0, utils_2.parseZeroPaddedUtf8)(this.state.name);
@@ -159,8 +159,8 @@ class KaminoMarket {
         return [...groupsColl].filter((item) => groupsDebt.has(item) &&
             item !== 0 &&
             this.state.elevationGroups[item - 1].allowNewLoans !== 0 &&
-            collReserve.state.config.borrowLimitAgainstThisCollateralInElevationGroup[item - 1].gt(new anchor_1.BN(0)) &&
-            this.state.elevationGroups[item - 1].debtReserve.equals(debtReserve.address));
+            collReserve.state.config.borrowLimitAgainstThisCollateralInElevationGroup[item - 1].gt(new bn_js_1.default(0)) &&
+            this.state.elevationGroups[item - 1].debtReserve === debtReserve.address);
     }
     getMaxAndLiquidationLtvAndBorrowFactorForPair(collTokenMint, debtTokenMint) {
         const collReserve = this.getReserveByMint(collTokenMint);
@@ -218,12 +218,12 @@ class KaminoMarket {
             .filter((obligation) => obligation.refreshedStats.userTotalBorrow.gt(0) || obligation.refreshedStats.userTotalDeposit.gt(0))
             .reduce((acc, _obligation) => acc + 1, 0);
     }
-    async getObligationByWallet(publicKey, obligationType) {
+    async getObligationByWallet(Address, obligationType) {
         const { address } = this;
         if (!address) {
             throw Error('Market must be initialized to call initialize.');
         }
-        const obligationAddress = obligationType.toPda(this.getAddress(), publicKey);
+        const obligationAddress = await obligationType.toPda(this.getAddress(), Address);
         return obligation_1.KaminoObligation.load(this, obligationAddress);
     }
     /**
@@ -236,25 +236,27 @@ class KaminoMarket {
     }
     async loadReserves() {
         const addresses = [...this.reserves.keys()];
-        const reserveAccounts = await this.connection.getMultipleAccountsInfo(addresses, 'processed');
-        const deserializedReserves = reserveAccounts.map((reserve, i) => {
+        const reserveAccounts = await this.rpc
+            .getMultipleAccounts(addresses, { commitment: 'processed', encoding: 'base64' })
+            .send();
+        const deserializedReserves = reserveAccounts.value.map((reserve, i) => {
             if (reserve === null) {
                 // maybe reuse old here
-                throw new Error(`Reserve account ${addresses[i].toBase58()} was not found`);
+                throw new Error(`Reserve account ${addresses[i]} was not found`);
             }
-            const reserveAccount = accounts_1.Reserve.decode(reserve.data);
+            const reserveAccount = accounts_1.Reserve.decode(buffer_1.Buffer.from(reserve.data[0], 'base64'));
             if (!reserveAccount) {
-                throw Error(`Could not parse reserve ${addresses[i].toBase58()}`);
+                throw Error(`Could not parse reserve ${addresses[i]}`);
             }
             return reserveAccount;
         });
-        const reservesAndOracles = await (0, utils_1.getTokenOracleData)(this.connection, deserializedReserves);
-        const kaminoReserves = new utils_1.PubkeyHashMap();
+        const reservesAndOracles = await (0, utils_1.getTokenOracleData)(this.getRpc(), deserializedReserves);
+        const kaminoReserves = new Map();
         reservesAndOracles.forEach(([reserve, oracle], index) => {
             if (!oracle) {
                 throw Error(`Could not find oracle for ${(0, utils_2.parseTokenSymbol)(reserve.config.tokenInfo.name)} reserve`);
             }
-            const kaminoReserve = reserve_1.KaminoReserve.initialize(reserveAccounts[index], addresses[index], reserve, oracle, this.connection, this.recentSlotDurationMs);
+            const kaminoReserve = reserve_1.KaminoReserve.initialize(addresses[index], reserve, oracle, this.rpc, this.recentSlotDurationMs);
             kaminoReserves.set(kaminoReserve.address, kaminoReserve);
         });
         this.reserves = kaminoReserves;
@@ -277,7 +279,7 @@ class KaminoMarket {
     }
     getReserveByMint(address) {
         for (const reserve of this.reserves.values()) {
-            if (reserve.getLiquidityMint().equals(address)) {
+            if (reserve.getLiquidityMint() === address) {
                 return reserve;
             }
         }
@@ -330,7 +332,7 @@ class KaminoMarket {
                 rewardsPerSecond: new decimal_js_1.default(0),
                 rewardsRemaining: new decimal_js_1.default(0),
                 rewardApr: new decimal_js_1.default(0),
-                rewardMint: web3_js_1.PublicKey.default,
+                rewardMint: utils_1.DEFAULT_PUBLIC_KEY,
                 totalInvestmentUsd: new decimal_js_1.default(0),
                 rewardPrice: 0,
             },
@@ -338,7 +340,7 @@ class KaminoMarket {
                 rewardsPerSecond: new decimal_js_1.default(0),
                 rewardsRemaining: new decimal_js_1.default(0),
                 rewardApr: new decimal_js_1.default(0),
-                rewardMint: web3_js_1.PublicKey.default,
+                rewardMint: utils_1.DEFAULT_PUBLIC_KEY,
                 totalInvestmentUsd: new decimal_js_1.default(0),
                 rewardPrice: 0,
             },
@@ -352,7 +354,7 @@ class KaminoMarket {
         return result;
     }
     async getRewardInfoForFarm(farmAddress, totalInvestmentUsd, getRewardPrice) {
-        const farmState = await farms_sdk_1.FarmState.fetch(this.connection, farmAddress);
+        const farmState = await farms_sdk_1.FarmState.fetch(this.getRpc(), farmAddress);
         if (!farmState) {
             throw Error(`Could not parse farm state. ${farmAddress}`);
         }
@@ -387,43 +389,42 @@ class KaminoMarket {
     async getAllObligationsForMarket(tag) {
         const filters = [
             {
-                dataSize: accounts_1.Obligation.layout.span + 8,
+                dataSize: BigInt(accounts_1.Obligation.layout.span + 8),
             },
             {
                 memcmp: {
-                    offset: 32,
-                    bytes: this.address,
+                    offset: 32n,
+                    bytes: this.address.toString(),
+                    encoding: 'base58',
                 },
             },
         ];
         if (tag !== undefined) {
             filters.push({
                 memcmp: {
-                    offset: 8,
-                    bytes: bs58_1.default.encode(new anchor_1.BN(tag).toBuffer()),
+                    offset: 8n,
+                    bytes: base58Decoder.decode(new bn_js_1.default(tag).toBuffer()),
+                    encoding: 'base58',
                 },
             });
         }
-        const collateralExchangeRates = new utils_1.PubkeyHashMap();
-        const cumulativeBorrowRates = new utils_1.PubkeyHashMap();
+        const collateralExchangeRates = new Map();
+        const cumulativeBorrowRates = new Map();
         const [slot, obligations] = await Promise.all([
-            this.connection.getSlot(),
-            (0, utils_3.getProgramAccounts)(this.connection, this.programId, zero_padding_1.ObligationZP.layout.span + 8, {
-                commitment: this.connection.commitment ?? 'processed',
-                filters,
-                dataSlice: { offset: 0, length: zero_padding_1.ObligationZP.layout.span + 8 }, // truncate the padding
-            }),
+            this.rpc.getSlot().send(),
+            (0, utils_1.getProgramAccounts)(this.rpc, this.programId, zero_padding_1.ObligationZP.layout.span + 8, filters, { offset: 0, length: zero_padding_1.ObligationZP.layout.span + 8 } // truncate the padding
+            ),
         ]);
         return obligations.map((obligation) => {
-            if (obligation.account === null) {
+            if (obligation.data === null) {
                 throw new Error('Invalid account');
             }
-            const obligationAccount = zero_padding_1.ObligationZP.decode(obligation.account.data);
+            const obligationAccount = zero_padding_1.ObligationZP.decode(obligation.data);
             if (!obligationAccount) {
                 throw Error('Could not parse obligation.');
             }
             obligation_1.KaminoObligation.addRatesForObligation(this, obligationAccount, collateralExchangeRates, cumulativeBorrowRates, slot);
-            return new obligation_1.KaminoObligation(this, obligation.pubkey, obligationAccount, collateralExchangeRates, cumulativeBorrowRates);
+            return new obligation_1.KaminoObligation(this, obligation.address, obligationAccount, collateralExchangeRates, cumulativeBorrowRates);
         });
     }
     /**
@@ -438,42 +439,47 @@ class KaminoMarket {
     async *batchGetAllObligationsForMarket(tag) {
         const filters = [
             {
-                dataSize: accounts_1.Obligation.layout.span + 8,
+                dataSize: BigInt(accounts_1.Obligation.layout.span + 8),
             },
             {
                 memcmp: {
-                    offset: 32,
-                    bytes: this.address,
+                    offset: 32n,
+                    bytes: this.address.toString(),
+                    encoding: 'base58',
                 },
             },
         ];
         if (tag !== undefined) {
             filters.push({
                 memcmp: {
-                    offset: 8,
-                    bytes: bs58_1.default.encode(new anchor_1.BN(tag).toBuffer()),
+                    offset: 8n,
+                    bytes: base58Decoder.decode(new bn_js_1.default(tag).toBuffer()),
+                    encoding: 'base58',
                 },
             });
         }
-        const collateralExchangeRates = new utils_1.PubkeyHashMap();
-        const cumulativeBorrowRates = new utils_1.PubkeyHashMap();
+        const collateralExchangeRates = new Map();
+        const cumulativeBorrowRates = new Map();
         const [obligationPubkeys, slot] = await Promise.all([
-            this.connection.getProgramAccounts(this.programId, {
+            this.rpc
+                .getProgramAccounts(this.programId, {
                 filters,
+                encoding: 'base64',
                 dataSlice: { offset: 0, length: 0 },
-            }),
-            this.connection.getSlot(),
+            })
+                .send(),
+            this.rpc.getSlot().send(),
         ]);
         for (const batch of (0, kliquidity_sdk_1.chunks)(obligationPubkeys.map((x) => x.pubkey), 100)) {
-            const obligationAccounts = await this.connection.getMultipleAccountsInfo(batch);
+            const obligationAccounts = await this.rpc.getMultipleAccounts(batch, { encoding: 'base64' }).send();
             const obligationsBatch = [];
-            for (let i = 0; i < obligationAccounts.length; i++) {
-                const obligation = obligationAccounts[i];
+            for (let i = 0; i < obligationAccounts.value.length; i++) {
+                const obligation = obligationAccounts.value[i];
                 const pubkey = batch[i];
                 if (obligation === null) {
                     continue;
                 }
-                const obligationAccount = accounts_1.Obligation.decode(obligation.data);
+                const obligationAccount = accounts_1.Obligation.decode(buffer_1.Buffer.from(obligation.data[0], 'base64'));
                 if (!obligationAccount) {
                     throw Error(`Could not decode obligation ${pubkey.toString()}`);
                 }
@@ -485,37 +491,42 @@ class KaminoMarket {
     }
     async getAllObligationsByTag(tag, market) {
         const [slot, obligations] = await Promise.all([
-            this.connection.getSlot(),
-            this.connection.getProgramAccounts(this.programId, {
+            this.rpc.getSlot().send(),
+            this.rpc
+                .getProgramAccounts(this.programId, {
                 filters: [
                     {
-                        dataSize: accounts_1.Obligation.layout.span + 8,
+                        dataSize: BigInt(accounts_1.Obligation.layout.span + 8),
                     },
                     {
                         memcmp: {
-                            offset: 8,
-                            bytes: bs58_1.default.encode(new anchor_1.BN(tag).toBuffer()),
+                            offset: 8n,
+                            bytes: base58Decoder.decode(new bn_js_1.default(tag).toBuffer()),
+                            encoding: 'base58',
                         },
                     },
                     {
                         memcmp: {
-                            offset: 32,
-                            bytes: market.toBase58(),
+                            offset: 32n,
+                            bytes: market.toString(),
+                            encoding: 'base58',
                         },
                     },
                 ],
-            }),
+                encoding: 'base64',
+            })
+                .send(),
         ]);
-        const collateralExchangeRates = new utils_1.PubkeyHashMap();
-        const cumulativeBorrowRates = new utils_1.PubkeyHashMap();
+        const collateralExchangeRates = new Map();
+        const cumulativeBorrowRates = new Map();
         return obligations.map((obligation) => {
             if (obligation.account === null) {
                 throw new Error('Invalid account');
             }
-            if (!obligation.account.owner.equals(this.programId)) {
+            if (obligation.account.owner !== this.programId) {
                 throw new Error("account doesn't belong to this program");
             }
-            const obligationAccount = accounts_1.Obligation.decode(obligation.account.data);
+            const obligationAccount = accounts_1.Obligation.decode(buffer_1.Buffer.from(obligation.account.data[0], 'base64'));
             if (!obligationAccount) {
                 throw Error('Could not parse obligation.');
             }
@@ -527,37 +538,42 @@ class KaminoMarket {
         const finalObligations = [];
         for (let i = 0; i < utils_1.DEPOSITS_LIMIT; i++) {
             const [slot, obligations] = await Promise.all([
-                this.connection.getSlot(),
-                this.connection.getProgramAccounts(this.programId, {
+                this.rpc.getSlot().send(),
+                this.rpc
+                    .getProgramAccounts(this.programId, {
                     filters: [
                         {
-                            dataSize: accounts_1.Obligation.layout.span + 8,
+                            dataSize: BigInt(accounts_1.Obligation.layout.span + 8),
                         },
                         {
                             memcmp: {
-                                offset: 96 + 136 * i,
-                                bytes: reserve.toBase58(),
+                                offset: 96n + 136n * BigInt(i),
+                                bytes: reserve.toString(),
+                                encoding: 'base58',
                             },
                         },
                         {
                             memcmp: {
-                                offset: 32,
-                                bytes: this.address,
+                                offset: 32n,
+                                bytes: this.address.toString(),
+                                encoding: 'base58',
                             },
                         },
                     ],
-                }),
+                    encoding: 'base64',
+                })
+                    .send(),
             ]);
-            const collateralExchangeRates = new utils_1.PubkeyHashMap();
-            const cumulativeBorrowRates = new utils_1.PubkeyHashMap();
+            const collateralExchangeRates = new Map();
+            const cumulativeBorrowRates = new Map();
             const obligationsBatch = obligations.map((obligation) => {
                 if (obligation.account === null) {
                     throw new Error('Invalid account');
                 }
-                if (!obligation.account.owner.equals(this.programId)) {
+                if (obligation.account.owner !== this.programId) {
                     throw new Error("account doesn't belong to this program");
                 }
-                const obligationAccount = accounts_1.Obligation.decode(obligation.account.data);
+                const obligationAccount = accounts_1.Obligation.decode(buffer_1.Buffer.from(obligation.account.data[0], 'base64'));
                 if (!obligationAccount) {
                     throw Error('Could not parse obligation.');
                 }
@@ -568,46 +584,49 @@ class KaminoMarket {
         }
         return finalObligations;
     }
-    async getAllUserObligations(user, commitment = this.connection.commitment) {
+    async getAllUserObligations(user, commitment = 'processed') {
         const [currentSlot, obligations] = await Promise.all([
-            this.connection.getSlot(),
-            this.connection.getProgramAccounts(this.programId, {
+            this.rpc.getSlot().send(),
+            this.rpc
+                .getProgramAccounts(this.programId, {
                 filters: [
                     {
-                        dataSize: accounts_1.Obligation.layout.span + 8,
+                        dataSize: BigInt(accounts_1.Obligation.layout.span + 8),
                     },
                     {
                         memcmp: {
-                            offset: 0,
-                            bytes: bs58_2.default.encode(accounts_1.Obligation.discriminator),
+                            offset: 0n,
+                            bytes: base58Decoder.decode(accounts_1.Obligation.discriminator),
+                            encoding: 'base58',
                         },
                     },
                     {
                         memcmp: {
-                            offset: 64,
-                            bytes: user.toBase58(),
+                            offset: 64n,
+                            bytes: user.toString(),
+                            encoding: 'base58',
                         },
                     },
                     {
                         memcmp: {
-                            offset: 32,
-                            bytes: this.address,
+                            offset: 32n,
+                            bytes: this.address.toString(),
+                            encoding: 'base58',
                         },
                     },
                 ],
+                encoding: 'base64',
                 commitment,
-            }),
+            })
+                .send(),
         ]);
-        const collateralExchangeRates = new utils_1.PubkeyHashMap();
-        const cumulativeBorrowRates = new utils_1.PubkeyHashMap();
+        const collateralExchangeRates = new Map();
+        const cumulativeBorrowRates = new Map();
         return obligations.map((obligation) => {
-            if (obligation.account === null) {
-                throw new Error('Invalid account');
-            }
-            if (!obligation.account.owner.equals(this.programId)) {
+            if (obligation.account.owner !== this.programId) {
                 throw new Error("account doesn't belong to this program");
             }
-            const obligationAccount = accounts_1.Obligation.decode(obligation.account.data);
+            const obligationAccount = accounts_1.Obligation.decode(buffer_1.Buffer.from(obligation.account.data[0], 'base64'));
             if (!obligationAccount) {
                 throw Error('Could not parse obligation.');
             }
@@ -617,20 +636,20 @@ class KaminoMarket {
     }
     async getAllUserObligationsForReserve(user, reserve) {
         const obligationAddresses = [];
-        obligationAddresses.push(new utils_1.VanillaObligation(this.programId).toPda(this.getAddress(), user));
-        const targetReserve = new utils_1.PubkeyHashMap(Array.from(this.reserves.entries())).get(reserve);
+        obligationAddresses.push(await new utils_1.VanillaObligation(this.programId).toPda(this.getAddress(), user));
+        const targetReserve = new Map(Array.from(this.reserves.entries())).get(reserve);
         if (!targetReserve) {
             throw Error('Could not find reserve.');
         }
         for (const [key, kaminoReserve] of this.reserves) {
-            if (targetReserve.address.equals(key)) {
+            if (targetReserve.address === key) {
                 // skip target reserve
                 continue;
             }
-            obligationAddresses.push(new utils_1.MultiplyObligation(targetReserve.getLiquidityMint(), kaminoReserve.getLiquidityMint(), this.programId).toPda(this.getAddress(), user));
-            obligationAddresses.push(new utils_1.MultiplyObligation(kaminoReserve.getLiquidityMint(), targetReserve.getLiquidityMint(), this.programId).toPda(this.getAddress(), user));
-            obligationAddresses.push(new utils_1.LeverageObligation(targetReserve.getLiquidityMint(), kaminoReserve.getLiquidityMint(), this.programId).toPda(this.getAddress(), user));
-            obligationAddresses.push(new utils_1.LeverageObligation(kaminoReserve.getLiquidityMint(), targetReserve.getLiquidityMint(), this.programId).toPda(this.getAddress(), user));
+            obligationAddresses.push(await new utils_1.MultiplyObligation(targetReserve.getLiquidityMint(), kaminoReserve.getLiquidityMint(), this.programId).toPda(this.getAddress(), user));
+            obligationAddresses.push(await new utils_1.MultiplyObligation(kaminoReserve.getLiquidityMint(), targetReserve.getLiquidityMint(), this.programId).toPda(this.getAddress(), user));
+            obligationAddresses.push(await new utils_1.LeverageObligation(targetReserve.getLiquidityMint(), kaminoReserve.getLiquidityMint(), this.programId).toPda(this.getAddress(), user));
+            obligationAddresses.push(await new utils_1.LeverageObligation(kaminoReserve.getLiquidityMint(), targetReserve.getLiquidityMint(), this.programId).toPda(this.getAddress(), user));
         }
         const batchSize = 100;
         const finalObligations = [];
@@ -639,12 +658,12 @@ class KaminoMarket {
             obligations.forEach((obligation) => {
                 if (obligation !== null) {
                     for (const deposits of obligation.deposits.keys()) {
-                        if (deposits.equals(reserve)) {
+                        if (deposits === reserve) {
                             finalObligations.push(obligation);
                         }
                     }
                     for (const borrows of obligation.borrows.keys()) {
-                        if (borrows.equals(reserve)) {
+                        if (borrows === reserve) {
                             finalObligations.push(obligation);
                         }
                     }
@@ -654,7 +673,7 @@ class KaminoMarket {
         return finalObligations;
     }
     async getUserVanillaObligation(user) {
-        const vanillaObligationAddress = new utils_1.VanillaObligation(this.programId).toPda(this.getAddress(), user);
+        const vanillaObligationAddress = await new utils_1.VanillaObligation(this.programId).toPda(this.getAddress(), user);
         const obligation = await this.getObligationByAddress(vanillaObligationAddress);
         if (!obligation) {
             throw new Error('Could not find vanilla obligation.');
@@ -663,12 +682,12 @@ class KaminoMarket {
     }
     isReserveInObligation(obligation, reserve) {
         for (const deposits of obligation.deposits.keys()) {
-            if (deposits.equals(reserve)) {
+            if (deposits === reserve) {
                 return true;
             }
         }
         for (const borrows of obligation.borrows.keys()) {
-            if (borrows.equals(reserve)) {
+            if (borrows === reserve) {
                 return true;
             }
         }
@@ -676,43 +695,46 @@ class KaminoMarket {
     }
     async getUserObligationsByTag(tag, user) {
         const [currentSlot, obligations] = await Promise.all([
-            this.connection.getSlot(),
-            this.connection.getProgramAccounts(this.programId, {
+            this.rpc.getSlot().send(),
+            this.rpc
+                .getProgramAccounts(this.programId, {
                 filters: [
                     {
-                        dataSize: accounts_1.Obligation.layout.span + 8,
+                        dataSize: BigInt(accounts_1.Obligation.layout.span + 8),
                     },
                     {
                         memcmp: {
-                            offset: 8,
-                            bytes: bs58_1.default.encode(new anchor_1.BN(tag).toBuffer()),
+                            offset: 8n,
+                            bytes: base58Decoder.decode(new bn_js_1.default(tag).toBuffer()),
+                            encoding: 'base58',
                         },
                     },
                     {
                         memcmp: {
-                            offset: 32,
-                            bytes: this.address,
+                            offset: 32n,
+                            bytes: this.address.toString(),
+                            encoding: 'base58',
                         },
                     },
                     {
                         memcmp: {
-                            offset: 64,
-                            bytes: user.toBase58(),
+                            offset: 64n,
+                            bytes: user.toString(),
+                            encoding: 'base58',
                         },
                     },
                 ],
-            }),
+                encoding: 'base64',
+            })
+                .send(),
         ]);
-        const collateralExchangeRates = new utils_1.PubkeyHashMap();
-        const cumulativeBorrowRates = new utils_1.PubkeyHashMap();
+        const collateralExchangeRates = new Map();
+        const cumulativeBorrowRates = new Map();
         return obligations.map((obligation) => {
-            if (obligation.account === null) {
-                throw new Error('Invalid account');
-            }
-            if (!obligation.account.owner.equals(this.programId)) {
+            if (obligation.account.owner !== this.programId) {
                 throw new Error("account doesn't belong to this program");
             }
-            const obligationAccount = accounts_1.Obligation.decode(obligation.account.data);
+            const obligationAccount = accounts_1.Obligation.decode(buffer_1.Buffer.from(obligation.account.data[0], 'base64'));
             if (!obligationAccount) {
                 throw Error('Could not parse obligation.');
             }
@@ -734,38 +756,42 @@ class KaminoMarket {
      * @return [address, userMetadataState] - The address of the user metadata PDA and the user metadata state, or null if it doesn't exist
      */
     async getUserMetadata(user) {
-        const [address, _bump] = (0, utils_1.userMetadataPda)(user, this.programId);
-        const userMetadata = await accounts_1.UserMetadata.fetch(this.connection, address, this.programId);
+        const [address, _bump] = await (0, utils_1.userMetadataPda)(user, this.programId);
+        const userMetadata = await accounts_1.UserMetadata.fetch(this.rpc, address, this.programId);
         return [address, userMetadata];
     }
     async getReferrerTokenStateForReserve(referrer, reserve) {
-        const [address, _bump] = (0, utils_1.referrerTokenStatePda)(referrer, reserve, this.programId);
-        const referrerTokenState = await accounts_1.ReferrerTokenState.fetch(this.connection, address, this.programId);
+        const address = await (0, utils_1.referrerTokenStatePda)(referrer, reserve, this.programId);
+        const referrerTokenState = await accounts_1.ReferrerTokenState.fetch(this.rpc, address, this.programId);
         return [address, referrerTokenState];
     }
     async getAllReferrerTokenStates(referrer) {
-        const referrerTokenStates = await this.connection.getProgramAccounts(this.programId, {
+        const referrerTokenStates = await this.rpc
+            .getProgramAccounts(this.programId, {
             filters: [
                 {
-                    dataSize: accounts_1.ReferrerTokenState.layout.span + 8,
+                    dataSize: BigInt(accounts_1.ReferrerTokenState.layout.span + 8),
                 },
                 {
                     memcmp: {
-                        offset: 8,
-                        bytes: referrer.toBase58(),
+                        offset: 8n,
+                        bytes: referrer.toString(),
+                        encoding: 'base58',
                     },
                 },
             ],
-        });
-        const referrerTokenStatesForMints = new utils_1.PubkeyHashMap();
+            encoding: 'base64',
+        })
+            .send();
+        const referrerTokenStatesForMints = new Map();
         referrerTokenStates.forEach((referrerTokenState) => {
             if (referrerTokenState.account === null) {
                 throw new Error('Invalid account');
             }
-            if (!referrerTokenState.account.owner.equals(this.programId)) {
+            if (referrerTokenState.account.owner !== this.programId) {
                 throw new Error("account doesn't belong to this program");
             }
-            const referrerTokenStateDecoded = accounts_1.ReferrerTokenState.decode(referrerTokenState.account.data);
+            const referrerTokenStateDecoded = accounts_1.ReferrerTokenState.decode(buffer_1.Buffer.from(referrerTokenState.account.data[0], 'base64'));
             if (!referrerTokenStateDecoded) {
                 throw Error('Could not parse obligation.');
             }
@@ -775,7 +801,7 @@ class KaminoMarket {
     }
     async getAllReferrerFeesUnclaimed(referrer) {
         const referrerTokenStatesForMints = await this.getAllReferrerTokenStates(referrer);
-        const referrerFeesUnclaimedForMints = new utils_1.PubkeyHashMap();
+        const referrerFeesUnclaimedForMints = new Map();
         for (const mint of referrerTokenStatesForMints.keys()) {
             referrerFeesUnclaimedForMints.set(mint, new fraction_1.Fraction(referrerTokenStatesForMints.get(mint).amountUnclaimedSf).toDecimal());
         }
@@ -791,39 +817,46 @@ class KaminoMarket {
     }
     async getAllReferrerFeesCumulative(referrer) {
         const referrerTokenStatesForMints = await this.getAllReferrerTokenStates(referrer);
-        const referrerFeesCumulativeForMints = new utils_1.PubkeyHashMap();
+        const referrerFeesCumulativeForMints = new Map();
         for (const mint of referrerTokenStatesForMints.keys()) {
             referrerFeesCumulativeForMints.set(mint, new fraction_1.Fraction(referrerTokenStatesForMints.get(mint).amountUnclaimedSf).toDecimal());
         }
         return referrerFeesCumulativeForMints;
     }
-    async getReferrerUrl(baseUrl, referrer) {
-        return baseUrl + this.encodeReferrer(referrer);
-    }
-    async getReferrerFromUrl(baseUrl, url) {
-        return this.decodeReferrer(url.split(baseUrl)[1]);
+    getReferrerUrl(baseUrl, referrer) {
+        return `${baseUrl}${referrer.toString()}`;
     }
-    async encodeReferrer(referrer) {
-        return bs58_2.default.encode(referrer.toBuffer());
+    getReferrerFromUrl(baseUrl, url) {
+        return (0, kit_1.address)(url.split(baseUrl)[1]);
     }
-    async decodeReferrer(encoded_referrer) {
-        const referrer_buffer = bs58_2.default.decode(encoded_referrer);
-        return new web3_js_1.PublicKey(referrer_buffer.toString());
+    /**
+     * Get the underlying rpc passed when instantiating this market
+     * @return rpc
+     */
+    getRpc() {
+        return this.rpc;
     }
     /**
-     * Get the underlying connection passed when instantiating this market
-     * @return connection
+     * Get all scope OraclePrices accounts for all market reserves
+     * @param scope
      */
-    getConnection() {
-        return this.connection;
+    async getReserveOraclePrices(scope) {
+        const reserveOraclePrices = new Map();
+        const oraclePrices = await scope.getMultipleOraclePrices(Array.from(this.scopeFeeds.keys()));
+        const oraclePriceMap = new Map();
+        for (const [feed, account] of oraclePrices) {
+            oraclePriceMap.set(feed, account);
+        }
+        for (const [reserveAddress, reserve] of this.reserves) {
+            reserveOraclePrices.set(reserveAddress, oraclePriceMap.get(reserve.state.config.tokenInfo.scopeConfiguration.priceFeed));
+        }
+        return reserveOraclePrices;
     }
     /**
      * Get all Scope prices used by all the market reserves
      */
-    async getAllScopePrices(scope, oraclePrices) {
-        if (!oraclePrices) {
-            oraclePrices = await scope.getOraclePrices();
-        }
+    async getAllScopePrices(scope) {
+        const allOraclePrices = await this.getReserveOraclePrices(scope);
         const spot = {};
         const twaps = {};
         for (const reserve of this.reserves.values()) {
@@ -832,11 +865,12 @@ class KaminoMarket {
             const oracle = reserve.state.config.tokenInfo.scopeConfiguration.priceFeed;
             const chain = reserve.state.config.tokenInfo.scopeConfiguration.priceChain;
             const twapChain = reserve.state.config.tokenInfo.scopeConfiguration.twapChain.filter((x) => x > 0);
-            if (oracle && (0, utils_1.isNotNullPubkey)(oracle) && chain && scope_sdk_1.Scope.isScopeChainValid(chain)) {
+            const oraclePrices = allOraclePrices.get(reserve.address);
+            if (oraclePrices && oracle && (0, utils_1.isNotNullPubkey)(oracle) && chain && scope_sdk_1.Scope.isScopeChainValid(chain)) {
                 const spotPrice = await scope.getPriceFromChain(chain, oraclePrices);
                 spot[tokenMint] = { price: spotPrice.price, name: tokenName };
             }
-            if (oracle && (0, utils_1.isNotNullPubkey)(oracle) && twapChain && scope_sdk_1.Scope.isScopeChainValid(twapChain)) {
+            if (oraclePrices && oracle && (0, utils_1.isNotNullPubkey)(oracle) && twapChain && scope_sdk_1.Scope.isScopeChainValid(twapChain)) {
                 const twap = await scope.getPriceFromChain(twapChain, oraclePrices);
                 twaps[tokenMint] = { price: twap.price, name: tokenName };
             }
@@ -852,11 +886,10 @@ class KaminoMarket {
             pyth: { spot: {}, twap: {} },
             switchboard: { spot: {}, twap: {} },
         };
-        const allOracleAccounts = await (0, utils_1.getAllOracleAccounts)(this.connection, this.getReserves().map((x) => x.state));
-        const pythCache = new utils_1.PubkeyHashMap();
-        const switchboardCache = new utils_1.PubkeyHashMap();
-        const scopeCache = new utils_1.PubkeyHashMap();
-        const switchboardV2 = await sbv2_lite_1.default.loadMainnet(this.connection);
+        const allOracleAccounts = await (0, utils_1.getAllOracleAccounts)(this.rpc, this.getReserves().map((x) => x.state));
+        const pythCache = new Map();
+        const switchboardCache = new Map();
+        const scopeCache = new Map();
         for (const reserve of this.reserves.values()) {
             const tokenMint = reserve.getLiquidityMint().toString();
             const tokenName = reserve.getTokenSymbol();
@@ -879,9 +912,9 @@ class KaminoMarket {
             }
             if ((0, utils_1.isNotNullPubkey)(switchboardSpotOracle)) {
                 const switchboardPrices = {
-                    spot: (0, utils_1.cacheOrGetSwitchboardPrice)(switchboardSpotOracle, switchboardCache, allOracleAccounts, switchboardV2),
+                    spot: (0, utils_1.cacheOrGetSwitchboardPrice)(switchboardSpotOracle, switchboardCache, allOracleAccounts),
                     twap: (0, utils_1.isNotNullPubkey)(switchboardTwapOracle)
-                        ? (0, utils_1.cacheOrGetSwitchboardPrice)(switchboardTwapOracle, switchboardCache, allOracleAccounts, switchboardV2)
+                        ? (0, utils_1.cacheOrGetSwitchboardPrice)(switchboardTwapOracle, switchboardCache, allOracleAccounts)
                         : null,
                 };
                 this.setPriceIfExist(klendPrices.switchboard, switchboardPrices.spot, switchboardPrices.twap, tokenMint, tokenName);
@@ -890,14 +923,14 @@ class KaminoMarket {
         return klendPrices;
     }
     getCumulativeBorrowRatesByReserve(slot) {
-        const cumulativeBorrowRates = new utils_1.PubkeyHashMap();
+        const cumulativeBorrowRates = new Map();
         for (const reserve of this.reserves.values()) {
             cumulativeBorrowRates.set(reserve.address, reserve.getEstimatedCumulativeBorrowRate(slot, this.state.referralFeeBps));
         }
         return cumulativeBorrowRates;
     }
     getCollateralExchangeRatesByReserve(slot) {
-        const collateralExchangeRates = new utils_1.PubkeyHashMap();
+        const collateralExchangeRates = new Map();
         for (const reserve of this.reserves.values()) {
             collateralExchangeRates.set(reserve.address, reserve.getEstimatedCollateralExchangeRate(slot, this.state.referralFeeBps));
         }
@@ -923,10 +956,10 @@ class KaminoMarket {
                 continue;
             }
             elevationGroups.push({
-                collateralReserves: new utils_1.PublicKeySet([]),
-                collateralLiquidityMints: new utils_1.PublicKeySet([]),
+                collateralReserves: new Set([]),
+                collateralLiquidityMints: new Set([]),
                 debtReserve: elevationGroup.debtReserve,
-                debtLiquidityMint: web3_js_1.PublicKey.default,
+                debtLiquidityMint: utils_1.DEFAULT_PUBLIC_KEY,
                 elevationGroup: elevationGroup.id,
                 maxReservesAsCollateral: elevationGroup.maxReservesAsCollateral,
             });
@@ -942,7 +975,7 @@ class KaminoMarket {
                 }
                 const elevationGroupDescription = elevationGroups[elevationGroupId - 1];
                 if (elevationGroupDescription) {
-                    if (reserveAddress.equals(elevationGroupDescription.debtReserve)) {
+                    if (reserveAddress === elevationGroupDescription.debtReserve) {
                         elevationGroups[elevationGroupId - 1].debtLiquidityMint = reserveLiquidityMint;
                     }
                     else {
@@ -961,75 +994,73 @@ class KaminoMarket {
     getElevationGroupsForMintsCombination(collLiquidityMints, debtLiquidityMint) {
         const allElevationGroups = this.getMarketElevationGroupDescriptions();
         return allElevationGroups.filter((elevationGroupDescription) => {
-            return (collLiquidityMints.every((mint) => elevationGroupDescription.collateralLiquidityMints.contains(mint)) &&
-                (debtLiquidityMint == undefined || debtLiquidityMint.equals(elevationGroupDescription.debtLiquidityMint)));
+            return (collLiquidityMints.every((mint) => elevationGroupDescription.collateralLiquidityMints.has(mint)) &&
+                (debtLiquidityMint == undefined || debtLiquidityMint === elevationGroupDescription.debtLiquidityMint));
         });
     }
     /* Returns all elevation groups for a given combination of reserves, except the default one */
     getElevationGroupsForReservesCombination(collReserves, debtReserve) {
         const allElevationGroups = this.getMarketElevationGroupDescriptions();
         return allElevationGroups.filter((elevationGroupDescription) => {
-            return (collReserves.every((mint) => elevationGroupDescription.collateralReserves.contains(mint)) &&
-                (debtReserve == undefined || debtReserve.equals(elevationGroupDescription.debtReserve)));
+            return (collReserves.every((mint) => elevationGroupDescription.collateralReserves.has(mint)) &&
+                (debtReserve == undefined || debtReserve === elevationGroupDescription.debtReserve));
         });
     }
 }
 exports.KaminoMarket = KaminoMarket;
-async function getReservesForMarket(marketAddress, connection, programId, recentSlotDurationMs) {
-    const reserves = await connection.getProgramAccounts(programId, {
+async function getReservesForMarket(marketAddress, rpc, programId, recentSlotDurationMs) {
+    const reserves = await rpc
+        .getProgramAccounts(programId, {
         filters: [
             {
-                dataSize: accounts_1.Reserve.layout.span + 8,
+                dataSize: BigInt(accounts_1.Reserve.layout.span + 8),
             },
             {
                 memcmp: {
-                    offset: 32,
-                    bytes: marketAddress.toBase58(),
+                    offset: 32n,
+                    bytes: marketAddress.toString(),
+                    encoding: 'base58',
                 },
             },
         ],
-    });
+        encoding: 'base64',
+    })
+        .send();
     const deserializedReserves = reserves.map((reserve) => {
         if (reserve.account === null) {
-            throw new Error(`Reserve account ${reserve.pubkey.toBase58()} does not exist`);
+            throw new Error(`Reserve account ${reserve.pubkey} does not exist`);
         }
-        const reserveAccount = accounts_1.Reserve.decode(reserve.account.data);
+        const reserveAccount = accounts_1.Reserve.decode(buffer_1.Buffer.from(reserve.account.data[0], 'base64'));
         if (!reserveAccount) {
-            throw Error(`Could not parse reserve ${reserve.pubkey.toBase58()}`);
+            throw Error(`Could not parse reserve ${reserve.pubkey}`);
         }
         return reserveAccount;
     });
-    const allBuffers = reserves.map((reserve) => reserve.account);
-    const reservesAndOracles = await (0, utils_1.getTokenOracleData)(connection, deserializedReserves);
-    const reservesByAddress = new utils_1.PubkeyHashMap();
+    const reservesAndOracles = await (0, utils_1.getTokenOracleData)(rpc, deserializedReserves);
+    const reservesByAddress = new Map();
     reservesAndOracles.forEach(([reserve, oracle], index) => {
         if (!oracle) {
             throw Error(`Could not find oracle for ${(0, utils_2.parseTokenSymbol)(reserve.config.tokenInfo.name)} reserve`);
         }
-        const kaminoReserve = reserve_1.KaminoReserve.initialize(allBuffers[index], reserves[index].pubkey, reserve, oracle, connection, recentSlotDurationMs);
+        const kaminoReserve = reserve_1.KaminoReserve.initialize(reserves[index].pubkey, reserve, oracle, rpc, recentSlotDurationMs);
         reservesByAddress.set(kaminoReserve.address, kaminoReserve);
     });
     return reservesByAddress;
 }
-async function getSingleReserve(reservePk, connection, recentSlotDurationMs, accountData) {
-    const reserve = accountData ? accountData : await connection.getAccountInfo(reservePk);
+async function getSingleReserve(reservePk, rpc, recentSlotDurationMs, reserveData) {
+    const reserve = reserveData ?? (await accounts_1.Reserve.fetch(rpc, reservePk));
     if (reserve === null) {
-        throw new Error(`Reserve account ${reservePk.toBase58()} does not exist`);
+        throw new Error(`Reserve account ${reservePk} does not exist`);
     }
-    const reserveAccount = accounts_1.Reserve.decode(reserve.data);
-    if (!reserveAccount) {
-        throw Error(`Could not parse reserve ${reservePk.toBase58()}`);
-    }
-    const reservesAndOracles = await (0, utils_1.getTokenOracleData)(connection, [reserveAccount]);
-    const [reserveState, oracle] = reservesAndOracles[0];
+    const reservesAndOracles = await (0, utils_1.getTokenOracleData)(rpc, [reserve]);
+    const [, oracle] = reservesAndOracles[0];
     if (!oracle) {
-        throw Error(`Could not find oracle for ${(0, utils_2.parseTokenSymbol)(reserveState.config.tokenInfo.name)} reserve`);
+        throw Error(`Could not find oracle for ${(0, utils_2.parseTokenSymbol)(reserve.config.tokenInfo.name)} reserve`);
     }
-    const kaminoReserve = reserve_1.KaminoReserve.initialize(reserve, reservePk, reserveState, oracle, connection, recentSlotDurationMs);
-    return kaminoReserve;
+    return reserve_1.KaminoReserve.initialize(reservePk, reserve, oracle, rpc, recentSlotDurationMs);
 }
 function getReservesActive(reserves) {
-    const reservesActive = new utils_1.PubkeyHashMap();
+    const reservesActive = new Map();
     for (const [key, reserve] of reserves) {
         if (reserve.state.config.status === 0) {
             reservesActive.set(key, reserve);
@@ -1037,55 +1068,42 @@ function getReservesActive(reserves) {
     }
     return reservesActive;
 }
+/**
+ *
+ * @param kaminoMarket
+ * @param reserves
+ */
 function getTokenIdsForScopeRefresh(kaminoMarket, reserves) {
-    const tokenIds = [];
+    const tokenIds = new Map();
     for (const reserveAddress of reserves) {
         const reserve = kaminoMarket.getReserveByAddress(reserveAddress);
         if (!reserve) {
-            throw new Error(`Reserve not found for reserve ${reserveAddress.toBase58()}`);
+            throw new Error(`Reserve not found for reserve ${reserveAddress}`);
         }
-        if (!reserve.state.config.tokenInfo.scopeConfiguration.priceFeed.equals(web3_js_1.PublicKey.default)) {
+        const { scopeConfiguration } = reserve.state.config.tokenInfo;
+        if (scopeConfiguration.priceFeed !== utils_1.DEFAULT_PUBLIC_KEY) {
             let x = 0;
-            while (reserve.state.config.tokenInfo.scopeConfiguration.priceChain[x] !== scope_sdk_1.U16_MAX) {
-                tokenIds.push(reserve.state.config.tokenInfo.scopeConfiguration.priceChain[x]);
+            while (scopeConfiguration.priceChain[x] !== scope_sdk_1.U16_MAX) {
+                (0, utils_1.setOrAppend)(tokenIds, scopeConfiguration.priceFeed, scopeConfiguration.priceChain[x]);
                 x++;
             }
             x = 0;
-            while (reserve.state.config.tokenInfo.scopeConfiguration.twapChain[x] !== scope_sdk_1.U16_MAX) {
-                tokenIds.push(reserve.state.config.tokenInfo.scopeConfiguration.twapChain[x]);
+            while (scopeConfiguration.twapChain[x] !== scope_sdk_1.U16_MAX) {
+                (0, utils_1.setOrAppend)(tokenIds, scopeConfiguration.priceFeed, scopeConfiguration.twapChain[x]);
                 x++;
             }
         }
     }
-    return tokenIds;
-}
-async function getReserveFromMintAndMarket(connection, market, mint, programId = programId_1.PROGRAM_ID) {
-    const reserve = (await connection.getProgramAccounts(programId, {
-        filters: [
-            {
-                dataSize: accounts_1.Reserve.layout.span + 8,
-            },
-            {
-                memcmp: {
-                    offset: 32,
-                    bytes: market.address,
-                },
-            },
-            {
-                memcmp: {
-                    offset: 128,
-                    bytes: mint,
-                },
-            },
-        ],
-    }))[0];
-    if (reserve.account === null) {
-        throw new Error('Invalid account');
+    //TODO: remove code below
+    // - currently Scope program does not allow multiple refreshPricesList instructions in one tx
+    // - temporary fix is to only refresh one scope feed at this time
+    const firstFeed = tokenIds.entries().next();
+    tokenIds.clear();
+    if (!firstFeed.done) {
+        const [key, value] = firstFeed.value;
+        tokenIds.set(key, value);
     }
-    if (!reserve.account.owner.equals(programId)) {
-        throw new Error("Account doesn't belong to this program");
-    }
-    return [reserve.pubkey, reserve.account];
+    return tokenIds;
 }
 const lamportsToNumberDecimal = (amount, decimals) => {
     const factor = 10 ** decimals;