@kestrelfi/lyc-sdk 1.0.1

package/dist/shared/lending-platforms/src/services/leverage/types.d.ts

@@ -0,0 +1,261 @@
+import type { Address, Instruction } from "@solana/kit";
+import type BN from "bn.js";
+import type { CpiData, Environment, SwapClient, TransactionCacheInvalidation } from "common";
+import type { LendingPlatformData } from "../../data";
+import type { LpInstructionsBase } from "../../data/instructions/lpInstructionsBase";
+import type { ReserveBase } from "../../data/reserve/reserveBase";
+import type { FlashLoanBase } from "../flashLoan";
+/**
+ * How the position changes when debt is adjusted.
+ *
+ * - `levered` — flash-loan loop where borrowed funds also increase supplied
+ *   collateral (e.g. multiply token).
+ * - `debtOnly` — only debt changes, supplied collateral stays constant
+ *   (e.g. carry-position borrow/repay).
+ */
+export type LeverageChangeMode = "levered" | "debtOnly";
+/**
+ * Shared context for leverage operations: the lending-platform client, reserves,
+ * and position identity needed for both sizing and CPI construction.
+ */
+export interface LeverageContext {
+    /** Lending-platform instruction client for building CPIs. */
+    lendingIx: LpInstructionsBase<LendingPlatformData>;
+    /** Collateral reserve. */
+    supplyReserve: ReserveBase;
+    /** Debt reserve. */
+    debtReserve: ReserveBase;
+    /** Account that owns the lending position (e.g. a token PDA). */
+    user: Address;
+    /** Transaction signer / fee payer. */
+    payer: Address;
+    /** Lending pool address. */
+    pool: Address;
+    /** Lending protocol user account (e.g. Kamino obligation). */
+    userAccount: Address;
+    /** Transaction identifier shared with the lending client for pre-instruction deduplication. */
+    txId: string;
+    /** Deployment environment used for oracle price fetches. */
+    environment?: Environment;
+}
+/**
+ * Inputs for an increase-leverage (borrow) operation.
+ */
+export interface IncreaseLeverageParams {
+    /** Current supply position in UI units (e.g. 1.5 SOL). */
+    currentSupplyUiAmount: number;
+    /** Current debt position in UI units (e.g. 100 USDC). */
+    currentDebtUiAmount: number;
+    /** Target LTV utilization rate in basis points (0–10000). */
+    targetUtilizationRateBps: number;
+    /** Defaults to `debtOnly`. */
+    mode?: LeverageChangeMode;
+}
+/**
+ * Inputs for a decrease-leverage (repay) operation.
+ */
+export interface DecreaseLeverageParams {
+    /** Current supply position in UI units. */
+    currentSupplyUiAmount: number;
+    /** Current debt position in UI units. */
+    currentDebtUiAmount: number;
+    /** Target LTV utilization rate in basis points (0–10000). */
+    targetUtilizationRateBps: number;
+    /** Defaults to `debtOnly`. */
+    mode?: LeverageChangeMode;
+    /**
+     * When set, replaces the utilization-derived repay size for both the on-chain
+     * `repay_amount` and the embedded Kamino repay CPI amount. Used for full
+     * deleverages where refreshed obligation debt can exceed stale token accounting.
+     */
+    repayBaseUnitsOverride?: BN;
+    /**
+     * When the debt token must be obtained via a swap (source asset differs
+     * from debt mint), provide swap context so the service can quote the swap
+     * and prepend a swap CPI group when the on-hand balance is insufficient.
+     */
+    swapContext?: LeverageSwapContext;
+}
+/**
+ * Context for quoting a swap that tops up the debt token before repay.
+ */
+export interface LeverageSwapContext {
+    /** Swap client used to quote and build CPI data. */
+    swap: SwapClient;
+    /** Mint of the asset to sell (source of liquidity). */
+    sourceMint: Address;
+    /** Debt mint the repay requires. */
+    debtMint: Address;
+    /** Base units of the source asset available for the swap. */
+    sourceBalanceBaseUnits: bigint;
+    /** Address that executes the swap (e.g. a vault PDA). */
+    swapTarget: Address;
+    /** Real signer that can pay for swap route setup instructions. */
+    payer?: Address;
+    /** Slippage tolerance in basis points. Defaults to 40 for decrease-leverage swaps. */
+    slippageBps?: number;
+    /** DEX labels to exclude from swap routing (e.g. venues that failed a prior attempt). */
+    excludeDexes?: string[];
+}
+/**
+ * Result of an increase-leverage (borrow) operation.
+ */
+export interface IncreaseLeverageResult {
+    /** Borrow amount in UI units. */
+    borrowUiAmount: number;
+    /** Borrow amount in debt-token base units. */
+    borrowBaseUnits: BN;
+    /** Prerequisite CPIs (e.g. obligation refresh) that precede the borrow. */
+    prerequisiteCpis: CpiData[];
+    /** Main borrow CPI descriptors. */
+    borrowCpis: CpiData[];
+    /** Top-level instructions that must execute before CPIs (e.g. Kamino LUT warmup). */
+    preInstructions: Instruction[];
+    /** Cache invalidations from the lending operation. */
+    postSuccessCacheInvalidations: TransactionCacheInvalidation[];
+}
+/**
+ * Per-leg context for a flash-loan-wrapped rebalance leg (source or destination).
+ */
+export interface FlashRebalanceLegContext {
+    /** Lending-platform instruction client for building CPIs on this leg. */
+    lendingIx: LpInstructionsBase<LendingPlatformData>;
+    /** Collateral (supply) reserve. */
+    supplyReserve: ReserveBase;
+    /** Debt reserve. */
+    debtReserve: ReserveBase;
+    /** Lending pool address. */
+    pool: Address;
+    /** Lending-protocol user account (e.g. Kamino obligation). */
+    userAccount: Address;
+}
+/**
+ * Shared context for a flash-loan-wrapped rebalance, moving collateral between
+ * two lending positions without touching carry positions.
+ */
+export interface FlashRebalanceContext {
+    /** Source position (collateral withdraws from here, debt temporarily repaid). */
+    source: FlashRebalanceLegContext;
+    /** Destination position (collateral deposits here, fresh debt borrowed). */
+    destination: FlashRebalanceLegContext;
+    /** Flash-loan client for the source debt mint's lending platform. */
+    flashLoan: FlashLoanBase<LendingPlatformData>;
+    /** Swap client used to quote the exact-in swap back to source debt mint. */
+    swap: SwapClient;
+    /** Account owning the lending positions (e.g. token PDA). */
+    user: Address;
+    /** Transaction signer / fee payer. */
+    payer: Address;
+    /** Transaction identifier shared with lending clients for pre-instruction dedup. */
+    txId: string;
+    /** Deployment environment — passed to oracle fetches so custom oracles (e.g. PythSplStake) use the correct RPC endpoint. */
+    environment?: Environment;
+}
+/**
+ * Inputs for a flash-loan-wrapped rebalance.
+ */
+export interface FlashRebalanceParams {
+    /** Collateral amount in UI units; used to size the source repay for partial rebalances. */
+    collateralUiAmount: number;
+    /** Target LTV utilization rate (bps) the source should land at after the repay. */
+    sourceTargetUtilizationRateBps: number;
+    /**
+     * Upper utilization bound (bps) the destination must stay under after the borrow.
+     * This should mirror the on-chain post-rebalance guard.
+     */
+    destinationMaxUtilizationRateBps?: number;
+    /** Slippage tolerance for the exact-in swap, in basis points. Defaults to 100. */
+    swapSlippageBps?: number;
+    /**
+     * Extra safety margin (bps) added on top of `swapSlippageBps` when sizing
+     * the destination borrow / swap input. The over-borrow makes the worst-case
+     * post-slippage swap output exceed the flash repay by this much; the
+     * excess is swept to the yielding bank on-chain. Defaults to 50.
+     */
+    swapBufferBps?: number;
+    /**
+     * Upper bound for how much destination debt mint the builder may borrow.
+     * Defaults to the destination reserve's available borrow capacity.
+     */
+    maxDestinationBorrowBaseUnits?: bigint;
+    /**
+     * If true, the source-side repay uses the platform's "repay all" sentinel so
+     * the obligation's full debt is cleared on-chain — caller still passes
+     * `collateralUiAmount` (used for sizing the destination borrow / swap).
+     * Set when rebalancing 100% of a position's debt.
+     */
+    withdrawAll?: boolean;
+    /**
+     * Maximum acceptable **execution cost** of the destination-debt →
+     * source-debt swap quote, in bps, measured against the oracle-fair cross
+     * rate (`destDebtUsd / sourceDebtUsd`): route fees + price impact only.
+     * Genuine market basis between the two stables is excluded here — bound it
+     * with {@link maxMarketBasisBps}. Exceeding this throws
+     * `FlashRebalanceSwapCostExceededError` (reason `"execution-cost"`); the
+     * cost is permanently lost value. Unset = no limit.
+     */
+    maxSwapCostBps?: number;
+    /**
+     * Maximum acceptable **market basis** between the two debt stables, in bps:
+     * how far the oracle-fair cross rate sits from 1:1 (either direction).
+     * Under the $1-pinned on-chain books the basis is charged to the token's
+     * carry-vs-debt difference at conversion time (as mark-to-market that
+     * reverses on unwind if the basis persists), and a large basis usually
+     * means one leg is depegging. Exceeding this throws
+     * `FlashRebalanceSwapCostExceededError` (reason `"market-basis"`).
+     * Unset = no limit.
+     */
+    maxMarketBasisBps?: number;
+}
+/**
+ * Result of a flash-loan-wrapped rebalance build.
+ *
+ * The caller wraps the on-chain rebalance instruction with the returned
+ * {@link flashBorrowIx} and {@link flashRepayIx} at the top level.
+ */
+export interface FlashRebalanceResult {
+    /** Flash-borrow amount in source-debt-mint base units. */
+    flashBorrowAmountBaseUnits: BN;
+    /** Flash-repay amount in source-debt-mint base units (borrow + fee). */
+    flashRepayAmountBaseUnits: BN;
+    /** Flash fee in source-debt-mint base units. */
+    flashFeeBaseUnits: BN;
+    /** Source repay amount in UI units (equals flash-borrow amount). */
+    sourceRepayUiAmount: number;
+    /** Destination borrow amount in UI units (quote's max input). */
+    destinationBorrowUiAmount: number;
+    /** Top-level flash-borrow instruction (goes before the rebalance ix). */
+    flashBorrowIx: Instruction;
+    /** Source repay CPI group (flash-borrowed tokens → source debt), prereqs prepended. */
+    sourceRepayCpis: CpiData[];
+    /** Destination borrow CPI group, prereqs prepended. */
+    destinationBorrowCpis: CpiData[];
+    /** Swap CPI descriptor (single Swap CPI, exact-in). */
+    swapCpis: CpiData[];
+    /** Hoisted top-level instructions (Kamino LUT warmup etc.), deduplicated across legs. */
+    preInstructions: Instruction[];
+    /** Cache invalidations for the lending operations. */
+    postSuccessCacheInvalidations: TransactionCacheInvalidation[];
+}
+/**
+ * Result of a decrease-leverage (repay) operation.
+ */
+export interface DecreaseLeverageResult {
+    /** Repay amount in UI units. */
+    repayUiAmount: number;
+    /** Repay amount in debt-token base units. */
+    repayBaseUnits: BN;
+    /** Prerequisite CPIs (e.g. obligation refresh) that precede the repay. */
+    prerequisiteCpis: CpiData[];
+    /** Main repay CPI descriptors. */
+    repayCpis: CpiData[];
+    /**
+     * Ordered CPI groups for the operation: `[swapGroup?, repayGroup]`.
+     * When no swap is needed, contains a single repay group.
+     */
+    cpiDataGroups: CpiData[][];
+    /** True when a swap CPI was prepended because on-hand debt was insufficient. */
+    swapRequired: boolean;
+    /** Top-level instructions that must execute before CPIs. */
+    preInstructions: Instruction[];
+}

