@kestrelfi/lyc-sdk 1.0.1 → 1.0.3

package/dist/shared/lending-platforms/src/data/instructions/lpInstructionsBase.d.ts

@@ -1,175 +0,0 @@
-import { BN } from "@anchor-lang/core";
-import { Address, Instruction, Rpc, SolanaRpcApi } from "@solana/kit";
-import { LendingPlatformData } from "../platform";
-import { CpiData, CustomAccountMeta, TransactionCacheInvalidation } from "common";
-import { LpAccountsBase } from "../accounts";
-import { RefreshPrerequisiteTarget } from "./types";
-/** Parameters for deposit, withdraw, and borrow operations */
-export interface LendingOperationParams {
-    user: Address;
-    payer: Address;
-    pool: Address;
-    reserve: Address;
-    userAccount: Address;
-    /**
-     * UI-unit amount, or `"all"` (withdraw-only) to encode the platform's
-     * "withdraw all" sentinel (Kamino: `u64::MAX` collateral amount) so the
-     * obligation's deposit is fully drained on-chain — no dust left behind
-     * from off-chain cToken/liquidity rate drift.
-     *
-     * If neither this nor {@link baseUnitAmount} is provided, the amount is
-     * implied to be derived in the program.
-     */
-    uiAmount?: number | "all";
-    /**
-     * Exact liquidity base units for the operation (e.g. lamports for SOL). Prefer over
-     * {@link uiAmount} when float round-trips would undershoot on-chain requirements.
-     * Pass `"all"` (withdraw-only) for the same sentinel semantics as {@link uiAmount}.
-     */
-    baseUnitAmount?: BN | "all";
-    txId: string;
-}
-/** Parameters for repay operations, with option for full repayment */
-export interface RepayOperationParams extends LendingOperationParams {
-    /** Repay amount in UI units. The withdraw-only `"all"` sentinel is not valid here. */
-    uiAmount?: number;
-    /** Exact repay amount in liquidity base units. */
-    baseUnitAmount?: BN;
-    /** When true, repays the entire debt balance regardless of `amount` */
-    full?: boolean;
-}
-/** CPI data split into instruction-level prerequisite CPIs and main operation CPIs. */
-export interface SplitLpOperationCpiData {
-    prerequisiteCpis: CpiData[];
-    cpis: CpiData[];
-    allCpis: CpiData[];
-}
-/** Split CPI data plus flattened post-success cache invalidations from all nested CPIs. */
-export interface LendingOperationCpiBundle extends SplitLpOperationCpiData {
-    postSuccessCacheInvalidations: TransactionCacheInvalidation[];
-}
-/** Whether a reserve is used as collateral or debt for a user account */
-export type ReserveRole = "collateral" | "debt";
-/** Tracks a reserve's pool and which user accounts reference it (with roles) */
-export interface TxReserveInfo {
-    pool: Address;
-    userAccounts: Map<string, Set<ReserveRole>>;
-}
-/**
- * Abstract base class for lending platform instruction builders.
- * Provides a unified interface for building CPI data for different lending protocols.
- * Each platform implementation provides the account metas needed to construct CPI calls.
- *
- * @typeParam T - The platform-specific data class extending LendingPlatformData
- */
-export declare abstract class LpInstructionsBase<T extends LendingPlatformData> {
-    rpc: Rpc<SolanaRpcApi>;
-    rpcUrl: string;
-    data: T;
-    abstract programId: Address;
-    abstract lookupTable: Address;
-    accounts: LpAccountsBase<T>;
-    /** Tracks which reserves (and their pools/roles) are involved in each transaction */
-    protected txReserves: Map<string, Map<string, TxReserveInfo>>;
-    /**
-     * Per-txId per-obligation set of debt reserves that the caller has flagged
-     * as being fully repaid earlier in the same transaction. Subsequent
-     * `RefreshObligation` builds for that obligation must NOT include these
-     * reserves in the borrow accounts list — by execution time the borrow row
-     * has been removed from the obligation, and Kamino's `handler_refresh_obligation`
-     * checks the passed account count against the live obligation state and
-     * fails with `InvalidAccountInput` (klend error 6006) on a mismatch.
-     *
-     * Set via {@link markObligationDebtCleared}, read via {@link getTxObligationClearedDebt}.
-     */
-    protected txClearedDebt: Map<string, Map<string, Set<string>>>;
-    constructor(rpc: Rpc<SolanaRpcApi>, rpcUrl: string, data: T, accounts: LpAccountsBase<T>);
-    emptyAccountMeta(): CustomAccountMeta;
-    clearCacheEntry(category: string, id: string): void;
-    protected getCacheInvalidation(invalidation: {
-        category: string;
-        id: Address;
-    }): TransactionCacheInvalidation;
-    applyPostSuccessCacheInvalidations(invalidations: TransactionCacheInvalidation[]): void;
-    protected getCpiData(cpiType: number, accounts: CustomAccountMeta[], data?: Uint8Array, programId?: Address, postSuccessCacheInvalidations?: TransactionCacheInvalidation[]): CpiData;
-    protected createSplitOperationCpiData(prerequisiteCpis: CpiData[], cpis: CpiData[]): SplitLpOperationCpiData;
-    protected buildLendingOperationCpiBundle(cpiData: SplitLpOperationCpiData): LendingOperationCpiBundle;
-    getInitAndDepositCpiBundle(params: LendingOperationParams, userAccountId: number): Promise<LendingOperationCpiBundle>;
-    getInitBorrowPositionCpiBundle(params: LendingOperationParams, collReserve: Address): Promise<LendingOperationCpiBundle>;
-    getDepositCpiBundle(params: LendingOperationParams): Promise<LendingOperationCpiBundle>;
-    getWithdrawCpiBundle(params: LendingOperationParams): Promise<LendingOperationCpiBundle>;
-    getBorrowCpiBundle(params: LendingOperationParams): Promise<LendingOperationCpiBundle>;
-    getRepayCpiBundle(params: RepayOperationParams): Promise<LendingOperationCpiBundle>;
-    /**
-     * Registers a reserve as being used in a transaction.
-     * When userAccount and role are provided, also tracks the collateral/debt role
-     * for that specific user account.
-     */
-    protected registerTxReserve(txId: string, pool: Address, reserve: Address, userAccount?: Address, role?: ReserveRole): void;
-    /**
-     * Returns the collateral and debt reserves registered in the tx cache
-     * for a specific user account (obligation).
-     */
-    protected getTxUserAccountReserves(txId: string, userAccount: Address): {
-        collateral: Address[];
-        debt: Address[];
-    };
-    /**
-     * Mark that `reserve` will be fully repaid for `userAccount` earlier in the
-     * `txId` flow, so subsequent obligation-refresh builders drop it from the
-     * borrow accounts they emit. Call after building a "repay all" CPI; it has
-     * no effect on the repay itself.
-     */
-    markObligationDebtCleared(txId: string, userAccount: Address, reserve: Address): void;
-    /** Returns the set of debt reserves marked cleared for `(txId, userAccount)`. */
-    protected getTxObligationClearedDebt(txId: string, userAccount: Address): Set<Address>;
-    /**
-     * Clears the transaction cache for a given transaction or all transactions.
-     * Call after finishing building a transaction to free memory.
-     */
-    clearTransactionCache(txId?: string): void;
-    /**
-     * Returns standalone instructions that must be executed at the top level
-     * BEFORE the the main CPIs. Should be called after all CPI methods for this
-     * txId have been invoked.
-     */
-    abstract getPreInstructions(txId: string): Promise<Instruction[]>;
-    /**
-     * Returns prerequisite CPIs needed before reading refreshed account state for
-     * a batch of lending positions outside a normal deposit/withdraw/borrow/repay
-     * flow.
-     */
-    getPrerequisiteCpisForRefresh(_targets: RefreshPrerequisiteTarget[]): Promise<CpiData[]>;
-    /** Returns CPI data for initializing a user's lending account */
-    abstract getInitUserAccountCpiData(pool: Address, user: Address, feePayer: Address, id: number): Promise<SplitLpOperationCpiData>;
-    /**
-     * Returns CPI data for initializing a lending position end-to-end: the user
-     * account itself plus any per-reserve accessory accounts (e.g. Kamino
-     * obligation farm user states for the collateral and debt reserves). Called
-     * at position-creation time so subsequent deposit/borrow flows don't need
-     * to init these inline.
-     *
-     * Default: delegates to {@link getInitUserAccountCpiData}. Platforms with
-     * per-reserve accessory accounts override this to add their inits.
-     */
-    getInitLendingPositionCpiData(params: {
-        pool: Address;
-        user: Address;
-        payer: Address;
-        userAccountId: number;
-        collateralReserve: Address;
-        debtReserve: Address;
-    }): Promise<SplitLpOperationCpiData>;
-    /** Returns CPI data for initializing user account, incentive account (if necessary) and depositing */
-    abstract getInitAndDepositCpiData(params: LendingOperationParams, userAccountId: number): Promise<SplitLpOperationCpiData>;
-    /** Returns CPI data for initializing a new borrow position */
-    abstract getInitBorrowPositionCpiData(params: LendingOperationParams, collReserve: Address): Promise<SplitLpOperationCpiData>;
-    /** Returns deposit CPI data split into optional prerequisite CPIs and main CPIs. */
-    abstract getDepositCpiData(params: LendingOperationParams): Promise<SplitLpOperationCpiData>;
-    /** Returns withdraw CPI data split into optional prerequisite CPIs and main CPIs. */
-    abstract getWithdrawCpiData(params: LendingOperationParams): Promise<SplitLpOperationCpiData>;
-    /** Returns borrow CPI data split into optional prerequisite CPIs and main CPIs. */
-    abstract getBorrowCpiData(params: LendingOperationParams): Promise<SplitLpOperationCpiData>;
-    /** Returns repay CPI data split into optional prerequisite CPIs and main CPIs. */
-    abstract getRepayCpiData(params: RepayOperationParams): Promise<SplitLpOperationCpiData>;
-}

