@kamino-finance/klend-sdk 6.0.4 → 6.0.5-beta.0

package/dist/classes/market.js

@@ -8,50 +8,61 @@ exports.getReservesForMarket = getReservesForMarket;
 exports.getSingleReserve = getSingleReserve;
 exports.getReservesActive = getReservesActive;
 exports.getTokenIdsForScopeRefresh = getTokenIdsForScopeRefresh;
-const kit_1 = require("@solana/kit");
+exports.getReserveFromMintAndMarket = getReserveFromMintAndMarket;
+const web3_js_1 = require("@solana/web3.js");
 const obligation_1 = require("./obligation");
 const reserve_1 = require("./reserve");
-const accounts_1 = require("../@codegen/klend/accounts");
+const accounts_1 = require("../idl_codegen/accounts");
 const utils_1 = require("../utils");
-const bn_js_1 = __importDefault(require("bn.js"));
+const bs58_1 = __importDefault(require("bs58"));
+const anchor_1 = require("@coral-xyz/anchor");
 const decimal_js_1 = __importDefault(require("decimal.js"));
 const farms_sdk_1 = require("@kamino-finance/farms-sdk");
-const programId_1 = require("../@codegen/klend/programId");
+const programId_1 = require("../idl_codegen/programId");
+const bs58_2 = __importDefault(require("bs58"));
 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 zero_padding_1 = require("../@codegen/klend/zero_padding");