package/dist/shared/lending-platforms/src/services/leverage/types.js

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

package/dist/shared/lending-platforms/src/services/reservesManager.d.ts

@@ -0,0 +1,53 @@
+import { type Environment } from "common";
+import { PriceResult } from "oracle-service";
+import { ReserveBase } from "../data";
+import { PositionBalanceChange } from "../types";
+export interface ReservesPrices {
+    supply: PriceResult;
+    debt: PriceResult;
+}
+export interface DebtAdjustmentOptions {
+    /**
+     * How the position changes when debt is adjusted.
+     * `levered` models a loop / flash-loan rebalance where borrowed funds also
+     * increase supplied collateral.
+     * `debtOnly` models changes such as carry-position borrows where only debt
+     * changes and supplied collateral stays constant.
+     */
+    positionChangeMode?: "levered" | "debtOnly";
+}
+/**
+ * Manages a supply/debt reserve pair and provides calculations
+ * for APY, simulations, and debt adjustments.
+ */
+export declare class ReservesManager {
+    supplyReserve: ReserveBase;
+    debtReserve: ReserveBase;
+    private environment?;
+    private cache;
+    constructor(supplyReserve: ReserveBase, debtReserve: ReserveBase, environment?: Environment | undefined);
+    /** Max LTV ratio (0-1), using e-mode override when the pair qualifies */
+    get maxLtv(): number;
+    /**
+     * Returns supply and debt token prices.
+     * Uses reserve-embedded prices when available, otherwise fetches from oracle and caches the result.
+     */
+    prices(): Promise<ReservesPrices>;
+    /**
+     * Net APY for the lending & borrowing position.
+     * Accounts for eligible incentives based on the paired reserve relationship.
+     */
+    get netAPY(): number;
+    /**
+     * Simulates net APY after hypothetical position changes.
+     * Accounts for eligible incentives based on the paired reserve relationship.
+     */
+    simulateNetAPY(args: PositionBalanceChange[]): number;
+    /** Current LTV utilization rate in basis points (0-10000) given USD position values */
+    calcLtvUtilizationRateBps(supplyUsd: number, debtUsd: number): number;
+    /**
+     * Calculates the USD debt adjustment needed to reach a target LTV utilization rate.
+     * Positive result = boost (increase leverage), negative = deleverage.
+     */
+    calcDebtAdjustmentUsd(uiSupplyAmount: number, uiDebtAmount: number, targetLtvUtilizationRateBps: number, options?: DebtAdjustmentOptions): Promise<number>;
+}

