@kestrelfi/lyc-sdk 1.0.1

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

@@ -0,0 +1,175 @@
+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

@@ -0,0 +1,192 @@
+"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

@@ -0,0 +1,7 @@
+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

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

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

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

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

@@ -0,0 +1,18 @@
+"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

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,206 @@
+"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;