package/dist/shared/lending-platforms/src/data/instructions/lpInstructionsBase.js

@@ -1,192 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LpInstructionsBase = void 0;
-const common_1 = require("common");
-/**
- * Abstract base class for lending platform instruction builders.
- * Provides a unified interface for building CPI data for different lending protocols.
- * Each platform implementation provides the account metas needed to construct CPI calls.
- *
- * @typeParam T - The platform-specific data class extending LendingPlatformData
- */
-class LpInstructionsBase {
-    constructor(rpc, rpcUrl, data, accounts) {
-        /** Tracks which reserves (and their pools/roles) are involved in each transaction */
-        this.txReserves = new Map();
-        /**
-         * Per-txId per-obligation set of debt reserves that the caller has flagged
-         * as being fully repaid earlier in the same transaction. Subsequent
-         * `RefreshObligation` builds for that obligation must NOT include these
-         * reserves in the borrow accounts list — by execution time the borrow row
-         * has been removed from the obligation, and Kamino's `handler_refresh_obligation`
-         * checks the passed account count against the live obligation state and
-         * fails with `InvalidAccountInput` (klend error 6006) on a mismatch.
-         *
-         * Set via {@link markObligationDebtCleared}, read via {@link getTxObligationClearedDebt}.
-         */
-        this.txClearedDebt = new Map();
-        this.rpc = rpc;
-        this.rpcUrl = rpcUrl;
-        this.data = data;
-        this.accounts = accounts;
-    }
-    emptyAccountMeta() {
-        return (0, common_1.toCustomAccountMeta)(this.programId);
-    }
-    clearCacheEntry(category, id) {
-        this.data.clearCacheEntry(category, id);
-    }
-    getCacheInvalidation(invalidation) {
-        return {
-            client: "kamino",
-            ...invalidation,
-        };
-    }
-    applyPostSuccessCacheInvalidations(invalidations) {
-        for (const invalidation of invalidations) {
-            if (invalidation.client !== "kamino") {
-                continue;
-            }
-            this.clearCacheEntry(invalidation.category, invalidation.id);
-        }
-    }
-    getCpiData(cpiType, accounts, data, programId, postSuccessCacheInvalidations) {
-        return {
-            programId: programId ?? this.programId,
-            cpiType,
-            data,
-            accounts,
-            lookupTables: [this.lookupTable],
-            postSuccessCacheInvalidations,
-        };
-    }
-    createSplitOperationCpiData(prerequisiteCpis, cpis) {
-        return {
-            prerequisiteCpis,
-            cpis,
-            allCpis: [...prerequisiteCpis, ...cpis],
-        };
-    }
-    buildLendingOperationCpiBundle(cpiData) {
-        return {
-            prerequisiteCpis: cpiData.prerequisiteCpis,
-            cpis: cpiData.cpis,
-            allCpis: [...cpiData.prerequisiteCpis, ...cpiData.cpis],
-            postSuccessCacheInvalidations: [...cpiData.prerequisiteCpis, ...cpiData.cpis].flatMap((cpi) => cpi.postSuccessCacheInvalidations ?? []),
-        };
-    }
-    async getInitAndDepositCpiBundle(params, userAccountId) {
-        return this.buildLendingOperationCpiBundle(await this.getInitAndDepositCpiData(params, userAccountId));
-    }
-    async getInitBorrowPositionCpiBundle(params, collReserve) {
-        return this.buildLendingOperationCpiBundle(await this.getInitBorrowPositionCpiData(params, collReserve));
-    }
-    async getDepositCpiBundle(params) {
-        return this.buildLendingOperationCpiBundle(await this.getDepositCpiData(params));
-    }
-    async getWithdrawCpiBundle(params) {
-        return this.buildLendingOperationCpiBundle(await this.getWithdrawCpiData(params));
-    }
-    async getBorrowCpiBundle(params) {
-        return this.buildLendingOperationCpiBundle(await this.getBorrowCpiData(params));
-    }
-    async getRepayCpiBundle(params) {
-        return this.buildLendingOperationCpiBundle(await this.getRepayCpiData(params));
-    }
-    /**
-     * Registers a reserve as being used in a transaction.
-     * When userAccount and role are provided, also tracks the collateral/debt role
-     * for that specific user account.
-     */
-    registerTxReserve(txId, pool, reserve, userAccount, role) {
-        if (!this.txReserves.has(txId)) {
-            this.txReserves.set(txId, new Map());
-        }
-        const txMap = this.txReserves.get(txId);
-        if (!txMap.has(reserve)) {
-            txMap.set(reserve, { pool, userAccounts: new Map() });
-        }
-        if (userAccount && role) {
-            const entry = txMap.get(reserve);
-            if (!entry.userAccounts.has(userAccount)) {
-                entry.userAccounts.set(userAccount, new Set());
-            }
-            entry.userAccounts.get(userAccount).add(role);
-        }
-    }
-    /**
-     * Returns the collateral and debt reserves registered in the tx cache
-     * for a specific user account (obligation).
-     */
-    getTxUserAccountReserves(txId, userAccount) {
-        const collateral = [];
-        const debt = [];
-        const txMap = this.txReserves.get(txId);
-        if (!txMap)
-            return { collateral, debt };
-        for (const [reserve, info] of txMap) {
-            const roles = info.userAccounts.get(userAccount);
-            if (roles?.has("collateral"))
-                collateral.push(reserve);
-            if (roles?.has("debt"))
-                debt.push(reserve);
-        }
-        return { collateral, debt };
-    }
-    /**
-     * Mark that `reserve` will be fully repaid for `userAccount` earlier in the
-     * `txId` flow, so subsequent obligation-refresh builders drop it from the
-     * borrow accounts they emit. Call after building a "repay all" CPI; it has
-     * no effect on the repay itself.
-     */
-    markObligationDebtCleared(txId, userAccount, reserve) {
-        if (!this.txClearedDebt.has(txId)) {
-            this.txClearedDebt.set(txId, new Map());
-        }
-        const obligationMap = this.txClearedDebt.get(txId);
-        if (!obligationMap.has(userAccount)) {
-            obligationMap.set(userAccount, new Set());
-        }
-        obligationMap.get(userAccount).add(reserve);
-    }
-    /** Returns the set of debt reserves marked cleared for `(txId, userAccount)`. */
-    getTxObligationClearedDebt(txId, userAccount) {
-        return (this.txClearedDebt.get(txId)?.get(userAccount) ?? new Set());
-    }
-    /**
-     * Clears the transaction cache for a given transaction or all transactions.
-     * Call after finishing building a transaction to free memory.
-     */
-    clearTransactionCache(txId) {
-        if (txId) {
-            this.txReserves.delete(txId);
-            this.txClearedDebt.delete(txId);
-        }
-        else {
-            this.txReserves.clear();
-            this.txClearedDebt.clear();
-        }
-    }
-    /**
-     * Returns prerequisite CPIs needed before reading refreshed account state for
-     * a batch of lending positions outside a normal deposit/withdraw/borrow/repay
-     * flow.
-     */
-    async getPrerequisiteCpisForRefresh(_targets) {
-        return [];
-    }
-    /**
-     * Returns CPI data for initializing a lending position end-to-end: the user
-     * account itself plus any per-reserve accessory accounts (e.g. Kamino
-     * obligation farm user states for the collateral and debt reserves). Called
-     * at position-creation time so subsequent deposit/borrow flows don't need
-     * to init these inline.
-     *
-     * Default: delegates to {@link getInitUserAccountCpiData}. Platforms with
-     * per-reserve accessory accounts override this to add their inits.
-     */
-    async getInitLendingPositionCpiData(params) {
-        return this.getInitUserAccountCpiData(params.pool, params.user, params.payer, params.userAccountId);
-    }
-}
-exports.LpInstructionsBase = LpInstructionsBase;