+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 validations_1 = require("../utils/validations");
-const buffer_1 = require("buffer");
-const base58Decoder = (0, kit_1.getBase58Decoder)();
 class KaminoMarket {
-    rpc;
+    connection;
     address;
     state;
     reserves;
     reservesActive;
     programId;
     recentSlotDurationMs;
-    constructor(rpc, state, marketAddress, reserves, recentSlotDurationMs, programId = programId_1.PROGRAM_ID) {
+    // key = scope feed (oracle prices) pubkey
+    // value = reserve pubkey
+    reserveScopeFeeds;
+    constructor(connection, state, marketAddress, reserves, recentSlotDurationMs, programId = programId_1.PROGRAM_ID) {
         this.address = marketAddress;
-        this.rpc = rpc;
+        this.connection = connection;
         this.state = state;
         this.reserves = reserves;
         this.reservesActive = getReservesActive(this.reserves);
         this.programId = programId;
         this.recentSlotDurationMs = recentSlotDurationMs;
+        this.reserveScopeFeeds = new utils_1.PubkeyHashMap(Array.from(this.reserves.values())
+            .filter((r) => (0, utils_1.isNotNullPubkey)(r.state.config.tokenInfo.scopeConfiguration.priceFeed))
+            .map((r) => [r.address, r.state.config.tokenInfo.scopeConfiguration.priceFeed]));
     }
     /**
      * Load a new market with all of its associated reserves
-     * @param rpc
+     * @param connection
      * @param marketAddress
      * @param recentSlotDurationMs
      * @param programId
      * @param withReserves
+     * @param setupLocalTest
+     * @param withReserves
      */
-    static async load(rpc, marketAddress, recentSlotDurationMs, programId = programId_1.PROGRAM_ID, withReserves = true) {
-        const market = await accounts_1.LendingMarket.fetch(rpc, marketAddress, programId);
+    static async load(connection, marketAddress, recentSlotDurationMs, programId = programId_1.PROGRAM_ID, withReserves = true) {
+        const market = await accounts_1.LendingMarket.fetch(connection, marketAddress, programId);
         if (market === null) {
             return null;
         }
@@ -59,24 +70,24 @@ class KaminoMarket {
             throw new Error('Recent slot duration cannot be 0');
         }
         const reserves = withReserves
-            ? await getReservesForMarket(marketAddress, rpc, programId, recentSlotDurationMs)
+            ? await getReservesForMarket(marketAddress, connection, programId, recentSlotDurationMs)
             : new Map();
-        return new KaminoMarket(rpc, market, marketAddress, reserves, recentSlotDurationMs, programId);
+        return new KaminoMarket(connection, market, marketAddress.toString(), reserves, recentSlotDurationMs, programId);
     }
     static loadWithReserves(connection, market, reserves, marketAddress, recentSlotDurationMs, programId = programId_1.PROGRAM_ID) {
-        return new KaminoMarket(connection, market, marketAddress, reserves, recentSlotDurationMs, programId);
+        return new KaminoMarket(connection, market, marketAddress.toString(), reserves, recentSlotDurationMs, programId);
     }
     async reload() {
-        const market = await accounts_1.LendingMarket.fetch(this.rpc, this.getAddress(), this.programId);
+        const market = await accounts_1.LendingMarket.fetch(this.connection, this.getAddress(), this.programId);
         if (market === null) {
             return;
         }
         this.state = market;
-        this.reserves = await getReservesForMarket(this.getAddress(), this.rpc, this.programId, this.recentSlotDurationMs);
+        this.reserves = await getReservesForMarket(this.getAddress(), this.connection, this.programId, this.recentSlotDurationMs);
         this.reservesActive = getReservesActive(this.reserves);
     }
-    async reloadSingleReserve(reservePk, reserveData) {
-        const reserve = await getSingleReserve(reservePk, this.rpc, this.recentSlotDurationMs, reserveData);
+    async reloadSingleReserve(reservePk, accountData) {
+        const reserve = await getSingleReserve(reservePk, this.connection, this.recentSlotDurationMs, accountData);
         this.reserves.set(reservePk, reserve);
         this.reservesActive.set(reservePk, reserve);
     }
@@ -85,7 +96,7 @@ class KaminoMarket {
      * @return market address public key
      */
     getAddress() {
-        return this.address;
+        return new web3_js_1.PublicKey(this.address);
     }
     /**
      * Get a list of reserves for this market
@@ -113,8 +124,8 @@ class KaminoMarket {
      * Get the authority PDA of this market
      * @return market authority public key
      */
-    async getLendingMarketAuthority() {
-        return (await (0, utils_1.lendingMarketAuthPda)(this.getAddress(), this.programId))[0];
+    getLendingMarketAuthority() {
+        return (0, utils_1.lendingMarketAuthPda)(this.getAddress(), this.programId)[0];
     }
     getName() {
         return (0, utils_2.parseZeroPaddedUtf8)(this.state.name);
@@ -154,8 +165,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 bn_js_1.default(0)) &&
-            this.state.elevationGroups[item - 1].debtReserve === debtReserve.address);
+            collReserve.state.config.borrowLimitAgainstThisCollateralInElevationGroup[item - 1].gt(new anchor_1.BN(0)) &&
+            this.state.elevationGroups[item - 1].debtReserve.equals(debtReserve.address));
     }
     getMaxAndLiquidationLtvAndBorrowFactorForPair(collTokenMint, debtTokenMint) {
         const collReserve = this.getReserveByMint(collTokenMint);
@@ -213,12 +224,12 @@ class KaminoMarket {
             .filter((obligation) => obligation.refreshedStats.userTotalBorrow.gt(0) || obligation.refreshedStats.userTotalDeposit.gt(0))
             .reduce((acc, _obligation) => acc + 1, 0);
     }
-    async getObligationByWallet(Address, obligationType) {
+    async getObligationByWallet(publicKey, obligationType) {
         const { address } = this;
         if (!address) {
             throw Error('Market must be initialized to call initialize.');
         }
-        const obligationAddress = await obligationType.toPda(this.getAddress(), Address);
+        const obligationAddress = obligationType.toPda(this.getAddress(), publicKey);
         return obligation_1.KaminoObligation.load(this, obligationAddress);
     }
     /**
@@ -231,27 +242,25 @@ class KaminoMarket {
     }
     async loadReserves() {
         const addresses = [...this.reserves.keys()];
-        const reserveAccounts = await this.rpc
-            .getMultipleAccounts(addresses, { commitment: 'processed', encoding: 'base64' })
-            .send();
-        const deserializedReserves = reserveAccounts.value.map((reserve, i) => {
+        const reserveAccounts = await this.connection.getMultipleAccountsInfo(addresses, 'processed');
+        const deserializedReserves = reserveAccounts.map((reserve, i) => {
             if (reserve === null) {
                 // maybe reuse old here
-                throw new Error(`Reserve account ${addresses[i]} was not found`);
+                throw new Error(`Reserve account ${addresses[i].toBase58()} was not found`);
             }
-            const reserveAccount = accounts_1.Reserve.decode(buffer_1.Buffer.from(reserve.data[0], 'base64'));
+            const reserveAccount = accounts_1.Reserve.decode(reserve.data);
             if (!reserveAccount) {
-                throw Error(`Could not parse reserve ${addresses[i]}`);
+                throw Error(`Could not parse reserve ${addresses[i].toBase58()}`);
             }
             return reserveAccount;
         });
-        const reservesAndOracles = await (0, utils_1.getTokenOracleData)(this.getRpc(), deserializedReserves);
-        const kaminoReserves = new Map();
+        const reservesAndOracles = await (0, utils_1.getTokenOracleData)(this.connection, deserializedReserves);
+        const kaminoReserves = new utils_1.PubkeyHashMap();
         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(addresses[index], reserve, oracle, this.rpc, this.recentSlotDurationMs);
+            const kaminoReserve = reserve_1.KaminoReserve.initialize(reserveAccounts[index], addresses[index], reserve, oracle, this.connection, this.recentSlotDurationMs);
             kaminoReserves.set(kaminoReserve.address, kaminoReserve);
         });
         this.reserves = kaminoReserves;
@@ -274,7 +283,7 @@ class KaminoMarket {
     }
     getReserveByMint(address) {
         for (const reserve of this.reserves.values()) {
-            if (reserve.getLiquidityMint() === address) {
+            if (reserve.getLiquidityMint().equals(address)) {
                 return reserve;
             }
         }
@@ -327,7 +336,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: utils_1.DEFAULT_PUBLIC_KEY,
+                rewardMint: web3_js_1.PublicKey.default,
                 totalInvestmentUsd: new decimal_js_1.default(0),
                 rewardPrice: 0,
             },
@@ -335,7 +344,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: utils_1.DEFAULT_PUBLIC_KEY,
+                rewardMint: web3_js_1.PublicKey.default,
                 totalInvestmentUsd: new decimal_js_1.default(0),
                 rewardPrice: 0,
             },
@@ -349,7 +358,7 @@ class KaminoMarket {
         return result;
     }
     async getRewardInfoForFarm(farmAddress, totalInvestmentUsd, getRewardPrice) {
-        const farmState = await farms_sdk_1.FarmState.fetch(this.getRpc(), farmAddress);
+        const farmState = await farms_sdk_1.FarmState.fetch(this.connection, farmAddress);
         if (!farmState) {
             throw Error(`Could not parse farm state. ${farmAddress}`);
         }
@@ -384,42 +393,43 @@ class KaminoMarket {
     async getAllObligationsForMarket(tag) {
         const filters = [
             {
-                dataSize: BigInt(accounts_1.Obligation.layout.span + 8),
+                dataSize: accounts_1.Obligation.layout.span + 8,
             },
             {
                 memcmp: {
-                    offset: 32n,
-                    bytes: this.address.toString(),
-                    encoding: 'base58',
+                    offset: 32,
+                    bytes: this.address,
                 },
             },
         ];
         if (tag !== undefined) {
             filters.push({
                 memcmp: {
-                    offset: 8n,
-                    bytes: base58Decoder.decode(new bn_js_1.default(tag).toBuffer()),
-                    encoding: 'base58',
+                    offset: 8,
+                    bytes: bs58_1.default.encode(new anchor_1.BN(tag).toBuffer()),
                 },
             });
         }
-        const collateralExchangeRates = new Map();
-        const cumulativeBorrowRates = new Map();
+        const collateralExchangeRates = new utils_1.PubkeyHashMap();
+        const cumulativeBorrowRates = new utils_1.PubkeyHashMap();
         const [slot, obligations] = await Promise.all([
-            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
-            ),
+            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
+            }),
         ]);
         return obligations.map((obligation) => {
-            if (obligation.data === null) {
+            if (obligation.account === null) {
                 throw new Error('Invalid account');
             }
-            const obligationAccount = zero_padding_1.ObligationZP.decode(obligation.data);
+            const obligationAccount = zero_padding_1.ObligationZP.decode(obligation.account.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.address, obligationAccount, collateralExchangeRates, cumulativeBorrowRates);
+            return new obligation_1.KaminoObligation(this, obligation.pubkey, obligationAccount, collateralExchangeRates, cumulativeBorrowRates);
         });
     }
     /**
@@ -434,47 +444,42 @@ class KaminoMarket {
     async *batchGetAllObligationsForMarket(tag) {
         const filters = [
             {
-                dataSize: BigInt(accounts_1.Obligation.layout.span + 8),
+                dataSize: accounts_1.Obligation.layout.span + 8,
             },
             {
                 memcmp: {
-                    offset: 32n,
-                    bytes: this.address.toString(),
-                    encoding: 'base58',
+                    offset: 32,
+                    bytes: this.address,
                 },
             },
         ];
         if (tag !== undefined) {
             filters.push({
                 memcmp: {
-                    offset: 8n,
-                    bytes: base58Decoder.decode(new bn_js_1.default(tag).toBuffer()),
-                    encoding: 'base58',
+                    offset: 8,
+                    bytes: bs58_1.default.encode(new anchor_1.BN(tag).toBuffer()),
                 },
             });
         }
-        const collateralExchangeRates = new Map();
-        const cumulativeBorrowRates = new Map();
+        const collateralExchangeRates = new utils_1.PubkeyHashMap();
+        const cumulativeBorrowRates = new utils_1.PubkeyHashMap();
         const [obligationPubkeys, slot] = await Promise.all([
-            this.rpc
-                .getProgramAccounts(this.programId, {
+            this.connection.getProgramAccounts(this.programId, {
                 filters,
-                encoding: 'base64',
                 dataSlice: { offset: 0, length: 0 },
-            })
-                .send(),
-            this.rpc.getSlot().send(),
+            }),
+            this.connection.getSlot(),
         ]);
         for (const batch of (0, kliquidity_sdk_1.chunks)(obligationPubkeys.map((x) => x.pubkey), 100)) {
-            const obligationAccounts = await this.rpc.getMultipleAccounts(batch, { encoding: 'base64' }).send();
+            const obligationAccounts = await this.connection.getMultipleAccountsInfo(batch);
             const obligationsBatch = [];
-            for (let i = 0; i < obligationAccounts.value.length; i++) {
-                const obligation = obligationAccounts.value[i];
+            for (let i = 0; i < obligationAccounts.length; i++) {
+                const obligation = obligationAccounts[i];
                 const pubkey = batch[i];
                 if (obligation === null) {
                     continue;
                 }
-                const obligationAccount = accounts_1.Obligation.decode(buffer_1.Buffer.from(obligation.data[0], 'base64'));
+                const obligationAccount = accounts_1.Obligation.decode(obligation.data);
                 if (!obligationAccount) {
                     throw Error(`Could not decode obligation ${pubkey.toString()}`);
                 }
@@ -486,42 +491,37 @@ class KaminoMarket {
     }
     async getAllObligationsByTag(tag, market) {
         const [slot, obligations] = await Promise.all([
-            this.rpc.getSlot().send(),
-            this.rpc
-                .getProgramAccounts(this.programId, {
+            this.connection.getSlot(),
+            this.connection.getProgramAccounts(this.programId, {
                 filters: [
                     {
-                        dataSize: BigInt(accounts_1.Obligation.layout.span + 8),
+                        dataSize: accounts_1.Obligation.layout.span + 8,
                     },
                     {
                         memcmp: {
-                            offset: 8n,
-                            bytes: base58Decoder.decode(new bn_js_1.default(tag).toBuffer()),
-                            encoding: 'base58',
+                            offset: 8,
+                            bytes: bs58_1.default.encode(new anchor_1.BN(tag).toBuffer()),
                         },
                     },
                     {
                         memcmp: {
-                            offset: 32n,
-                            bytes: market.toString(),
-                            encoding: 'base58',
+                            offset: 32,
+                            bytes: market.toBase58(),
                         },
                     },
                 ],
-                encoding: 'base64',
-            })
-                .send(),
+            }),
         ]);
-        const collateralExchangeRates = new Map();
-        const cumulativeBorrowRates = new Map();
+        const collateralExchangeRates = new utils_1.PubkeyHashMap();
+        const cumulativeBorrowRates = new utils_1.PubkeyHashMap();
         return obligations.map((obligation) => {
             if (obligation.account === null) {
                 throw new Error('Invalid account');
             }
-            if (obligation.account.owner !== this.programId) {
+            if (!obligation.account.owner.equals(this.programId)) {
                 throw new Error("account doesn't belong to this program");
             }
-            const obligationAccount = accounts_1.Obligation.decode(buffer_1.Buffer.from(obligation.account.data[0], 'base64'));
+            const obligationAccount = accounts_1.Obligation.decode(obligation.account.data);
             if (!obligationAccount) {
                 throw Error('Could not parse obligation.');
             }
@@ -533,42 +533,37 @@ class KaminoMarket {
         const finalObligations = [];
         for (let i = 0; i < utils_1.DEPOSITS_LIMIT; i++) {
             const [slot, obligations] = await Promise.all([
-                this.rpc.getSlot().send(),
-                this.rpc
-                    .getProgramAccounts(this.programId, {
+                this.connection.getSlot(),
+                this.connection.getProgramAccounts(this.programId, {
                     filters: [
                         {
-                            dataSize: BigInt(accounts_1.Obligation.layout.span + 8),
+                            dataSize: accounts_1.Obligation.layout.span + 8,
                         },
                         {
                             memcmp: {
-                                offset: 96n + 136n * BigInt(i),
-                                bytes: reserve.toString(),
-                                encoding: 'base58',
+                                offset: 96 + 136 * i,
+                                bytes: reserve.toBase58(),
                             },
                         },
                         {
                             memcmp: {
-                                offset: 32n,
-                                bytes: this.address.toString(),
-                                encoding: 'base58',
+                                offset: 32,
+                                bytes: this.address,
                             },
                         },
                     ],
-                    encoding: 'base64',
-                })
-                    .send(),
+                }),
             ]);
-            const collateralExchangeRates = new Map();
-            const cumulativeBorrowRates = new Map();
+            const collateralExchangeRates = new utils_1.PubkeyHashMap();
+            const cumulativeBorrowRates = new utils_1.PubkeyHashMap();
             const obligationsBatch = obligations.map((obligation) => {
                 if (obligation.account === null) {
                     throw new Error('Invalid account');
                 }
-                if (obligation.account.owner !== this.programId) {
+                if (!obligation.account.owner.equals(this.programId)) {
                     throw new Error("account doesn't belong to this program");
                 }
-                const obligationAccount = accounts_1.Obligation.decode(buffer_1.Buffer.from(obligation.account.data[0], 'base64'));
+                const obligationAccount = accounts_1.Obligation.decode(obligation.account.data);
                 if (!obligationAccount) {
                     throw Error('Could not parse obligation.');
                 }
@@ -579,49 +574,46 @@ class KaminoMarket {
         }
         return finalObligations;
     }
-    async getAllUserObligations(user, commitment = 'processed') {
+    async getAllUserObligations(user, commitment = this.connection.commitment) {
         const [currentSlot, obligations] = await Promise.all([
-            this.rpc.getSlot().send(),
-            this.rpc
-                .getProgramAccounts(this.programId, {
+            this.connection.getSlot(),
+            this.connection.getProgramAccounts(this.programId, {
                 filters: [
                     {
-                        dataSize: BigInt(accounts_1.Obligation.layout.span + 8),
+                        dataSize: accounts_1.Obligation.layout.span + 8,
                     },
                     {
                         memcmp: {
-                            offset: 0n,
-                            bytes: base58Decoder.decode(accounts_1.Obligation.discriminator),
-                            encoding: 'base58',
+                            offset: 0,
+                            bytes: bs58_2.default.encode(accounts_1.Obligation.discriminator),
                         },
                     },
                     {
                         memcmp: {
-                            offset: 64n,
-                            bytes: user.toString(),
-                            encoding: 'base58',
+                            offset: 64,
+                            bytes: user.toBase58(),
                         },
                     },
                     {
                         memcmp: {
-                            offset: 32n,
-                            bytes: this.address.toString(),
-                            encoding: 'base58',
+                            offset: 32,
+                            bytes: this.address,
                         },
                     },
                 ],
-                encoding: 'base64',
                 commitment,
-            })
-                .send(),
+            }),
         ]);
-        const collateralExchangeRates = new Map();
-        const cumulativeBorrowRates = new Map();
+        const collateralExchangeRates = new utils_1.PubkeyHashMap();
+        const cumulativeBorrowRates = new utils_1.PubkeyHashMap();
         return obligations.map((obligation) => {
-            if (obligation.account.owner !== this.programId) {
+            if (obligation.account === null) {
+                throw new Error('Invalid account');
+            }
+            if (!obligation.account.owner.equals(this.programId)) {
                 throw new Error("account doesn't belong to this program");
             }
-            const obligationAccount = accounts_1.Obligation.decode(buffer_1.Buffer.from(obligation.account.data[0], 'base64'));
+            const obligationAccount = accounts_1.Obligation.decode(obligation.account.data);
             if (!obligationAccount) {
                 throw Error('Could not parse obligation.');
             }
@@ -631,20 +623,20 @@ class KaminoMarket {
     }
     async getAllUserObligationsForReserve(user, reserve) {
         const obligationAddresses = [];
-        obligationAddresses.push(await new utils_1.VanillaObligation(this.programId).toPda(this.getAddress(), user));
-        const targetReserve = new Map(Array.from(this.reserves.entries())).get(reserve);
+        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);
         if (!targetReserve) {
             throw Error('Could not find reserve.');
         }
         for (const [key, kaminoReserve] of this.reserves) {
-            if (targetReserve.address === key) {
+            if (targetReserve.address.equals(key)) {
                 // skip target reserve
                 continue;
             }
-            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));
+            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));
         }
         const batchSize = 100;
         const finalObligations = [];
@@ -653,12 +645,12 @@ class KaminoMarket {
             obligations.forEach((obligation) => {
                 if (obligation !== null) {
                     for (const deposits of obligation.deposits.keys()) {
-                        if (deposits === reserve) {
+                        if (deposits.equals(reserve)) {
                             finalObligations.push(obligation);
                         }
                     }
                     for (const borrows of obligation.borrows.keys()) {
-                        if (borrows === reserve) {
+                        if (borrows.equals(reserve)) {
                             finalObligations.push(obligation);
                         }
                     }
@@ -668,7 +660,7 @@ class KaminoMarket {
         return finalObligations;
     }
     async getUserVanillaObligation(user) {
-        const vanillaObligationAddress = await new utils_1.VanillaObligation(this.programId).toPda(this.getAddress(), user);
+        const vanillaObligationAddress = 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.');
@@ -677,12 +669,12 @@ class KaminoMarket {
     }
     isReserveInObligation(obligation, reserve) {
         for (const deposits of obligation.deposits.keys()) {
-            if (deposits === reserve) {
+            if (deposits.equals(reserve)) {
                 return true;
             }
         }
         for (const borrows of obligation.borrows.keys()) {
-            if (borrows === reserve) {
+            if (borrows.equals(reserve)) {
                 return true;
             }
         }
@@ -690,46 +682,43 @@ class KaminoMarket {
     }
     async getUserObligationsByTag(tag, user) {
         const [currentSlot, obligations] = await Promise.all([
-            this.rpc.getSlot().send(),
-            this.rpc
-                .getProgramAccounts(this.programId, {
+            this.connection.getSlot(),
+            this.connection.getProgramAccounts(this.programId, {
                 filters: [
                     {
-                        dataSize: BigInt(accounts_1.Obligation.layout.span + 8),
+                        dataSize: accounts_1.Obligation.layout.span + 8,
                     },
                     {
                         memcmp: {
-                            offset: 8n,
-                            bytes: base58Decoder.decode(new bn_js_1.default(tag).toBuffer()),
-                            encoding: 'base58',
+                            offset: 8,
+                            bytes: bs58_1.default.encode(new anchor_1.BN(tag).toBuffer()),
                         },
                     },
                     {
                         memcmp: {
-                            offset: 32n,
-                            bytes: this.address.toString(),
-                            encoding: 'base58',
+                            offset: 32,
+                            bytes: this.address,
                         },
                     },
                     {
                         memcmp: {
-                            offset: 64n,
-                            bytes: user.toString(),
-                            encoding: 'base58',
+                            offset: 64,
+                            bytes: user.toBase58(),
                         },
                     },
                 ],
-                encoding: 'base64',
-            })
-                .send(),
+            }),
         ]);
-        const collateralExchangeRates = new Map();
-        const cumulativeBorrowRates = new Map();
+        const collateralExchangeRates = new utils_1.PubkeyHashMap();
+        const cumulativeBorrowRates = new utils_1.PubkeyHashMap();
         return obligations.map((obligation) => {
-            if (obligation.account.owner !== this.programId) {
+            if (obligation.account === null) {
+                throw new Error('Invalid account');
+            }
+            if (!obligation.account.owner.equals(this.programId)) {
                 throw new Error("account doesn't belong to this program");
             }
-            const obligationAccount = accounts_1.Obligation.decode(buffer_1.Buffer.from(obligation.account.data[0], 'base64'));
+            const obligationAccount = accounts_1.Obligation.decode(obligation.account.data);
             if (!obligationAccount) {
                 throw Error('Could not parse obligation.');
             }
@@ -751,42 +740,38 @@ 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] = await (0, utils_1.userMetadataPda)(user, this.programId);
-        const userMetadata = await accounts_1.UserMetadata.fetch(this.rpc, address, this.programId);
+        const [address, _bump] = (0, utils_1.userMetadataPda)(user, this.programId);
+        const userMetadata = await accounts_1.UserMetadata.fetch(this.connection, address, this.programId);
         return [address, userMetadata];
     }
     async getReferrerTokenStateForReserve(referrer, reserve) {
-        const address = await (0, utils_1.referrerTokenStatePda)(referrer, reserve, this.programId);
-        const referrerTokenState = await accounts_1.ReferrerTokenState.fetch(this.rpc, address, this.programId);
+        const [address, _bump] = (0, utils_1.referrerTokenStatePda)(referrer, reserve, this.programId);
+        const referrerTokenState = await accounts_1.ReferrerTokenState.fetch(this.connection, address, this.programId);
         return [address, referrerTokenState];
     }
     async getAllReferrerTokenStates(referrer) {
-        const referrerTokenStates = await this.rpc
-            .getProgramAccounts(this.programId, {
+        const referrerTokenStates = await this.connection.getProgramAccounts(this.programId, {
             filters: [
                 {
-                    dataSize: BigInt(accounts_1.ReferrerTokenState.layout.span + 8),
+                    dataSize: accounts_1.ReferrerTokenState.layout.span + 8,
                 },
                 {
                     memcmp: {
-                        offset: 8n,
-                        bytes: referrer.toString(),
-                        encoding: 'base58',
+                        offset: 8,
+                        bytes: referrer.toBase58(),
                     },
                 },
             ],
-            encoding: 'base64',
-        })
-            .send();
-        const referrerTokenStatesForMints = new Map();
+        });
+        const referrerTokenStatesForMints = new utils_1.PubkeyHashMap();
         referrerTokenStates.forEach((referrerTokenState) => {
             if (referrerTokenState.account === null) {
                 throw new Error('Invalid account');
             }
-            if (referrerTokenState.account.owner !== this.programId) {
+            if (!referrerTokenState.account.owner.equals(this.programId)) {
                 throw new Error("account doesn't belong to this program");
             }
-            const referrerTokenStateDecoded = accounts_1.ReferrerTokenState.decode(buffer_1.Buffer.from(referrerTokenState.account.data[0], 'base64'));
+            const referrerTokenStateDecoded = accounts_1.ReferrerTokenState.decode(referrerTokenState.account.data);
             if (!referrerTokenStateDecoded) {
                 throw Error('Could not parse obligation.');
             }
@@ -796,7 +781,7 @@ class KaminoMarket {
     }
     async getAllReferrerFeesUnclaimed(referrer) {
         const referrerTokenStatesForMints = await this.getAllReferrerTokenStates(referrer);
-        const referrerFeesUnclaimedForMints = new Map();
+        const referrerFeesUnclaimedForMints = new utils_1.PubkeyHashMap();
         for (const mint of referrerTokenStatesForMints.keys()) {
             referrerFeesUnclaimedForMints.set(mint, new fraction_1.Fraction(referrerTokenStatesForMints.get(mint).amountUnclaimedSf).toDecimal());
         }
@@ -812,32 +797,52 @@ class KaminoMarket {
     }
     async getAllReferrerFeesCumulative(referrer) {
         const referrerTokenStatesForMints = await this.getAllReferrerTokenStates(referrer);
-        const referrerFeesCumulativeForMints = new Map();
+        const referrerFeesCumulativeForMints = new utils_1.PubkeyHashMap();
         for (const mint of referrerTokenStatesForMints.keys()) {
             referrerFeesCumulativeForMints.set(mint, new fraction_1.Fraction(referrerTokenStatesForMints.get(mint).amountUnclaimedSf).toDecimal());
         }
         return referrerFeesCumulativeForMints;
     }
-    getReferrerUrl(baseUrl, referrer) {
-        return `${baseUrl}${referrer.toString()}`;
+    async getReferrerUrl(baseUrl, referrer) {
+        return baseUrl + this.encodeReferrer(referrer);
+    }
+    async getReferrerFromUrl(baseUrl, url) {
+        return this.decodeReferrer(url.split(baseUrl)[1]);
     }
-    getReferrerFromUrl(baseUrl, url) {
-        return (0, kit_1.address)(url.split(baseUrl)[1]);
+    async encodeReferrer(referrer) {
+        return bs58_2.default.encode(referrer.toBuffer());
+    }
+    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
+     * Get the underlying connection passed when instantiating this market
+     * @return connection
      */
-    getRpc() {
-        return this.rpc;
+    getConnection() {
+        return this.connection;
     }
     /**
-     * Get all Scope prices used by all the market reserves
+     * Get all scope OraclePrices accounts for all market reserves
+     * @param scope
      */
-    async getAllScopePrices(scope, oraclePrices) {
-        if (!oraclePrices) {
-            oraclePrices = await scope.getOraclePrices();
+    async getReserveOraclePrices(scope) {
+        const reserveOraclePrices = new utils_1.PubkeyHashMap();
+        const oraclePrices = await scope.getMultipleOraclePrices(Array.from(this.reserveScopeFeeds.keys()));
+        for (const [feed, oraclePricesAccount] of oraclePrices) {
+            const reserve = this.reserveScopeFeeds.get(feed);
+            if (reserve) {
+                reserveOraclePrices.set(reserve, oraclePricesAccount);
+            }
         }
+        return reserveOraclePrices;
+    }
+    /**
+     * Get all Scope prices used by all the market reserves
+     */
+    async getAllScopePrices(scope) {
+        const allOraclePrices = await this.getReserveOraclePrices(scope);
         const spot = {};
         const twaps = {};
         for (const reserve of this.reserves.values()) {
@@ -846,11 +851,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 };
             }
@@ -866,10 +872,11 @@ class KaminoMarket {
             pyth: { spot: {}, twap: {} },
             switchboard: { spot: {}, twap: {} },
         };
-        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();
+        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);
         for (const reserve of this.reserves.values()) {
             const tokenMint = reserve.getLiquidityMint().toString();
             const tokenName = reserve.getTokenSymbol();
@@ -892,9 +899,9 @@ class KaminoMarket {
             }
             if ((0, utils_1.isNotNullPubkey)(switchboardSpotOracle)) {
                 const switchboardPrices = {
-                    spot: (0, utils_1.cacheOrGetSwitchboardPrice)(switchboardSpotOracle, switchboardCache, allOracleAccounts),
+                    spot: (0, utils_1.cacheOrGetSwitchboardPrice)(switchboardSpotOracle, switchboardCache, allOracleAccounts, switchboardV2),
                     twap: (0, utils_1.isNotNullPubkey)(switchboardTwapOracle)
-                        ? (0, utils_1.cacheOrGetSwitchboardPrice)(switchboardTwapOracle, switchboardCache, allOracleAccounts)
+                        ? (0, utils_1.cacheOrGetSwitchboardPrice)(switchboardTwapOracle, switchboardCache, allOracleAccounts, switchboardV2)
                         : null,
                 };
                 this.setPriceIfExist(klendPrices.switchboard, switchboardPrices.spot, switchboardPrices.twap, tokenMint, tokenName);
@@ -903,14 +910,14 @@ class KaminoMarket {
         return klendPrices;
     }
     getCumulativeBorrowRatesByReserve(slot) {
-        const cumulativeBorrowRates = new Map();
+        const cumulativeBorrowRates = new utils_1.PubkeyHashMap();
         for (const reserve of this.reserves.values()) {
             cumulativeBorrowRates.set(reserve.address, reserve.getEstimatedCumulativeBorrowRate(slot, this.state.referralFeeBps));
         }
         return cumulativeBorrowRates;
     }
     getCollateralExchangeRatesByReserve(slot) {
-        const collateralExchangeRates = new Map();
+        const collateralExchangeRates = new utils_1.PubkeyHashMap();
         for (const reserve of this.reserves.values()) {
             collateralExchangeRates.set(reserve.address, reserve.getEstimatedCollateralExchangeRate(slot, this.state.referralFeeBps));
         }
@@ -936,10 +943,10 @@ class KaminoMarket {
                 continue;
             }
             elevationGroups.push({
-                collateralReserves: new Set([]),
-                collateralLiquidityMints: new Set([]),
+                collateralReserves: new utils_1.PublicKeySet([]),
+                collateralLiquidityMints: new utils_1.PublicKeySet([]),
                 debtReserve: elevationGroup.debtReserve,
-                debtLiquidityMint: utils_1.DEFAULT_PUBLIC_KEY,
+                debtLiquidityMint: web3_js_1.PublicKey.default,
                 elevationGroup: elevationGroup.id,
                 maxReservesAsCollateral: elevationGroup.maxReservesAsCollateral,
             });
@@ -955,7 +962,7 @@ class KaminoMarket {
                 }
                 const elevationGroupDescription = elevationGroups[elevationGroupId - 1];
                 if (elevationGroupDescription) {
-                    if (reserveAddress === elevationGroupDescription.debtReserve) {
+                    if (reserveAddress.equals(elevationGroupDescription.debtReserve)) {
                         elevationGroups[elevationGroupId - 1].debtLiquidityMint = reserveLiquidityMint;
                     }
                     else {
@@ -974,73 +981,75 @@ class KaminoMarket {
     getElevationGroupsForMintsCombination(collLiquidityMints, debtLiquidityMint) {
         const allElevationGroups = this.getMarketElevationGroupDescriptions();
         return allElevationGroups.filter((elevationGroupDescription) => {
-            return (collLiquidityMints.every((mint) => elevationGroupDescription.collateralLiquidityMints.has(mint)) &&
-                (debtLiquidityMint == undefined || debtLiquidityMint === elevationGroupDescription.debtLiquidityMint));
+            return (collLiquidityMints.every((mint) => elevationGroupDescription.collateralLiquidityMints.contains(mint)) &&
+                (debtLiquidityMint == undefined || debtLiquidityMint.equals(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.has(mint)) &&
-                (debtReserve == undefined || debtReserve === elevationGroupDescription.debtReserve));
+            return (collReserves.every((mint) => elevationGroupDescription.collateralReserves.contains(mint)) &&
+                (debtReserve == undefined || debtReserve.equals(elevationGroupDescription.debtReserve)));
         });
     }
 }
 exports.KaminoMarket = KaminoMarket;
-async function getReservesForMarket(marketAddress, rpc, programId, recentSlotDurationMs) {
-    const reserves = await rpc
-        .getProgramAccounts(programId, {
+async function getReservesForMarket(marketAddress, connection, programId, recentSlotDurationMs) {
+    const reserves = await connection.getProgramAccounts(programId, {
         filters: [
             {
-                dataSize: BigInt(accounts_1.Reserve.layout.span + 8),
+                dataSize: accounts_1.Reserve.layout.span + 8,
             },
             {
                 memcmp: {
-                    offset: 32n,
-                    bytes: marketAddress.toString(),
-                    encoding: 'base58',
+                    offset: 32,
+                    bytes: marketAddress.toBase58(),
                 },
             },
         ],
-        encoding: 'base64',
-    })
-        .send();
+    });
     const deserializedReserves = reserves.map((reserve) => {
         if (reserve.account === null) {
-            throw new Error(`Reserve account ${reserve.pubkey} does not exist`);
+            throw new Error(`Reserve account ${reserve.pubkey.toBase58()} does not exist`);
         }
-        const reserveAccount = accounts_1.Reserve.decode(buffer_1.Buffer.from(reserve.account.data[0], 'base64'));
+        const reserveAccount = accounts_1.Reserve.decode(reserve.account.data);
         if (!reserveAccount) {
-            throw Error(`Could not parse reserve ${reserve.pubkey}`);
+            throw Error(`Could not parse reserve ${reserve.pubkey.toBase58()}`);
         }
         return reserveAccount;
     });
-    const reservesAndOracles = await (0, utils_1.getTokenOracleData)(rpc, deserializedReserves);
-    const reservesByAddress = new Map();
+    const allBuffers = reserves.map((reserve) => reserve.account);
+    const reservesAndOracles = await (0, utils_1.getTokenOracleData)(connection, deserializedReserves);
+    const reservesByAddress = new utils_1.PubkeyHashMap();
     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(reserves[index].pubkey, reserve, oracle, rpc, recentSlotDurationMs);
+        const kaminoReserve = reserve_1.KaminoReserve.initialize(allBuffers[index], reserves[index].pubkey, reserve, oracle, connection, recentSlotDurationMs);
         reservesByAddress.set(kaminoReserve.address, kaminoReserve);
     });
     return reservesByAddress;
 }
-async function getSingleReserve(reservePk, rpc, recentSlotDurationMs, reserveData) {
-    const reserve = reserveData ?? (await accounts_1.Reserve.fetch(rpc, reservePk));
+async function getSingleReserve(reservePk, connection, recentSlotDurationMs, accountData) {
+    const reserve = accountData ? accountData : await connection.getAccountInfo(reservePk);
     if (reserve === null) {
-        throw new Error(`Reserve account ${reservePk} does not exist`);
+        throw new Error(`Reserve account ${reservePk.toBase58()} 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)(rpc, [reserve]);
-    const [, oracle] = reservesAndOracles[0];
+    const reservesAndOracles = await (0, utils_1.getTokenOracleData)(connection, [reserveAccount]);
+    const [reserveState, oracle] = reservesAndOracles[0];
     if (!oracle) {
-        throw Error(`Could not find oracle for ${(0, utils_2.parseTokenSymbol)(reserve.config.tokenInfo.name)} reserve`);
+        throw Error(`Could not find oracle for ${(0, utils_2.parseTokenSymbol)(reserveState.config.tokenInfo.name)} reserve`);
     }
-    return reserve_1.KaminoReserve.initialize(reservePk, reserve, oracle, rpc, recentSlotDurationMs);
+    const kaminoReserve = reserve_1.KaminoReserve.initialize(reserve, reservePk, reserveState, oracle, connection, recentSlotDurationMs);
+    return kaminoReserve;
 }
 function getReservesActive(reserves) {
-    const reservesActive = new Map();
+    const reservesActive = new utils_1.PubkeyHashMap();
     for (const [key, reserve] of reserves) {
         if (reserve.state.config.status === 0) {
             reservesActive.set(key, reserve);
@@ -1053,9 +1062,9 @@ function getTokenIdsForScopeRefresh(kaminoMarket, reserves) {
     for (const reserveAddress of reserves) {
         const reserve = kaminoMarket.getReserveByAddress(reserveAddress);
         if (!reserve) {
-            throw new Error(`Reserve not found for reserve ${reserveAddress}`);
+            throw new Error(`Reserve not found for reserve ${reserveAddress.toBase58()}`);
         }
-        if (reserve.state.config.tokenInfo.scopeConfiguration.priceFeed !== utils_1.DEFAULT_PUBLIC_KEY) {
+        if (!reserve.state.config.tokenInfo.scopeConfiguration.priceFeed.equals(web3_js_1.PublicKey.default)) {
             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]);
@@ -1070,6 +1079,34 @@ function getTokenIdsForScopeRefresh(kaminoMarket, reserves) {
     }
     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');
+    }
+    if (!reserve.account.owner.equals(programId)) {
+        throw new Error("Account doesn't belong to this program");
+    }
+    return [reserve.pubkey, reserve.account];
+}
 const lamportsToNumberDecimal = (amount, decimals) => {
     const factor = 10 ** decimals;
     return new decimal_js_1.default(amount).div(factor);