@kamino-finance/klend-sdk 2.10.6

package/dist/classes/market.js

@@ -0,0 +1,901 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._getReserveFromMintAndMarket = exports.getReservesActive = exports.getReservesForMarket = exports.KaminoMarket = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const obligation_1 = require("./obligation");
+const reserve_1 = require("./reserve");
+const accounts_1 = require("../idl_codegen/accounts");
+const utils_1 = require("../utils");
+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("@hubbleprotocol/farms-sdk");
+const programId_1 = require("../idl_codegen/programId");
+const bs58_2 = __importDefault(require("bs58"));
+const scope_sdk_1 = require("@hubbleprotocol/scope-sdk");
+const fraction_1 = require("./fraction");
+const kamino_sdk_1 = require("@hubbleprotocol/kamino-sdk");
+const utils_2 = require("./utils");
+const sbv2_lite_1 = __importDefault(require("@switchboard-xyz/sbv2-lite"));
+class KaminoMarket {
+    constructor(connection, state, marketAddress, reserves, scope, programId = programId_1.PROGRAM_ID) {
+        this.address = marketAddress;
+        this.connection = connection;
+        this.state = state;
+        this.reserves = reserves;
+        this.reservesActive = getReservesActive(this.reserves);
+        this.programId = programId;
+        this.scope = scope;
+    }
+    /**
+     * Load a new market with all of its associated reserves
+     * @param connection
+     * @param marketAddress
+     * @param programId
+     * @param setupLocalTest
+     */
+    static load(connection, marketAddress, programId = programId_1.PROGRAM_ID, setupLocalTest = false, withReserves = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const market = yield accounts_1.LendingMarket.fetch(connection, marketAddress, programId);
+            if (market === null) {
+                return null;
+            }
+            let scope;
+            if (!setupLocalTest) {
+                scope = new scope_sdk_1.Scope('mainnet-beta', connection);
+            }
+            else {
+                scope = new scope_sdk_1.Scope('localnet', connection);
+            }
+            const reserves = withReserves
+                ? yield getReservesForMarket(marketAddress, connection, programId)
+                : new Map();
+            return new KaminoMarket(connection, market, marketAddress.toString(), reserves, scope, programId);
+        });
+    }
+    reload() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const market = yield accounts_1.LendingMarket.fetch(this.connection, this.getAddress(), this.programId);
+            if (market === null) {
+                return;
+            }
+            this.state = market;
+            this.reserves = yield getReservesForMarket(this.getAddress(), this.connection, this.programId);
+            this.reservesActive = getReservesActive(this.reserves);
+        });
+    }
+    /**
+     * Get the address of this market
+     * @return market address public key
+     */
+    getAddress() {
+        return new web3_js_1.PublicKey(this.address);
+    }
+    /**
+     * Get a list of reserves for this market
+     */
+    getReserves() {
+        return [...this.reserves.values()];
+    }
+    getElevationGroup(elevationGroup) {
+        return this.state.elevationGroups[elevationGroup - 1];
+    }
+    /**
+     * Get the authority PDA of this market
+     * @return market authority public key
+     */
+    getLendingMarketAuthority() {
+        return (0, utils_1.lendingMarketAuthPda)(this.getAddress(), this.programId)[0];
+    }
+    getObligationDepositByWallet(owner, mint, obligationType) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const obligation = yield this.getObligationByWallet(owner, obligationType);
+            return (_b = (_a = obligation === null || obligation === void 0 ? void 0 : obligation.getDepositByMint(mint)) === null || _a === void 0 ? void 0 : _a.amount) !== null && _b !== void 0 ? _b : new decimal_js_1.default(0);
+        });
+    }
+    getObligationBorrowByWallet(owner, mint, obligationType) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const obligation = yield this.getObligationByWallet(owner, obligationType);
+            return (_b = (_a = obligation === null || obligation === void 0 ? void 0 : obligation.getBorrowByMint(mint)) === null || _a === void 0 ? void 0 : _a.amount) !== null && _b !== void 0 ? _b : new decimal_js_1.default(0);
+        });
+    }
+    getTotalDepositTVL() {
+        const tvl = new decimal_js_1.default(0);
+        for (const reserve of this.reserves.values()) {
+            tvl.add(reserve.getDepositTvl());
+        }
+        return tvl;
+    }
+    getTotalBorrowTVL() {
+        const tvl = new decimal_js_1.default(0);
+        for (const reserve of this.reserves.values()) {
+            tvl.add(reserve.getBorrowTvl());
+        }
+        return tvl;
+    }
+    getMaxLeverageForPair(collTokenMint, debtTokenMint) {
+        const { maxLtv: maxCollateralLtv, borrowFactor } = this.getMaxAndLiquidationLtvAndBorrowFactorForPair(collTokenMint, debtTokenMint);
+        const maxLeverage = 
+        // const ltv = (coll * ltv_factor) / (debt * borrow_factor);
+        1 / (1 - (maxCollateralLtv * 100) / (borrowFactor * 100));
+        return maxLeverage;
+    }
+    getMaxAndLiquidationLtvAndBorrowFactorForPair(collTokenMint, debtTokenMint) {
+        const collReserve = this.getReserveByMint(collTokenMint);
+        const debtReserve = this.getReserveByMint(debtTokenMint);
+        if (!collReserve || !debtReserve) {
+            throw Error('Could not find one of the reserves.');
+        }
+        const groupsColl = new Set(collReserve.state.config.elevationGroups);
+        const groupsDebt = new Set(debtReserve.state.config.elevationGroups);
+        const commonElevationGroups = [...groupsColl].filter((item) => groupsDebt.has(item) && item !== 0);
+        // Ltv factor for coll token
+        const maxCollateralLtv = commonElevationGroups.length === 0
+            ? collReserve.state.config.loanToValuePct
+            : this.state.elevationGroups
+                .filter((e) => commonElevationGroups.includes(e.id))
+                .reduce((acc, elem) => Math.max(acc, elem.ltvPct), 0);
+        const liquidationLtv = commonElevationGroups.length === 0
+            ? collReserve.state.config.liquidationThresholdPct
+            : this.state.elevationGroups
+                .filter((e) => commonElevationGroups.includes(e.id))
+                .reduce((acc, elem) => Math.max(acc, elem.liquidationThresholdPct), 0);
+        const borrowFactor = commonElevationGroups.length === 0 ? (debtReserve === null || debtReserve === void 0 ? void 0 : debtReserve.state.config.borrowFactorPct.toNumber()) / 100 : 1;
+        return { maxLtv: maxCollateralLtv / 100, liquidationLtv: liquidationLtv / 100, borrowFactor };
+    }
+    getTotalProductTvl(productType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let obligations = (yield this.getAllObligationsForMarket(productType.toArgs().tag)).filter((obligation) => obligation.refreshedStats.userTotalBorrow.gt(0) || obligation.refreshedStats.userTotalDeposit.gt(0));
+            switch (productType.toArgs().tag) {
+                case utils_1.VanillaObligation.tag: {
+                    break;
+                }
+                case utils_1.LendingObligation.tag: {
+                    const mint = productType.toArgs().seed1;
+                    obligations = obligations.filter((obligation) => obligation.getDepositByMint(mint) !== undefined);
+                    break;
+                }
+                case utils_1.MultiplyObligation.tag:
+                case utils_1.LeverageObligation.tag: {
+                    const collMint = productType.toArgs().seed1;
+                    const debtMint = productType.toArgs().seed2;
+                    obligations = obligations.filter((obligation) => obligation.getDepositByMint(collMint) !== undefined && obligation.getBorrowByMint(debtMint) !== undefined);
+                    break;
+                }
+                default:
+                    throw new Error('Invalid obligation type');
+            }
+            const deposits = obligations.reduce((acc, obligation) => acc.plus(obligation.refreshedStats.userTotalDeposit), new decimal_js_1.default(0));
+            const borrows = obligations.reduce((acc, obligation) => acc.plus(obligation.refreshedStats.userTotalBorrow), new decimal_js_1.default(0));
+            const avgLeverage = obligations.reduce((acc, obligations) => acc.plus(obligations.refreshedStats.leverage), new decimal_js_1.default(0));
+            return { tvl: deposits.sub(borrows), deposits, borrows, avgLeverage: avgLeverage.div(obligations.length) };
+        });
+    }
+    /**
+     *
+     * @returns Number of active obligations in the market
+     */
+    getNumberOfObligations() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.getAllObligationsForMarket())
+                .filter((obligation) => obligation.refreshedStats.userTotalBorrow.gt(0) || obligation.refreshedStats.userTotalDeposit.gt(0))
+                .reduce((acc, _obligation) => acc + 1, 0);
+        });
+    }
+    getObligationByWallet(publicKey, obligationType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { address } = this;
+            if (!address) {
+                throw Error('Market must be initialized to call initialize.');
+            }
+            const obligationAddress = obligationType.toPda(this.getAddress(), publicKey);
+            return obligation_1.KaminoObligation.load(this, obligationAddress);
+        });
+    }
+    loadReserves() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const addresses = [...this.reserves.keys()];
+            const reserveAccounts = yield 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].toBase58()} was not found`);
+                }
+                const reserveAccount = accounts_1.Reserve.decode(reserve.data);
+                if (!reserveAccount) {
+                    throw Error(`Could not parse reserve ${addresses[i].toBase58()}`);
+                }
+                return reserveAccount;
+            });
+            const reservesAndOracles = yield (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(reserveAccounts[index], addresses[index], reserve, oracle, this.connection);
+                kaminoReserves.set(kaminoReserve.address, kaminoReserve);
+            });
+            this.reserves = kaminoReserves;
+            this.reservesActive = getReservesActive(this.reserves);
+        });
+    }
+    refreshAll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promises = [this.getReserves().every((reserve) => reserve.stats) ? this.loadReserves() : null].filter((x) => x);
+            yield Promise.all(promises);
+            this.reservesActive = getReservesActive(this.reserves);
+        });
+    }
+    getReserveByAddress(address) {
+        return this.reserves.get(address);
+    }
+    getReserveByMint(address) {
+        for (const reserve of this.reserves.values()) {
+            if (reserve.getLiquidityMint().equals(address)) {
+                return reserve;
+            }
+        }
+        return undefined;
+    }
+    getReserveBySymbol(symbol) {
+        for (const reserve of this.reserves.values()) {
+            if (reserve.symbol === symbol) {
+                return reserve;
+            }
+        }
+        return undefined;
+    }
+    getReserveMintBySymbol(symbol) {
+        var _a;
+        return (_a = this.getReserveBySymbol(symbol)) === null || _a === void 0 ? void 0 : _a.getLiquidityMint();
+    }
+    getReserveFarmInfo(mint, getRewardPrice) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { address } = this;
+            if (!address) {
+                throw Error('Market must be initialized to call initialize.');
+            }
+            if (!this.getReserves().every((reserve) => reserve.stats)) {
+                yield this.loadReserves();
+            }
+            // Find the reserve
+            const kaminoReserve = this.getReserveByMint(mint);
+            if (!kaminoReserve) {
+                throw Error(`Could not find reserve. ${mint}`);
+            }
+            const totalDepositAmount = lamportsToNumberDecimal(kaminoReserve.getLiquidityAvailableAmount(), kaminoReserve.stats.decimals);
+            const totalBorrowAmount = lamportsToNumberDecimal(kaminoReserve.getBorrowedAmount(), kaminoReserve.stats.decimals);
+            const collateralFarmAddress = kaminoReserve.state.farmCollateral;
+            const debtFarmAddress = kaminoReserve.state.farmDebt;
+            const result = {
+                borrowingRewards: {
+                    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,
+                    totalInvestmentUsd: new decimal_js_1.default(0),
+                    rewardPrice: 0,
+                },
+                depositingRewards: {
+                    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,
+                    totalInvestmentUsd: new decimal_js_1.default(0),
+                    rewardPrice: 0,
+                },
+            };
+            if ((0, utils_1.isNotNullPubkey)(collateralFarmAddress)) {
+                result.depositingRewards = yield this.getRewardInfoForFarm(collateralFarmAddress, totalDepositAmount, getRewardPrice);
+            }
+            if ((0, utils_1.isNotNullPubkey)(debtFarmAddress)) {
+                result.depositingRewards = yield this.getRewardInfoForFarm(debtFarmAddress, totalBorrowAmount, getRewardPrice);
+            }
+            return result;
+        });
+    }
+    getRewardInfoForFarm(farmAddress, totalInvestmentUsd, getRewardPrice) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const farmState = yield farms_sdk_1.FarmState.fetch(this.connection, farmAddress);
+            if (!farmState) {
+                throw Error(`Could not parse farm state. ${farmAddress}`);
+            }
+            const { token, rewardsAvailable, rewardScheduleCurve } = farmState.rewardInfos[0];
+            // TODO: marius fix
+            const rewardPerSecondLamports = rewardScheduleCurve.points[0].rewardPerTimeUnit.toNumber();
+            const { mint, decimals: rewardDecimals } = token;
+            const rewardPriceUsd = yield getRewardPrice(mint);
+            const rewardApr = this.calculateRewardAPR(rewardPerSecondLamports, rewardPriceUsd, totalInvestmentUsd, rewardDecimals.toNumber());
+            return {
+                rewardsPerSecond: new decimal_js_1.default(rewardPerSecondLamports).dividedBy(Math.pow(10, rewardDecimals.toNumber())),
+                rewardsRemaining: new decimal_js_1.default(rewardsAvailable.toNumber()).dividedBy(Math.pow(10, rewardDecimals.toNumber())),
+                rewardApr: rewardsAvailable.toNumber() > 0 ? rewardApr : new decimal_js_1.default(0),
+                rewardMint: mint,
+                totalInvestmentUsd,
+                rewardPrice: rewardPriceUsd,
+            };
+        });
+    }
+    calculateRewardAPR(rewardPerSecondLamports, rewardPriceUsd, totalInvestmentUsd, rewardDecimals) {
+        const rewardsPerYear = new decimal_js_1.default(rewardPerSecondLamports)
+            .dividedBy(Math.pow(10, rewardDecimals))
+            .times(365 * 24 * 60 * 60)
+            .times(rewardPriceUsd);
+        return rewardsPerYear.dividedBy(totalInvestmentUsd);
+    }
+    getAllObligationsForMarket(tag) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const filters = [
+                {
+                    dataSize: accounts_1.Obligation.layout.span + 8,
+                },
+                {
+                    memcmp: {
+                        offset: 32,
+                        bytes: this.address,
+                    },
+                },
+            ];
+            if (tag !== undefined) {
+                filters.push({
+                    memcmp: {
+                        offset: 8,
+                        bytes: bs58_1.default.encode(new anchor_1.BN(tag).toBuffer()),
+                    },
+                });
+            }
+            const collateralExchangeRates = new utils_1.PubkeyHashMap();
+            const cumulativeBorrowRates = new utils_1.PubkeyHashMap();
+            const [slot, obligations] = yield Promise.all([
+                this.connection.getSlot(),
+                this.connection.getProgramAccounts(this.programId, {
+                    filters,
+                }),
+            ]);
+            return obligations.map((obligation) => {
+                if (obligation.account === null) {
+                    throw new Error('Invalid account');
+                }
+                const obligationAccount = accounts_1.Obligation.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.pubkey, obligationAccount, collateralExchangeRates, cumulativeBorrowRates);
+            });
+        });
+    }
+    /**
+     * Get all obligations for lending market from an async generator filled with batches of 100 obligations each
+     * @param tag
+     * @example
+     * const obligationsGenerator = market.batchGetAllObligationsForMarket();
+     * for await (const obligations of obligationsGenerator) {
+     *   console.log('got a batch of # obligations:', obligations.length);
+     * }
+     */
+    batchGetAllObligationsForMarket(tag) {
+        return __asyncGenerator(this, arguments, function* batchGetAllObligationsForMarket_1() {
+            const filters = [
+                {
+                    dataSize: accounts_1.Obligation.layout.span + 8,
+                },
+                {
+                    memcmp: {
+                        offset: 32,
+                        bytes: this.address,
+                    },
+                },
+            ];
+            if (tag !== undefined) {
+                filters.push({
+                    memcmp: {
+                        offset: 8,
+                        bytes: bs58_1.default.encode(new anchor_1.BN(tag).toBuffer()),
+                    },
+                });
+            }
+            const slot = yield __await(this.connection.getSlot());
+            const collateralExchangeRates = new utils_1.PubkeyHashMap();
+            const cumulativeBorrowRates = new utils_1.PubkeyHashMap();
+            const obligationPubkeys = yield __await(this.connection.getProgramAccounts(this.programId, {
+                filters,
+                dataSlice: { offset: 0, length: 0 },
+            }));
+            for (const batch of (0, kamino_sdk_1.chunks)(obligationPubkeys.map((x) => x.pubkey), 100)) {
+                const obligationAccounts = yield __await(this.connection.getMultipleAccountsInfo(batch));
+                const obligationsBatch = [];
+                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(obligation.data);
+                    if (!obligationAccount) {
+                        throw Error(`Could not decode obligation ${pubkey.toString()}`);
+                    }
+                    obligation_1.KaminoObligation.addRatesForObligation(this, obligationAccount, collateralExchangeRates, cumulativeBorrowRates, slot);
+                    obligationsBatch.push(new obligation_1.KaminoObligation(this, pubkey, obligationAccount, collateralExchangeRates, cumulativeBorrowRates));
+                }
+                yield yield __await(obligationsBatch);
+            }
+        });
+    }
+    getAllObligationsByTag(tag, market) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [slot, obligations] = yield Promise.all([
+                this.connection.getSlot(),
+                this.connection.getProgramAccounts(this.programId, {
+                    filters: [
+                        {
+                            dataSize: accounts_1.Obligation.layout.span + 8,
+                        },
+                        {
+                            memcmp: {
+                                offset: 8,
+                                bytes: bs58_1.default.encode(new anchor_1.BN(tag).toBuffer()),
+                            },
+                        },
+                        {
+                            memcmp: {
+                                offset: 32,
+                                bytes: market.toBase58(),
+                            },
+                        },
+                    ],
+                }),
+            ]);
+            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.equals(this.programId)) {
+                    throw new Error("account doesn't belong to this program");
+                }
+                const obligationAccount = accounts_1.Obligation.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.pubkey, obligationAccount, collateralExchangeRates, cumulativeBorrowRates);
+            });
+        });
+    }
+    getAllUserObligations(user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [currentSlot, obligations] = yield Promise.all([
+                this.connection.getSlot(),
+                this.connection.getProgramAccounts(this.programId, {
+                    filters: [
+                        {
+                            dataSize: accounts_1.Obligation.layout.span + 8,
+                        },
+                        {
+                            memcmp: {
+                                offset: 0,
+                                bytes: bs58_2.default.encode(accounts_1.Obligation.discriminator),
+                            },
+                        },
+                        {
+                            memcmp: {
+                                offset: 64,
+                                bytes: user.toBase58(),
+                            },
+                        },
+                        {
+                            memcmp: {
+                                offset: 32,
+                                bytes: this.address,
+                            },
+                        },
+                    ],
+                }),
+            ]);
+            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.equals(this.programId)) {
+                    throw new Error("account doesn't belong to this program");
+                }
+                const obligationAccount = accounts_1.Obligation.decode(obligation.account.data);
+                if (!obligationAccount) {
+                    throw Error('Could not parse obligation.');
+                }
+                obligation_1.KaminoObligation.addRatesForObligation(this, obligationAccount, collateralExchangeRates, cumulativeBorrowRates, currentSlot);
+                return new obligation_1.KaminoObligation(this, obligation.pubkey, obligationAccount, collateralExchangeRates, cumulativeBorrowRates);
+            });
+        });
+    }
+    getUserObligationsByTag(tag, user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [currentSlot, obligations] = yield Promise.all([
+                this.connection.getSlot(),
+                this.connection.getProgramAccounts(this.programId, {
+                    filters: [
+                        {
+                            dataSize: accounts_1.Obligation.layout.span + 8,
+                        },
+                        {
+                            memcmp: {
+                                offset: 8,
+                                bytes: bs58_1.default.encode(new anchor_1.BN(tag).toBuffer()),
+                            },
+                        },
+                        {
+                            memcmp: {
+                                offset: 32,
+                                bytes: this.address,
+                            },
+                        },
+                        {
+                            memcmp: {
+                                offset: 64,
+                                bytes: user.toBase58(),
+                            },
+                        },
+                    ],
+                }),
+            ]);
+            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.equals(this.programId)) {
+                    throw new Error("account doesn't belong to this program");
+                }
+                const obligationAccount = accounts_1.Obligation.decode(obligation.account.data);
+                if (!obligationAccount) {
+                    throw Error('Could not parse obligation.');
+                }
+                obligation_1.KaminoObligation.addRatesForObligation(this, obligationAccount, collateralExchangeRates, cumulativeBorrowRates, currentSlot);
+                return new obligation_1.KaminoObligation(this, obligation.pubkey, obligationAccount, collateralExchangeRates, cumulativeBorrowRates);
+            });
+        });
+    }
+    getObligationByAddress(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.getReserves().every((reserve) => reserve.stats)) {
+                yield this.loadReserves();
+            }
+            return obligation_1.KaminoObligation.load(this, address);
+        });
+    }
+    getMultipleObligationsByAddress(addresses) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return obligation_1.KaminoObligation.loadAll(this, addresses);
+        });
+    }
+    /**
+     * Get the user metadata PDA and fetch and return the user metadata state if it exists
+     * @return [address, userMetadataState] - The address of the user metadata PDA and the user metadata state, or null if it doesn't exist
+     */
+    getUserMetadata(user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [address, _bump] = (0, utils_1.userMetadataPda)(user, this.programId);
+            const userMetadata = yield accounts_1.UserMetadata.fetch(this.connection, address, this.programId);
+            return [address, userMetadata];
+        });
+    }
+    getReferrerTokenStateForReserve(referrer, reserve) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [address, _bump] = (0, utils_1.referrerTokenStatePda)(referrer, reserve, this.programId);
+            const referrerTokenState = yield accounts_1.ReferrerTokenState.fetch(this.connection, address, this.programId);
+            return [address, referrerTokenState];
+        });
+    }
+    getAllReferrerTokenStates(referrer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const referrerTokenStates = yield this.connection.getProgramAccounts(this.programId, {
+                filters: [
+                    {
+                        dataSize: accounts_1.ReferrerTokenState.layout.span + 8,
+                    },
+                    {
+                        memcmp: {
+                            offset: 8,
+                            bytes: referrer.toBase58(),
+                        },
+                    },
+                ],
+            });
+            const referrerTokenStatesForMints = new utils_1.PubkeyHashMap();
+            referrerTokenStates.forEach((referrerTokenState) => {
+                if (referrerTokenState.account === null) {
+                    throw new Error('Invalid account');
+                }
+                if (!referrerTokenState.account.owner.equals(this.programId)) {
+                    throw new Error("account doesn't belong to this program");
+                }
+                const referrerTokenStateDecoded = accounts_1.ReferrerTokenState.decode(referrerTokenState.account.data);
+                if (!referrerTokenStateDecoded) {
+                    throw Error('Could not parse obligation.');
+                }
+                referrerTokenStatesForMints.set(referrerTokenStateDecoded.mint, referrerTokenStateDecoded);
+            });
+            return referrerTokenStatesForMints;
+        });
+    }
+    getAllReferrerFeesUnclaimed(referrer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const referrerTokenStatesForMints = yield this.getAllReferrerTokenStates(referrer);
+            const referrerFeesUnclaimedForMints = new utils_1.PubkeyHashMap();
+            for (const mint of referrerTokenStatesForMints.keys()) {
+                referrerFeesUnclaimedForMints.set(mint, new fraction_1.Fraction(referrerTokenStatesForMints.get(mint).amountUnclaimedSf).toDecimal());
+            }
+            return referrerFeesUnclaimedForMints;
+        });
+    }
+    getReferrerFeesUnclaimedForReserve(referrer, reserve) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [, referrerTokenState] = yield this.getReferrerTokenStateForReserve(referrer, reserve.address);
+            return referrerTokenState ? new fraction_1.Fraction(referrerTokenState.amountUnclaimedSf).toDecimal() : new decimal_js_1.default(0);
+        });
+    }
+    getReferrerFeesCumulativeForReserve(referrer, reserve) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [, referrerTokenState] = yield this.getReferrerTokenStateForReserve(referrer, reserve.address);
+            return referrerTokenState ? new fraction_1.Fraction(referrerTokenState.amountCumulativeSf).toDecimal() : new decimal_js_1.default(0);
+        });
+    }
+    getAllReferrerFeesCumulative(referrer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const referrerTokenStatesForMints = yield this.getAllReferrerTokenStates(referrer);
+            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 __awaiter(this, void 0, void 0, function* () {
+            return baseUrl + this.encodeReferrer(referrer);
+        });
+    }
+    getReferrerFromUrl(baseUrl, url) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.decodeReferrer(url.split(baseUrl)[1]);
+        });
+    }
+    encodeReferrer(referrer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return bs58_2.default.encode(referrer.toBuffer());
+        });
+    }
+    decodeReferrer(encoded_referrer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const referrer_buffer = bs58_2.default.decode(encoded_referrer);
+            return new web3_js_1.PublicKey(referrer_buffer.toString());
+        });
+    }
+    /**
+     * Get the underlying connection passed when instantiating this market
+     * @return connection
+     */
+    getConnection() {
+        return this.connection;
+    }
+    /**
+     * Get all Scope prices used by all the market reserves
+     */
+    getAllScopePrices(oraclePrices) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!oraclePrices) {
+                oraclePrices = yield this.scope.getOraclePrices();
+            }
+            const spot = {};
+            const twaps = {};
+            for (const reserve of this.reserves.values()) {
+                const tokenMint = reserve.getLiquidityMint().toString();
+                const tokenName = reserve.getTokenSymbol();
+                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 spotPrice = yield this.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)) {
+                    const twap = yield this.scope.getPriceFromChain(twapChain, oraclePrices);
+                    twaps[tokenMint] = { price: twap.price, name: tokenName };
+                }
+            }
+            return { spot, twap: twaps };
+        });
+    }
+    /**
+     * Get all Scope/Pyth/Switchboard prices used by all the market reserves
+     */
+    getAllPrices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const klendPrices = {
+                scope: { spot: {}, twap: {} },
+                pyth: { spot: {}, twap: {} },
+                switchboard: { spot: {}, twap: {} },
+            };
+            const allOracleAccounts = yield (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 = yield sbv2_lite_1.default.loadMainnet(this.connection);
+            for (const reserve of this.reserves.values()) {
+                const tokenMint = reserve.getLiquidityMint().toString();
+                const tokenName = reserve.getTokenSymbol();
+                const scopeOracle = reserve.state.config.tokenInfo.scopeConfiguration.priceFeed;
+                const spotChain = reserve.state.config.tokenInfo.scopeConfiguration.priceChain;
+                const twapChain = reserve.state.config.tokenInfo.scopeConfiguration.twapChain.filter((x) => x > 0);
+                const pythOracle = reserve.state.config.tokenInfo.pythConfiguration.price;
+                const switchboardSpotOracle = reserve.state.config.tokenInfo.switchboardConfiguration.priceAggregator;
+                const switchboardTwapOracle = reserve.state.config.tokenInfo.switchboardConfiguration.twapAggregator;
+                if ((0, utils_1.isNotNullPubkey)(scopeOracle)) {
+                    const scopePrices = {
+                        spot: (0, utils_1.cacheOrGetScopePrice)(scopeOracle, scopeCache, allOracleAccounts, spotChain),
+                        twap: (0, utils_1.cacheOrGetScopePrice)(scopeOracle, scopeCache, allOracleAccounts, twapChain),
+                    };
+                    this.setPriceIfExist(klendPrices.scope, scopePrices.spot, scopePrices.twap, tokenMint, tokenName);
+                }
+                if ((0, utils_1.isNotNullPubkey)(pythOracle)) {
+                    const pythPrices = (0, utils_1.cacheOrGetPythPrices)(pythOracle, pythCache, allOracleAccounts);
+                    this.setPriceIfExist(klendPrices.pyth, pythPrices === null || pythPrices === void 0 ? void 0 : pythPrices.spot, pythPrices === null || pythPrices === void 0 ? void 0 : pythPrices.twap, tokenMint, tokenName);
+                }
+                if ((0, utils_1.isNotNullPubkey)(switchboardSpotOracle)) {
+                    const switchboardPrices = {
+                        spot: (0, utils_1.cacheOrGetSwitchboardPrice)(switchboardSpotOracle, switchboardCache, allOracleAccounts, switchboardV2),
+                        twap: (0, utils_1.isNotNullPubkey)(switchboardTwapOracle)
+                            ? (0, utils_1.cacheOrGetSwitchboardPrice)(switchboardTwapOracle, switchboardCache, allOracleAccounts, switchboardV2)
+                            : null,
+                    };
+                    this.setPriceIfExist(klendPrices.switchboard, switchboardPrices.spot, switchboardPrices.twap, tokenMint, tokenName);
+                }
+            }
+            return klendPrices;
+        });
+    }
+    getCumulativeBorrowRatesByReserve(slot) {
+        const cumulativeBorrowRates = new utils_1.PubkeyHashMap();
+        for (const reserve of this.reserves.values()) {
+            cumulativeBorrowRates.set(reserve.address, reserve.getEstimatedCumulativeBorrowRate(slot));
+        }
+        return cumulativeBorrowRates;
+    }
+    getCollateralExchangeRatesByReserve(slot) {
+        const collateralExchangeRates = new utils_1.PubkeyHashMap();
+        for (const reserve of this.reserves.values()) {
+            collateralExchangeRates.set(reserve.address, reserve.getEstimatedCollateralExchangeRate(slot, this.state.referralFeeBps));
+        }
+        return collateralExchangeRates;
+    }
+    setPriceIfExist(prices, spot, twap, mint, tokenName) {
+        if (spot) {
+            prices.spot[mint] = { price: spot.price, name: tokenName };
+        }
+        if (twap) {
+            prices.twap[mint] = { price: twap.price, name: tokenName };
+        }
+    }
+}
+exports.KaminoMarket = KaminoMarket;
+function getReservesForMarket(marketAddress, connection, programId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const reserves = yield connection.getProgramAccounts(programId, {
+            filters: [
+                {
+                    dataSize: accounts_1.Reserve.layout.span + 8,
+                },
+                {
+                    memcmp: {
+                        offset: 32,
+                        bytes: marketAddress.toBase58(),
+                    },
+                },
+            ],
+        });
+        const deserializedReserves = reserves.map((reserve) => {
+            if (reserve.account === null) {
+                throw new Error(`Reserve account ${reserve.pubkey.toBase58()} does not exist`);
+            }
+            const reserveAccount = accounts_1.Reserve.decode(reserve.account.data);
+            if (!reserveAccount) {
+                throw Error(`Could not parse reserve ${reserve.pubkey.toBase58()}`);
+            }
+            return reserveAccount;
+        });
+        const allBuffers = reserves.map((reserve) => reserve.account);
+        const reservesAndOracles = yield (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(allBuffers[index], reserves[index].pubkey, reserve, oracle, connection);
+            reservesByAddress.set(kaminoReserve.address, kaminoReserve);
+        });
+        return reservesByAddress;
+    });
+}
+exports.getReservesForMarket = getReservesForMarket;
+function getReservesActive(reserves) {
+    const reservesActive = new utils_1.PubkeyHashMap();
+    for (const [key, reserve] of reserves) {
+        if (reserve.state.config.status === 0) {
+            reservesActive.set(key, reserve);
+        }
+    }
+    return reservesActive;
+}
+exports.getReservesActive = getReservesActive;
+function _getReserveFromMintAndMarket(marketConfig, mint, connection, programId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const reserve = (yield connection.getProgramAccounts(programId, {
+            filters: [
+                {
+                    dataSize: accounts_1.Reserve.layout.span + 8,
+                },
+                {
+                    memcmp: {
+                        offset: 32,
+                        bytes: marketConfig.lendingMarket,
+                    },
+                },
+                {
+                    memcmp: {
+                        offset: 64,
+                        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");
+        }
+        const reserveAccount = accounts_1.Reserve.decode(reserve.account.data);
+        if (!reserveAccount) {
+            throw Error('Could not parse reserve.');
+        }
+        return [reserve.pubkey, reserveAccount];
+    });
+}
+exports._getReserveFromMintAndMarket = _getReserveFromMintAndMarket;
+const lamportsToNumberDecimal = (amount, decimals) => {
+    const factor = Math.pow(10, decimals);
+    return new decimal_js_1.default(amount).div(factor);
+};
+//# sourceMappingURL=market.js.map