package/dist/shared/lending-platforms/src/data/instructions/types.d.ts

@@ -1,7 +0,0 @@
-import { Address } from "@solana/kit";
-export interface RefreshPrerequisiteTarget {
-    pool: Address;
-    userAccount: Address;
-    collateralReserves: Address[];
-    debtReserves: Address[];
-}

package/dist/shared/lending-platforms/src/data/instructions/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/shared/lending-platforms/src/data/platform/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./kamino";
-export * from "./lpDataBase";

package/dist/shared/lending-platforms/src/data/platform/index.js

@@ -1,18 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./kamino"), exports);
-__exportStar(require("./lpDataBase"), exports);

package/dist/shared/lending-platforms/src/data/platform/kamino.d.ts

@@ -1,59 +0,0 @@
-import { type Address } from "@solana/kit";
-import { KaminoMarket, KaminoObligation, KlendPrices } from "@kamino-finance/klend-sdk";
-import { Farms, FarmState, UserFarm } from "@kamino-finance/farms-sdk";
-import { LendingPlatformData } from "./lpDataBase";
-import { KaminoReserveData, KaminoUserPositionData } from "..";
-import { LendingPlatform } from "../../types";
-import { OraclePrices } from "@kamino-finance/scope-sdk/dist/@codegen/scope/accounts";
-import { CacheTtlConfig } from "common";
-/** Cache configuration for Kamino data with optional market-specific TTL */
-export interface KaminoCacheConfig extends CacheTtlConfig {
-    marketsTtlMs?: number;
-}
-/**
- * Data provider for Kamino Lend protocol.
- * Handles fetching and caching of markets, reserves, obligations, farms, and prices.
- * Supports both standard reserve farms and "extra" farms (paired collateral/debt incentives).
- */
-export declare class KaminoData extends LendingPlatformData {
-    farms: Farms;
-    private scope;
-    constructor(rpcUrl: string, cacheConfig?: KaminoCacheConfig, rpcUrls?: string[]);
-    platform(): LendingPlatform;
-    /**
-     * Warms the market cache for the requested pools. Single-pool calls reuse the
-     * normal lazy fetch path; multi-pool calls use Kamino's batched loader.
-     */
-    load(pools: Address[]): Promise<void>;
-    /** Fetches a market by address, loading from cache if available */
-    fetchMarket(market: Address): Promise<KaminoMarket>;
-    /** Fetches all oracle prices for assets in the specified market */
-    fetchPrices(pool: Address): Promise<KlendPrices>;
-    /** Fetches an obligation (user position) by address */
-    fetchObligation(market: KaminoMarket, obligation: Address): Promise<KaminoObligation | null>;
-    /** Batch fetches farm states by their addresses */
-    fetchFarms(farms: Address[]): Promise<FarmState[]>;
-    private fetchExtraFarms;
-    /**
-     * Collects all farm incentives for a reserve, including both standard
-     * collateral/debt farms and extra paired farms from Kamino CDN config.
-     */
-    private fetchFarmsForReserve;
-    fetchUserActiveIncentives(user: Address, specificFarm?: Address): Promise<UserFarm[]>;
-    maybeFetchUserPositionInPool(pool: Address, userPosition: Address): Promise<KaminoUserPositionData | null>;
-    fetchUserPositionsInPool(pool: Address, userPositions: Address[]): Promise<KaminoUserPositionData[]>;
-    fetchAllUserPositionsForUserInPool(pool: Address, user: Address): Promise<KaminoUserPositionData[]>;
-    fetchReserve(pool: Address, reserve: Address): Promise<KaminoReserveData>;
-    fetchReserveByMint(pool: Address, mint: Address): Promise<KaminoReserveData>;
-    private mapReserve;
-    /**
-     * Fetches and caches the Scope OraclePrices account for a given price feed.
-     * @returns The deserialized OraclePrices, or null if the account doesn't exist
-     */
-    fetchScopeOraclePrices(priceFeed: Address): Promise<OraclePrices | null>;
-    /**
-     * Resolves and caches the Scope Configuration account address for a given OraclePrices account.
-     * The first call per price feed does a getProgramAccounts lookup; subsequent calls use cache.
-     */
-    fetchScopeConfigAddress(priceFeed: Address): Promise<Address>;
-}

