@kamino-finance/klend-sdk 2.10.6

package/dist/classes/market.d.ts

@@ -0,0 +1,140 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import { KaminoObligation } from './obligation';
+import { KaminoReserve } from './reserve';
+import { LendingMarket, UserMetadata, ReferrerTokenState, Reserve } from '../idl_codegen/accounts';
+import { MarketConfigType } from './shared';
+import { ObligationType, PubkeyHashMap } from '../utils';
+import Decimal from 'decimal.js';
+import { OraclePrices, Scope } from '@hubbleprotocol/scope-sdk';
+import { KaminoPrices } from '@hubbleprotocol/kamino-sdk';
+export interface ReserveRewardInfo {
+    rewardsPerSecond: Decimal;
+    rewardsRemaining: Decimal;
+    rewardApr: Decimal;
+    rewardMint: PublicKey;
+    totalInvestmentUsd: Decimal;
+    rewardPrice: number;
+}
+export declare class KaminoMarket {
+    private readonly connection;
+    readonly address: string;
+    state: LendingMarket;
+    reserves: Map<PublicKey, KaminoReserve>;
+    reservesActive: Map<PublicKey, KaminoReserve>;
+    readonly programId: PublicKey;
+    scope: Scope;
+    private constructor();
+    /**
+     * Load a new market with all of its associated reserves
+     * @param connection
+     * @param marketAddress
+     * @param programId
+     * @param setupLocalTest
+     */
+    static load(connection: Connection, marketAddress: PublicKey, programId?: PublicKey, setupLocalTest?: boolean, withReserves?: boolean): Promise<KaminoMarket | null>;
+    reload(): Promise<void>;
+    /**
+     * Get the address of this market
+     * @return market address public key
+     */
+    getAddress(): PublicKey;
+    /**
+     * Get a list of reserves for this market
+     */
+    getReserves(): Array<KaminoReserve>;
+    getElevationGroup(elevationGroup: number): import("../idl_codegen/types").ElevationGroup;
+    /**
+     * Get the authority PDA of this market
+     * @return market authority public key
+     */
+    getLendingMarketAuthority(): PublicKey;
+    getObligationDepositByWallet(owner: PublicKey, mint: PublicKey, obligationType: ObligationType): Promise<Decimal>;
+    getObligationBorrowByWallet(owner: PublicKey, mint: PublicKey, obligationType: ObligationType): Promise<Decimal>;
+    getTotalDepositTVL(): Decimal;
+    getTotalBorrowTVL(): Decimal;
+    getMaxLeverageForPair(collTokenMint: PublicKey, debtTokenMint: PublicKey): number;
+    getMaxAndLiquidationLtvAndBorrowFactorForPair(collTokenMint: PublicKey, debtTokenMint: PublicKey): {
+        maxLtv: number;
+        liquidationLtv: number;
+        borrowFactor: number;
+    };
+    getTotalProductTvl(productType: ObligationType): Promise<{
+        tvl: Decimal;
+        borrows: Decimal;
+        deposits: Decimal;
+        avgLeverage: Decimal;
+    }>;
+    /**
+     *
+     * @returns Number of active obligations in the market
+     */
+    getNumberOfObligations(): Promise<number>;
+    getObligationByWallet(publicKey: PublicKey, obligationType: ObligationType): Promise<KaminoObligation | null>;
+    loadReserves(): Promise<void>;
+    refreshAll(): Promise<void>;
+    getReserveByAddress(address: PublicKey): KaminoReserve | undefined;
+    getReserveByMint(address: PublicKey): KaminoReserve | undefined;
+    getReserveBySymbol(symbol: string): KaminoReserve | undefined;
+    getReserveMintBySymbol(symbol: string): PublicKey | undefined;
+    getReserveFarmInfo(mint: PublicKey, getRewardPrice: (mint: PublicKey) => Promise<number>): Promise<{
+        borrowingRewards: ReserveRewardInfo;
+        depositingRewards: ReserveRewardInfo;
+    }>;
+    getRewardInfoForFarm(farmAddress: PublicKey, totalInvestmentUsd: Decimal, getRewardPrice: (mint: PublicKey) => Promise<number>): Promise<ReserveRewardInfo>;
+    calculateRewardAPR(rewardPerSecondLamports: number, rewardPriceUsd: number, totalInvestmentUsd: Decimal, rewardDecimals: number): Decimal;
+    getAllObligationsForMarket(tag?: number): Promise<KaminoObligation[]>;
+    /**
+     * 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?: number): AsyncGenerator<KaminoObligation[], void, unknown>;
+    getAllObligationsByTag(tag: number, market: PublicKey): Promise<KaminoObligation[]>;
+    getAllUserObligations(user: PublicKey): Promise<KaminoObligation[]>;
+    getUserObligationsByTag(tag: number, user: PublicKey): Promise<KaminoObligation[]>;
+    getObligationByAddress(address: PublicKey): Promise<KaminoObligation | null>;
+    getMultipleObligationsByAddress(addresses: PublicKey[]): Promise<(KaminoObligation | null)[]>;
+    /**
+     * 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: PublicKey): Promise<[PublicKey, UserMetadata | null]>;
+    getReferrerTokenStateForReserve(referrer: PublicKey, reserve: PublicKey): Promise<[PublicKey, ReferrerTokenState | null]>;
+    getAllReferrerTokenStates(referrer: PublicKey): Promise<PubkeyHashMap<PublicKey, ReferrerTokenState>>;
+    getAllReferrerFeesUnclaimed(referrer: PublicKey): Promise<PubkeyHashMap<PublicKey, Decimal>>;
+    getReferrerFeesUnclaimedForReserve(referrer: PublicKey, reserve: KaminoReserve): Promise<Decimal>;
+    getReferrerFeesCumulativeForReserve(referrer: PublicKey, reserve: KaminoReserve): Promise<Decimal>;
+    getAllReferrerFeesCumulative(referrer: PublicKey): Promise<PubkeyHashMap<PublicKey, Decimal>>;
+    getReferrerUrl(baseUrl: string, referrer: PublicKey): Promise<string>;
+    getReferrerFromUrl(baseUrl: string, url: string): Promise<PublicKey>;
+    encodeReferrer(referrer: PublicKey): Promise<string>;
+    decodeReferrer(encoded_referrer: string): Promise<PublicKey>;
+    /**
+     * Get the underlying connection passed when instantiating this market
+     * @return connection
+     */
+    getConnection(): Connection;
+    /**
+     * Get all Scope prices used by all the market reserves
+     */
+    getAllScopePrices(oraclePrices?: OraclePrices): Promise<KaminoPrices>;
+    /**
+     * Get all Scope/Pyth/Switchboard prices used by all the market reserves
+     */
+    getAllPrices(): Promise<KlendPrices>;
+    getCumulativeBorrowRatesByReserve(slot: number): Map<PublicKey, Decimal>;
+    getCollateralExchangeRatesByReserve(slot: number): Map<PublicKey, Decimal>;
+    private setPriceIfExist;
+}
+export type KlendPrices = {
+    scope: KaminoPrices;
+    pyth: KaminoPrices;
+    switchboard: KaminoPrices;
+};
+export declare function getReservesForMarket(marketAddress: PublicKey, connection: Connection, programId: PublicKey): Promise<Map<PublicKey, KaminoReserve>>;
+export declare function getReservesActive(reserves: Map<PublicKey, KaminoReserve>): Map<PublicKey, KaminoReserve>;
+export declare function _getReserveFromMintAndMarket(marketConfig: MarketConfigType, mint: string, connection: Connection, programId: PublicKey): Promise<[PublicKey, Reserve]>;