package/dist/shared/lending-platforms/src/services/reservesManager.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReservesManager = void 0;
+const common_1 = require("common");
+const oracle_service_1 = require("oracle-service");
+/**
+ * Manages a supply/debt reserve pair and provides calculations
+ * for APY, simulations, and debt adjustments.
+ */
+class ReservesManager {
+    constructor(supplyReserve, debtReserve, environment) {
+        this.supplyReserve = supplyReserve;
+        this.debtReserve = debtReserve;
+        this.environment = environment;
+        this.cache = new common_1.DataCache();
+    }
+    /** Max LTV ratio (0-1), using e-mode override when the pair qualifies */
+    get maxLtv() {
+        const emode = this.supplyReserve.emodes?.find((e) => e.debtReserve === this.debtReserve.address);
+        return emode?.ltvPct ?? this.supplyReserve.ltvPct;
+    }
+    /**
+     * Returns supply and debt token prices.
+     * Uses reserve-embedded prices when available, otherwise fetches from oracle and caches the result.
+     */
+    async prices() {
+        const { data } = await this.cache.getDataOrThrow(async () => {
+            const supplyRealtimePrice = this.supplyReserve.mintPrice;
+            const debtRealtimePrice = this.debtReserve.mintPrice;
+            const supplyEmaPrice = this.supplyReserve.mintEmaPrice;
+            const debtEmaPrice = this.debtReserve.mintEmaPrice;
+            const realtimeMintsToFetch = [
+                ...(supplyRealtimePrice === undefined ? [this.supplyReserve.mint.mint] : []),
+                ...(debtRealtimePrice === undefined ? [this.debtReserve.mint.mint] : []),
+            ];
+            const emaMintsToFetch = [
+                ...(supplyEmaPrice === undefined ? [this.supplyReserve.mint.mint] : []),
+                ...(debtEmaPrice === undefined ? [this.debtReserve.mint.mint] : []),
+            ];
+            const [realtime, ema] = await Promise.all([
+                realtimeMintsToFetch.length
+                    ? oracle_service_1.oracle.fetchPrices(realtimeMintsToFetch, "realtime", undefined, this.environment)
+                    : {},
+                emaMintsToFetch.length
+                    ? oracle_service_1.oracle.fetchPrices(emaMintsToFetch, "ema", undefined, this.environment)
+                    : {},
+            ]);
+            return {
+                supply: {
+                    realtimePrice: supplyRealtimePrice ?? realtime[this.supplyReserve.mint.mint],
+                    emaPrice: supplyEmaPrice ?? ema[this.supplyReserve.mint.mint],
+                },
+                debt: {
+                    realtimePrice: debtRealtimePrice ?? realtime[this.debtReserve.mint.mint],
+                    emaPrice: debtEmaPrice ?? ema[this.debtReserve.mint.mint],
+                },
+            };
+        }, "prices", `${this.supplyReserve.mint.mint}:${this.debtReserve.mint.mint}`);
+        return data;
+    }
+    /**
+     * Net APY for the lending & borrowing position.
+     * Accounts for eligible incentives based on the paired reserve relationship.
+     */
+    get netAPY() {
+        return this.supplyReserve.supplyAPY(this.debtReserve.address) - this.debtReserve.borrowAPY();
+    }
+    /**
+     * Simulates net APY after hypothetical position changes.
+     * Accounts for eligible incentives based on the paired reserve relationship.
+     */
+    simulateNetAPY(args) {
+        return (this.supplyReserve.simulateNewSupplyAPY(args.find((x) => Boolean(x.collateralChange)) ?? { collateralChange: 0 }, this.debtReserve.address) -
+            this.debtReserve.simulateNewBorrowAPY(args.find((x) => Boolean(x.debtChange)) ?? { debtChange: 0 }));
+    }
+    /** Current LTV utilization rate in basis points (0-10000) given USD position values */
+    calcLtvUtilizationRateBps(supplyUsd, debtUsd) {
+        if (supplyUsd <= 0)
+            return 0;
+        return (debtUsd / (supplyUsd * this.maxLtv)) * 10000;
+    }
+    /**
+     * Calculates the USD debt adjustment needed to reach a target LTV utilization rate.
+     * Positive result = boost (increase leverage), negative = deleverage.
+     */
+    async calcDebtAdjustmentUsd(uiSupplyAmount, uiDebtAmount, targetLtvUtilizationRateBps, options = {}) {
+        const { supply: supplyPrice, debt: debtPrice } = await this.prices();
+        let supplyUsd = uiSupplyAmount * supplyPrice.realtimePrice;
+        let debtUsd = uiDebtAmount * debtPrice.realtimePrice;
+        const maxLtv = this.maxLtv;
+        const targetUtilizationRate = targetLtvUtilizationRateBps / 10000;
+        const flFee = this.debtReserve.config.flashLoanFeePct / 100;
+        const lpBorrowFee = this.debtReserve.config.borrowFeePct / 100;
+        const positionChangeMode = options.positionChangeMode ?? "levered";
+        const currentLtvUtilizationRate = supplyUsd > 0 ? debtUsd / (supplyUsd * maxLtv) : 0;
+        const isBoost = currentLtvUtilizationRate < targetUtilizationRate;
+        if (isBoost) {
+            supplyUsd = uiSupplyAmount * (supplyPrice.emaPrice ?? supplyPrice.realtimePrice);
+            debtUsd = uiDebtAmount * (debtPrice.emaPrice ?? debtPrice.realtimePrice);
+        }
+        if (positionChangeMode === "debtOnly") {
+            const targetDebtDeltaUsd = targetUtilizationRate * maxLtv * supplyUsd - debtUsd;
+            return isBoost ? targetDebtDeltaUsd / (1.0 + lpBorrowFee) : targetDebtDeltaUsd;
+        }
+        return isBoost
+            ? (targetUtilizationRate * maxLtv * supplyUsd - debtUsd) /
+                (1.0 + lpBorrowFee + flFee - targetUtilizationRate * maxLtv)
+            : (targetUtilizationRate * maxLtv * supplyUsd - debtUsd) /
+                (1.0 - targetUtilizationRate * maxLtv * (1.0 + flFee));
+    }
+}
+exports.ReservesManager = ReservesManager;

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