package/dist/shared/lending-platforms/src/data/platform/kamino.js

@@ -1,206 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.KaminoData = void 0;
-const klend_sdk_1 = require("@kamino-finance/klend-sdk");
-const scope_sdk_1 = require("@kamino-finance/scope-sdk");
-const farms_sdk_1 = require("@kamino-finance/farms-sdk");
-const lpDataBase_1 = require("./lpDataBase");
-const __1 = require("..");
-const constants_1 = require("../../constants");
-const types_1 = require("../../types");
-const utils_1 = require("../../utils");
-const common_1 = require("common");
-const decimal_js_1 = __importDefault(require("decimal.js"));
-/**
- * Data provider for Kamino Lend protocol.
- * Handles fetching and caching of markets, reserves, obligations, farms, and prices.
- * Supports both standard reserve farms and "extra" farms (paired collateral/debt incentives).
- */
-class KaminoData extends lpDataBase_1.LendingPlatformData {
-    constructor(rpcUrl, cacheConfig, rpcUrls = [rpcUrl]) {
-        const ttlConfig = {
-            defaultTtlMs: 90000,
-            categoryTtlMs: {
-                ...cacheConfig?.categoryTtlMs,
-                markets: 60000 * 5,
-                farms: 60000 * 5,
-                extraFarms: Number.MAX_SAFE_INTEGER,
-                scopeOraclePrices: 30000,
-                scopeConfig: 60000 * 5,
-            },
-        };
-        super(rpcUrl, ttlConfig, rpcUrls);
-        this.farms = new farms_sdk_1.Farms(this.rpc, constants_1.KAMINO_FARMS_PROGRAM_ID);
-        this.scope = new scope_sdk_1.Scope("mainnet-beta", this.rpc);
-    }
-    platform() {
-        return types_1.LendingPlatform.Kamino;
-    }
-    /**
-     * Warms the market cache for the requested pools. Single-pool calls reuse the
-     * normal lazy fetch path; multi-pool calls use Kamino's batched loader.
-     */
-    async load(pools) {
-        if (pools.length === 0)
-            return;
-        if (pools.length === 1) {
-            await this.fetchMarket(pools[0]);
-            return;
-        }
-        const { data: markets, fromCache } = await this.cache.getDataBatch(async () => {
-            const marketsData = await klend_sdk_1.KaminoMarket.loadMultiple(this.rpc, pools, klend_sdk_1.DEFAULT_RECENT_SLOT_DURATION_MS, klend_sdk_1.PROGRAM_ID, true);
-            return pools.map((pool) => marketsData.get(pool) ?? null);
-        }, this.poolCatKey, pools);
-        if (!fromCache) {
-            await Promise.all(markets.map(async (market) => await market.loadReserves()));
-        }
-    }
-    /** Fetches a market by address, loading from cache if available */
-    async fetchMarket(market) {
-        const { data, fromCache } = await this.cache.getDataOrThrow(async () => await klend_sdk_1.KaminoMarket.load(this.rpc, market, klend_sdk_1.DEFAULT_RECENT_SLOT_DURATION_MS, klend_sdk_1.PROGRAM_ID, true), this.poolCatKey, market);
-        if (!fromCache) {
-            await data.loadReserves();
-        }
-        return data;
-    }
-    /** Fetches all oracle prices for assets in the specified market */
-    async fetchPrices(pool) {
-        const market = await this.fetchMarket(pool);
-        const { data } = await this.cache.getDataOrThrow(async () => await market.getAllPrices(), "prices", "queryAll");
-        return data;
-    }
-    /** Fetches an obligation (user position) by address */
-    async fetchObligation(market, obligation) {
-        const { data } = await this.cache.getData(async () => await market.getObligationByAddress(obligation), this.userAccountCatKey, obligation, { cacheNull: false });
-        return data;
-    }
-    /** Batch fetches farm states by their addresses */
-    async fetchFarms(farms) {
-        const { data } = await this.cache.getDataBatch(async () => (await this.farms.getAllFarmStatesByPubkeys(farms)).map((x) => x.farmState), "userFarms", farms);
-        return data;
-    }
-    async fetchExtraFarms() {
-        const { data } = await this.cache.getDataOrThrow(async () => await (0, utils_1.fetchExtraFarms)(), "extraFarms", "mainnet-beta");
-        return data;
-    }
-    /**
-     * Collects all farm incentives for a reserve, including both standard
-     * collateral/debt farms and extra paired farms from Kamino CDN config.
-     */
-    async fetchFarmsForReserve(pool, reserve) {
-        const market = await this.fetchMarket(pool);
-        const reserveData = market.getReserveByAddress(reserve);
-        if (!reserveData) {
-            throw new Error(`Unable to find reserve ${reserve}`);
-        }
-        const farms = [];
-        const farmCollateral = reserveData.state.farmCollateral;
-        const farmDebt = reserveData.state.farmDebt;
-        if (farmCollateral && farmCollateral !== klend_sdk_1.DEFAULT_PUBLIC_KEY) {
-            farms.push({ address: farmCollateral, isDebtFarm: false });
-        }
-        if (farmDebt && farmDebt !== klend_sdk_1.DEFAULT_PUBLIC_KEY) {
-            farms.push({ address: farmDebt, isDebtFarm: true });
-        }
-        const extraFarmsData = (await this.fetchExtraFarms()).filter((x) => x.collReserve === reserve || x.debtReserve === reserve);
-        const extraFarmEntries = extraFarmsData.map((x) => ({
-            address: x.farm,
-            isDebtFarm: x.debtReserve === reserve,
-        }));
-        const allFarmEntries = [...farms, ...extraFarmEntries];
-        const allFarmAddresses = allFarmEntries.map((f) => f.address);
-        if (!allFarmAddresses.length) {
-            return [];
-        }
-        const farmStates = await this.fetchFarms(allFarmAddresses);
-        const result = [];
-        farmStates.forEach((farmState, i) => {
-            const farmEntry = allFarmEntries[i];
-            const isExtraFarm = i >= farms.length;
-            const extraFarmIndex = i - farms.length;
-            farmState.rewardInfos.forEach((rewardInfo, rewardIndex) => {
-                if (rewardInfo.rewardsVault === klend_sdk_1.DEFAULT_PUBLIC_KEY) {
-                    return;
-                }
-                result.push({
-                    data: {
-                        key: farmEntry.address,
-                        farmState,
-                    },
-                    rewardIndex,
-                    requiresPairReserve: isExtraFarm ? extraFarmsData[extraFarmIndex].debtReserve : undefined,
-                    isDebtFarm: farmEntry.isDebtFarm,
-                });
-            });
-        });
-        return result;
-    }
-    async fetchUserActiveIncentives(user, specificFarm) {
-        let { data } = await this.cache.getDataOrThrow(async () => {
-            return Array.from((await this.farms.getAllFarmsForUserMultiState(user, new decimal_js_1.default((0, common_1.currentUnixSeconds)()))).values()).flat();
-        }, "userFarms", user);
-        if (specificFarm) {
-            data = data.filter((x) => x.farm === specificFarm);
-        }
-        return data;
-    }
-    async maybeFetchUserPositionInPool(pool, userPosition) {
-        const market = await this.fetchMarket(pool);
-        const obligation = await this.fetchObligation(market, userPosition);
-        return obligation ? __1.KaminoUserPositionData.loadData(obligation) : null;
-    }
-    async fetchUserPositionsInPool(pool, userPositions) {
-        const market = await this.fetchMarket(pool);
-        const { data } = await this.cache.getDataBatch(async () => await market.getMultipleObligationsByAddress(userPositions), this.userAccountCatKey, userPositions);
-        return data.map((obligation) => __1.KaminoUserPositionData.loadData(obligation));
-    }
-    async fetchAllUserPositionsForUserInPool(pool, user) {
-        const market = await this.fetchMarket(pool);
-        const { data } = await this.cache.getDataOrThrow(async () => await market.getAllUserObligations(user, "confirmed"), "obligationsBatch", user);
-        return data.map((obligation) => __1.KaminoUserPositionData.loadData(obligation));
-    }
-    async fetchReserve(pool, reserve) {
-        const market = await this.fetchMarket(pool);
-        const reserveData = market.getReserveByAddress(reserve);
-        if (!reserveData) {
-            throw new Error(`Unable to find reserve ${reserve}`);
-        }
-        return this.mapReserve(market, reserveData);
-    }
-    async fetchReserveByMint(pool, mint) {
-        const market = await this.fetchMarket(pool);
-        const reserveData = market.getReserveByMint(mint);
-        if (!reserveData) {
-            throw new Error(`Unable to find reserve by mint ${mint}`);
-        }
-        return this.mapReserve(market, reserveData);
-    }
-    async mapReserve(market, reserve) {
-        return __1.KaminoReserveData.loadData(market, reserve, await this.fetchFarmsForReserve(market.address, reserve.address), await this.fetchPrices(market.address), await this.getSlot());
-    }
-    /**
-     * Fetches and caches the Scope OraclePrices account for a given price feed.
-     * @returns The deserialized OraclePrices, or null if the account doesn't exist
-     */
-    async fetchScopeOraclePrices(priceFeed) {
-        const { data } = await this.cache.getData(async () => await this.scope.getSingleOraclePrices({ prices: priceFeed }), "scopeOraclePrices", priceFeed);
-        return data;
-    }
-    /**
-     * Resolves and caches the Scope Configuration account address for a given OraclePrices account.
-     * The first call per price feed does a getProgramAccounts lookup; subsequent calls use cache.
-     */
-    async fetchScopeConfigAddress(priceFeed) {
-        const { data } = await this.cache.getDataOrThrow(async () => {
-            const [configAddr] = await this.scope.getSingleFeedConfiguration({
-                prices: priceFeed,
-            });
-            return configAddr;
-        }, "scopeConfig", priceFeed);
-        return data;
-    }
-}
-exports.KaminoData = KaminoData;