@@ -0,0 +1,37 @@
+import { Address } from "@solana/kit";
+/** Supported lending platforms */
+export declare enum LendingPlatform {
+    Kamino = 0
+}
+export interface OutstandingIncentiveClaimAccounts {
+    farm: Address;
+    userFarm: Address;
+}
+/**
+ * Represents a hypothetical change to a user's position.
+ * Used for simulating APY changes before executing transactions.
+ * Values are in UI units (token amounts, not raw).
+ */
+export interface PositionBalanceChange {
+    /** Change in collateral amount (positive = deposit, negative = withdraw) */
+    collateralChange?: number;
+    /** Change in debt amount (positive = borrow, negative = repay) */
+    debtChange?: number;
+}
+/** A claimable lending-platform incentive balance for a specific claim path. */
+export interface OutstandingIncentive {
+    mint: Address;
+    /** Claimable balance in the reward token's raw base units. */
+    amount: number;
+    /** Decimals of the reward token mint (0 if unknown). */
+    decimals: number;
+    /** Claimable balance in UI units (`amount / 10 ** decimals`). */
+    uiAmount: number;
+    claimAccounts?: OutstandingIncentiveClaimAccounts;
+}
+export interface SupportedReserve {
+    address: Address;
+    mintSymbol: string;
+}
+/** Pool mapped to supported reserves */
+export type LendingPlatformAccounts = Record<Address, SupportedReserve[]>;

package/dist/shared/lending-platforms/src/types/general.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LendingPlatform = void 0;
+/** Supported lending platforms */
+var LendingPlatform;
+(function (LendingPlatform) {
+    LendingPlatform[LendingPlatform["Kamino"] = 0] = "Kamino";
+})(LendingPlatform || (exports.LendingPlatform = LendingPlatform = {}));

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

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

package/dist/shared/lending-platforms/src/types/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("./general"), exports);

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

@@ -0,0 +1,10 @@
+import { Address } from "@solana/kit";
+export interface KaminoExtraFarmData {
+    market: Address;
+    debtMint: Address;
+    collMint: Address;
+    farm: Address;
+    rewardPayerTokenMint: Address;
+    collReserve: Address;
+    debtReserve: Address;
+}

package/dist/shared/lending-platforms/src/types/kamino.js

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

package/dist/shared/lending-platforms/src/utils/accounts.d.ts

@@ -0,0 +1,16 @@
+import type { Address } from "@solana/kit";
+/**
+ * Returns all lending pool addresses that list a reserve matching the
+ * given mint symbol (case-insensitive).
+ *
+ * Useful for resolving which pool(s) a collateral token is eligible for
+ * when the caller hasn't specified a pool explicitly.
+ */
+export declare function getEligiblePools(mintSymbol: string): Address[];
+/**
+ * Returns all mint symbols listed in a given lending pool.
+ *
+ * Callers can cross-reference with the common mint registry's `assetType`
+ * to filter for stablecoins, LSTs, etc.
+ */
+export declare function getBorrowableMintsForPool(pool: Address): string[];

package/dist/shared/lending-platforms/src/utils/accounts.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEligiblePools = getEligiblePools;
+exports.getBorrowableMintsForPool = getBorrowableMintsForPool;
+const constants_1 = require("../constants");
+/**
+ * Returns all lending pool addresses that list a reserve matching the
+ * given mint symbol (case-insensitive).
+ *
+ * Useful for resolving which pool(s) a collateral token is eligible for
+ * when the caller hasn't specified a pool explicitly.
+ */
+function getEligiblePools(mintSymbol) {
+    const needle = mintSymbol.toUpperCase();
+    const pools = [];
+    for (const pool of Object.keys(constants_1.KAMINO_ACCOUNTS)) {
+        const reserves = constants_1.KAMINO_ACCOUNTS[pool];
+        if (reserves.some((r) => r.mintSymbol.toUpperCase() === needle)) {
+            pools.push(pool);
+        }
+    }
+    return pools;
+}
+/**
+ * Returns all mint symbols listed in a given lending pool.
+ *
+ * Callers can cross-reference with the common mint registry's `assetType`
+ * to filter for stablecoins, LSTs, etc.
+ */
+function getBorrowableMintsForPool(pool) {
+    const reserves = constants_1.KAMINO_ACCOUNTS[pool];
+    if (!reserves) {
+        throw new Error(`getBorrowableMintsForPool: unknown pool ${pool}`);
+    }
+    return reserves.map((r) => r.mintSymbol);
+}

package/dist/shared/lending-platforms/src/utils/cache.d.ts

@@ -0,0 +1,3 @@
+import { type Address } from "@solana/kit";
+import { type TransactionCacheInvalidation } from "common";
+export declare function getLendingUserAccountCacheInvalidation(userAccount: Address): TransactionCacheInvalidation;

package/dist/shared/lending-platforms/src/utils/cache.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLendingUserAccountCacheInvalidation = getLendingUserAccountCacheInvalidation;
+const cache_1 = require("../constants/cache");
+function getLendingUserAccountCacheInvalidation(userAccount) {
+    return {
+        client: "kamino",
+        category: cache_1.LENDING_PLATFORM_DATA_CACHE_CATEGORY_USER_ACCOUNT,
+        id: userAccount,
+    };
+}

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

@@ -0,0 +1,6 @@
+export * from "./accounts";
+export * from "./cache";
+export * from "./kamino";
+export * from "./lendingPlatform";
+export * from "./math";
+export * from "./scope";

package/dist/shared/lending-platforms/src/utils/index.js

@@ -0,0 +1,22 @@
+"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("./accounts"), exports);
+__exportStar(require("./cache"), exports);
+__exportStar(require("./kamino"), exports);
+__exportStar(require("./lendingPlatform"), exports);
+__exportStar(require("./math"), exports);
+__exportStar(require("./scope"), exports);