@kestrelfi/lyc-sdk 1.0.1

package/dist/shared/lending-platforms/src/data/userPosition/userPositionBase.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserPositionBase = void 0;
+const core_1 = require("@anchor-lang/core");
+const common_1 = require("common");
+/**
+ * Base class representing a user's lending position.
+ * Contains aggregated data about deposits, borrows, and health metrics.
+ */
+class UserPositionBase {
+    constructor(address, 
+    /** Current utilization as a ratio of borrowed value to borrow limit (0-1) */
+    utilizationRate, deposits, borrows, 
+    /** Loan-to-value ratio (if applicable based on elevation group) */
+    ltv, 
+    /** Liquidation threshold percentage (if applicable) */
+    liquidationThreshold, 
+    /**
+     * Obligation-level max borrow capacity in USD (`borrowedUsd / utilizationRate`).
+     * Each platform loader must set this from that protocol's position health model.
+     */
+    borrowLimitUsd) {
+        this.address = address;
+        this.utilizationRate = utilizationRate;
+        this.deposits = deposits;
+        this.borrows = borrows;
+        this.ltv = ltv;
+        this.liquidationThreshold = liquidationThreshold;
+        this.borrowLimitUsd = borrowLimitUsd;
+    }
+    /** Aggregate borrowed USD for headroom; prefers per-borrow breakdown when present. */
+    userPositionBorrowedValueUsd() {
+        const fromBorrows = this.borrows.reduce((sum, borrow) => sum + borrow.valueUsd, 0);
+        if (fromBorrows > 0) {
+            return fromBorrows;
+        }
+        if (this.borrowLimitUsd !== undefined && this.utilizationRate > 0) {
+            return this.borrowLimitUsd * this.utilizationRate;
+        }
+        return 0;
+    }
+    /**
+     * Max additional debt UI amount before the platform rejects the borrow.
+     * Uses obligation `borrowLimitUsd − borrowedUsd`, floored to base units with a
+     * one-unit buffer so simulation-time refresh cannot overshoot. Returns `undefined`
+     * when `borrowLimitUsd` was not set by the platform loader.
+     */
+    getMaxAdditionalBorrowUiAmount(debtPriceUsd, debtDecimals) {
+        if (this.borrowLimitUsd === undefined) {
+            return undefined;
+        }
+        const borrowedValueUsd = this.userPositionBorrowedValueUsd();
+        const headroomUsd = Math.max(0, this.borrowLimitUsd - borrowedValueUsd);
+        if (headroomUsd <= 0 || !(debtPriceUsd > 0)) {
+            return 0;
+        }
+        const headroomUi = headroomUsd / debtPriceUsd;
+        const maxBaseUnits = (0, common_1.fromUiAmount)(headroomUi, debtDecimals);
+        const safeBaseUnits = core_1.BN.max(maxBaseUnits.subn(1), new core_1.BN(0));
+        return (0, common_1.toUiAmount)(safeBaseUnits, debtDecimals);
+    }
+}
+exports.UserPositionBase = UserPositionBase;

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

@@ -0,0 +1,5 @@
+export * from "./services";
+export * from "./data";
+export * from "./constants";
+export * from "./utils";
+export * from "./types";

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

@@ -0,0 +1,21 @@
+"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("./services"), exports);
+__exportStar(require("./data"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./types"), exports);

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

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

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

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

@@ -0,0 +1,53 @@
+import { Address } from "@solana/kit";
+import { BN } from "@anchor-lang/core";
+import { LendingPlatformClientBase } from "./lpClientBase";
+import { KaminoData } from "../../data";
+import { KaminoAccounts } from "../../data/accounts";
+import { KaminoInstructions } from "../../data/instructions";
+import { KaminoFlashLoan } from "../flashLoan/kamino";
+import type { OutstandingIncentive } from "../../types";
+/**
+ * Client for interacting with Kamino Lend protocol.
+ * Provides access to data, accounts, and instruction builders for lending operations.
+ */
+export declare class KaminoClient extends LendingPlatformClientBase<KaminoData> {
+    accounts: KaminoAccounts;
+    ix: KaminoInstructions;
+    constructor(rpcUrl?: string, rpcUrls?: string[]);
+    refreshData(pools: Address[]): Promise<void>;
+    getFlashLoan(): KaminoFlashLoan;
+    /**
+     * Kamino's `RepayObligationLiquidityV2` interprets `u64::MAX` as "repay
+     * the obligation's full debt for this reserve" — letting the on-chain
+     * handler clear interest-accrual dust between the off-chain quote and
+     * settlement. The flash-borrow over-borrows by a slippage buffer to fund
+     * this; the post-repay surplus is swept into the yielding bank.
+     */
+    getRepayAllSentinel(): BN;
+    getAvailableUserAccountId(pool: Address, user: Address, excludeUserAccounts?: readonly Address[]): Promise<number>;
+    /**
+     * Returns claimable rewards across all kamino farms tied to this obligation:
+     *
+     *   - **Obligation farms** (klend reserve `farmCollateral`/`farmDebt`):
+     *     UserState.owner = obligation owner (the lyc-token PDA),
+     *     UserState.delegatee = the obligation itself.
+     *   - **Direct/extra farms** (e.g. paired-reserve incentives): the lyc-token
+     *     PDA stakes directly in the farms program.
+     *     UserState.owner = UserState.delegatee = lyc-token PDA.
+     *
+     * The farms SDK filters UserStates by memcmp against `owner` (offset 48),
+     * so we query by the obligation's owner and then accept any UserState whose
+     * `delegatee` is either the obligation or the owner itself. In both cases
+     * `userFarm.userStateAddress` is the correct UserState account for the
+     * `HarvestReward` CPI; deriving via `obligationFarmStatePda` would be wrong
+     * for direct farms (different seed scheme).
+     */
+    getOutstandingIncentives(userAccount: Address, minUiAmount?: number, log?: (msg: string) => void): Promise<OutstandingIncentive[]>;
+    /**
+     * Reads the klend obligation account and returns its `owner` field (the
+     * authority that opened the obligation — for LYC this is the lyc-token PDA).
+     * Returns null when the account doesn't exist on-chain (stale protocolUserAcc).
+     */
+    private fetchObligationOwner;
+    private isInactiveUserAccount;
+}

package/dist/shared/lending-platforms/src/services/client/kamino.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KaminoClient = void 0;
+const klend_sdk_1 = require("@kamino-finance/klend-sdk");
+const common_1 = require("common");
+const lpClientBase_1 = require("./lpClientBase");
+const data_1 = require("../../data");
+const accounts_1 = require("../../data/accounts");
+const instructions_1 = require("../../data/instructions");
+const kamino_1 = require("../flashLoan/kamino");
+/**
+ * Client for interacting with Kamino Lend protocol.
+ * Provides access to data, accounts, and instruction builders for lending operations.
+ */
+class KaminoClient extends lpClientBase_1.LendingPlatformClientBase {
+    constructor(rpcUrl = (0, common_1.getRpcUrl)(common_1.ENVIRONMENT), rpcUrls = [rpcUrl]) {
+        super(rpcUrl, rpcUrls);
+        this.data = new data_1.KaminoData(rpcUrl, undefined, rpcUrls);
+        this.accounts = new accounts_1.KaminoAccounts(this.data);
+        this.ix = new instructions_1.KaminoInstructions(this.rpc, rpcUrl, this.data, this.accounts);
+    }
+    async refreshData(pools) {
+        this.data.clearCache();
+        await this.data.load(pools);
+    }
+    getFlashLoan() {
+        return new kamino_1.KaminoFlashLoan(this.data);
+    }
+    /**
+     * Kamino's `RepayObligationLiquidityV2` interprets `u64::MAX` as "repay
+     * the obligation's full debt for this reserve" — letting the on-chain
+     * handler clear interest-accrual dust between the off-chain quote and
+     * settlement. The flash-borrow over-borrows by a slippage buffer to fund
+     * this; the post-repay surplus is swept into the yielding bank.
+     */
+    getRepayAllSentinel() {
+        return common_1.U64_MAX_BN;
+    }
+    async getAvailableUserAccountId(pool, user, excludeUserAccounts = []) {
+        const positions = await this.data.fetchAllUserPositionsForUserInPool(pool, user);
+        const positionsByAddress = new Map(positions.map((position) => [position.address, position]));
+        const excludeSet = new Set(excludeUserAccounts);
+        for (let userAccountId = 0;; userAccountId++) {
+            const userAccount = await this.accounts.getUserAccountAddress(pool, user, userAccountId);
+            if (excludeSet.has(userAccount)) {
+                continue;
+            }
+            const existingPosition = positionsByAddress.get(userAccount);
+            if (!existingPosition || this.isInactiveUserAccount(existingPosition)) {
+                return userAccountId;
+            }
+        }
+    }
+    /**
+     * Returns claimable rewards across all kamino farms tied to this obligation:
+     *
+     *   - **Obligation farms** (klend reserve `farmCollateral`/`farmDebt`):
+     *     UserState.owner = obligation owner (the lyc-token PDA),
+     *     UserState.delegatee = the obligation itself.
+     *   - **Direct/extra farms** (e.g. paired-reserve incentives): the lyc-token
+     *     PDA stakes directly in the farms program.
+     *     UserState.owner = UserState.delegatee = lyc-token PDA.
+     *
+     * The farms SDK filters UserStates by memcmp against `owner` (offset 48),
+     * so we query by the obligation's owner and then accept any UserState whose
+     * `delegatee` is either the obligation or the owner itself. In both cases
+     * `userFarm.userStateAddress` is the correct UserState account for the
+     * `HarvestReward` CPI; deriving via `obligationFarmStatePda` would be wrong
+     * for direct farms (different seed scheme).
+     */
+    async getOutstandingIncentives(userAccount, minUiAmount = 0, log) {
+        const obligationOwner = await this.fetchObligationOwner(userAccount);
+        if (!obligationOwner) {
+            log?.(`  [getOutstandingIncentives] no obligation owner found for ${userAccount}`);
+            return [];
+        }
+        const allOwnerFarms = await this.data.fetchUserActiveIncentives(obligationOwner);
+        log?.(`  [getOutstandingIncentives] found ${allOwnerFarms.length} farm(s) owned by ${obligationOwner.slice(0, 6)}…`);
+        const userFarms = allOwnerFarms.filter((uf) => uf.userState.delegatee === userAccount || uf.userState.delegatee === obligationOwner);
+        const filteredOut = allOwnerFarms.length - userFarms.length;
+        if (filteredOut > 0) {
+            log?.(`  [getOutstandingIncentives] ${filteredOut} farm(s) skipped — delegatee matched neither userAccount (${userAccount.slice(0, 6)}…) nor owner`);
+        }
+        if (userFarms.length === 0) {
+            log?.(`  [getOutstandingIncentives] no matching farms for userAccount`);
+            return [];
+        }
+        // Reward token decimals live on the FarmState, not on the pending-reward
+        // entry, so fetch the (cached) farm states to convert raw balances to UI
+        // units for the dust filter.
+        const farmStates = await this.data.fetchFarms(userFarms.map((uf) => uf.farm));
+        const decimalsByFarmAndMint = new Map();
+        farmStates.forEach((farmState, i) => {
+            const farm = userFarms[i].farm;
+            for (const rewardInfo of farmState.rewardInfos) {
+                decimalsByFarmAndMint.set(`${farm}:${rewardInfo.token.mint}`, rewardInfo.token.decimals.toNumber());
+            }
+        });
+        const incentives = [];
+        for (const userFarm of userFarms) {
+            log?.(`  [getOutstandingIncentives] farm ${userFarm.farm.slice(0, 6)}…  userFarm ${userFarm.userStateAddress.slice(0, 6)}…  delegatee ${userFarm.userState.delegatee.slice(0, 6)}…  ${userFarm.pendingRewards.length} pending reward(s)`);
+            for (const reward of userFarm.pendingRewards) {
+                const amount = reward.cumulatedPendingRewards.toNumber();
+                const decimals = decimalsByFarmAndMint.get(`${userFarm.farm}:${reward.rewardTokenMint}`) ?? 0;
+                const uiAmount = amount / 10 ** decimals;
+                if (amount <= 0) {
+                    log?.(`    reward ${reward.rewardTokenMint.slice(0, 6)}… — skipped (amount=0)`);
+                    continue;
+                }
+                if (uiAmount < minUiAmount) {
+                    log?.(`    reward ${reward.rewardTokenMint.slice(0, 6)}… — skipped (uiAmount=${uiAmount.toFixed(4)} < minUiAmount=${minUiAmount})`);
+                    continue;
+                }
+                log?.(`    reward ${reward.rewardTokenMint.slice(0, 6)}… — claimable uiAmount=${uiAmount.toFixed(4)}`);
+                incentives.push({
+                    mint: reward.rewardTokenMint,
+                    amount,
+                    decimals,
+                    uiAmount,
+                    claimAccounts: {
+                        farm: userFarm.farm,
+                        userFarm: userFarm.userStateAddress,
+                    },
+                });
+            }
+        }
+        return incentives;
+    }
+    /**
+     * Reads the klend obligation account and returns its `owner` field (the
+     * authority that opened the obligation — for LYC this is the lyc-token PDA).
+     * Returns null when the account doesn't exist on-chain (stale protocolUserAcc).
+     */
+    async fetchObligationOwner(userAccount) {
+        const obligation = await klend_sdk_1.Obligation.fetch(this.rpc, userAccount);
+        return obligation ? obligation.owner : null;
+    }
+    isInactiveUserAccount(position) {
+        return [...position.deposits, ...position.borrows].every((entry) => entry.amount.isZero());
+    }
+}
+exports.KaminoClient = KaminoClient;

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

@@ -0,0 +1,66 @@
+import { Address, Rpc, SolanaRpcApi } from "@solana/kit";
+import { BN } from "@anchor-lang/core";
+import { TransactionCacheInvalidation } from "common";
+import { LendingPlatformData, LpAccountsBase, LpInstructionsBase } from "../../data";
+import type { FlashLoanBase } from "../flashLoan/flashLoanBase";
+import type { OutstandingIncentive } from "../../types";
+/**
+ * A platform-agnostic lending client — the base class instantiated against
+ * any concrete `LendingPlatformData` subclass. Use this when a function
+ * doesn't care about the underlying platform (Kamino, Marginfi, etc.) and
+ * just needs to call the shared abstract surface.
+ */
+export type AnyLendingPlatformClient = LendingPlatformClientBase<LendingPlatformData>;
+/**
+ * Abstract base class for lending platform clients.
+ * Provides a unified interface for interacting with different lending protocols.
+ *
+ * @typeParam T - The platform-specific data class extending LendingPlatformData
+ */
+export declare abstract class LendingPlatformClientBase<T extends LendingPlatformData> {
+    rpc: Rpc<SolanaRpcApi>;
+    data: T;
+    abstract accounts: LpAccountsBase<T>;
+    abstract ix: LpInstructionsBase<T>;
+    constructor(rpcUrl: string, rpcUrls?: string[]);
+    applyPostSuccessCacheInvalidations(invalidations: TransactionCacheInvalidation[]): void;
+    /** Refreshes cached platform data for the specified pools */
+    abstract refreshData(pools: Address[]): Promise<void>;
+    /**
+     * Returns this platform's flash-loan client. Implementations should throw
+     * if the platform doesn't expose a flash-loan facility.
+     */
+    abstract getFlashLoan(): FlashLoanBase<T>;
+    /**
+     * Returns the platform-specific "repay full obligation debt" sentinel for
+     * the repay CPI's amount field, or `null` if the platform has no such
+     * sentinel and callers must compute the exact debt amount themselves.
+     * Used by `rebalance_token` on full-position moves to clear obligation
+     * debt exactly without leaving interest-accrual dust.
+     */
+    abstract getRepayAllSentinel(): BN | null;
+    /**
+     * Returns the first user-account ID that can be used in `pool` for `user`.
+     *
+     * Implementations may reuse an existing inactive account or return the first
+     * never-before-used ID, depending on the platform's account model.
+     *
+     * `excludeUserAccounts`, when provided, lists protocol user-account
+     * addresses that must NOT be returned even if they look reusable on-chain
+     * (e.g. zero deposits + zero borrows). Callers managing multiple
+     * higher-level positions over the same `(pool, user)` pair use this to
+     * ensure each position gets its own distinct user account, even when
+     * sibling positions are temporarily inactive on-chain.
+     */
+    abstract getAvailableUserAccountId(pool: Address, user: Address, excludeUserAccounts?: readonly Address[]): Promise<number>;
+    /**
+     * Returns the protocol user account's currently claimable rewards, excluding
+     * zero balances. Entries may include claim metadata required by the platform
+     * to harvest that specific reward.
+     *
+     * `minUiAmount` filters out dust: rewards whose UI-denominated balance is
+     * below this threshold are omitted, so callers don't pay transaction fees to
+     * harvest economically negligible amounts. Defaults to `0` (no filtering).
+     */
+    abstract getOutstandingIncentives(userAccount: Address, minUiAmount?: number, log?: (msg: string) => void): Promise<OutstandingIncentive[]>;
+}

package/dist/shared/lending-platforms/src/services/client/lpClientBase.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LendingPlatformClientBase = void 0;
+const common_1 = require("common");
+/**
+ * Abstract base class for lending platform clients.
+ * Provides a unified interface for interacting with different lending protocols.
+ *
+ * @typeParam T - The platform-specific data class extending LendingPlatformData
+ */
+class LendingPlatformClientBase {
+    constructor(rpcUrl, rpcUrls = [rpcUrl]) {
+        this.rpc = (0, common_1.createRpcWithFailover)(rpcUrls);
+    }
+    applyPostSuccessCacheInvalidations(invalidations) {
+        this.ix.applyPostSuccessCacheInvalidations(invalidations);
+    }
+}
+exports.LendingPlatformClientBase = LendingPlatformClientBase;

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

@@ -0,0 +1,49 @@
+import { BN } from "@anchor-lang/core";
+import type { Address, Instruction } from "@solana/kit";
+import { LendingPlatformData } from "../../data/platform";
+/** Parameters for building a flash-borrow instruction. */
+export interface FlashBorrowParams {
+    /** Authority that signs the transfer of the borrowed liquidity. */
+    user: Address;
+    pool: Address;
+    reserve: Address;
+    /** Amount to borrow, in the reserve liquidity mint's base units. */
+    amountBaseUnits: BN;
+    /** Destination ATA for the borrowed liquidity. Defaults to `user`'s ATA for the mint. */
+    destinationAta?: Address;
+}
+/** Parameters for building a flash-repay instruction, paired with a prior flash-borrow. */
+export interface FlashRepayParams extends FlashBorrowParams {
+    /** Top-level transaction index of the matching flash-borrow instruction. */
+    borrowIxIndex: number;
+    /** Source ATA for the repay. Defaults to the destination ATA used on the flash-borrow. */
+    userSourceLiquidity?: Address;
+}
+/**
+ * Abstract base for lending-platform flash-loan instruction builders.
+ * Flash loans are composed of a top-level borrow and repay pair that must live
+ * in the same transaction; the repay references the borrow by instruction index.
+ *
+ * @typeParam T - The platform-specific data class extending LendingPlatformData
+ */
+export declare abstract class FlashLoanBase<T extends LendingPlatformData> {
+    data: T;
+    constructor(data: T);
+    /** Builds the top-level flash-borrow instruction. */
+    abstract getFlashBorrowIx(params: FlashBorrowParams): Promise<Instruction>;
+    /**
+     * Builds the top-level flash-repay instruction. Must be paired with a
+     * flash-borrow at `borrowIxIndex` in the same transaction.
+     */
+    abstract getFlashRepayIx(params: FlashRepayParams): Promise<Instruction>;
+    /**
+     * Returns the maximum amount that can be flash-borrowed from `reserve`, in
+     * the reserve liquidity mint's base units.
+     */
+    abstract getAvailableFlashBorrowAmount(pool: Address, reserve: Address): Promise<BN>;
+    /**
+     * Returns `reserve`'s flash-loan fee rate as a fraction of the borrowed
+     * amount (e.g. `0.003` for 0.3%).
+     */
+    abstract getFlashLoanFeeRate(pool: Address, reserve: Address): Promise<number>;
+}

package/dist/shared/lending-platforms/src/services/flashLoan/flashLoanBase.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlashLoanBase = void 0;
+/**
+ * Abstract base for lending-platform flash-loan instruction builders.
+ * Flash loans are composed of a top-level borrow and repay pair that must live
+ * in the same transaction; the repay references the borrow by instruction index.
+ *
+ * @typeParam T - The platform-specific data class extending LendingPlatformData
+ */
+class FlashLoanBase {
+    constructor(data) {
+        this.data = data;
+    }
+}
+exports.FlashLoanBase = FlashLoanBase;

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

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

package/dist/shared/lending-platforms/src/services/flashLoan/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("./flashLoanBase"), exports);
+__exportStar(require("./kamino"), exports);

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

@@ -0,0 +1,11 @@
+import { BN } from "@anchor-lang/core";
+import { type Address, type Instruction } from "@solana/kit";
+import { KaminoData } from "../../data/platform";
+import { FlashBorrowParams, FlashLoanBase, FlashRepayParams } from "./flashLoanBase";
+export declare class KaminoFlashLoan extends FlashLoanBase<KaminoData> {
+    getFlashBorrowIx(params: FlashBorrowParams): Promise<Instruction>;
+    getAvailableFlashBorrowAmount(pool: Address, reserve: Address): Promise<BN>;
+    getFlashLoanFeeRate(pool: Address, reserve: Address): Promise<number>;
+    getFlashRepayIx(params: FlashRepayParams): Promise<Instruction>;
+    private resolveSharedAccounts;
+}

package/dist/shared/lending-platforms/src/services/flashLoan/kamino.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KaminoFlashLoan = void 0;
+const core_1 = require("@anchor-lang/core");
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const kit_1 = require("@solana/kit");
+const klend_sdk_1 = require("@kamino-finance/klend-sdk");
+const common_1 = require("common");
+const flashLoanBase_1 = require("./flashLoanBase");
+/**
+ * Drop the `signer` field from any account meta, leaving the address + role
+ * intact. The Kamino codegen attaches a placeholder `NoopSigner` to the
+ * `userTransferAuthority` meta to satisfy its TS types; if we keep it, Kit's
+ * dedup conflicts with the real fee-payer `KeyPairSigner` whenever the
+ * placeholder address matches the fee payer (or appears twice — borrow +
+ * repay — in the same tx). Stripping it lets `addSignersToTransactionMessage`
+ * re-attach the real signer at compile time.
+ */
+function stripAccountSigners(ix) {
+    if (!ix.accounts)
+        return ix;
+    return {
+        ...ix,
+        accounts: ix.accounts.map((account) => {
+            if (!("signer" in account))
+                return account;
+            const { signer: _signer, ...rest } = account;
+            return rest;
+        }),
+    };
+}
+class KaminoFlashLoan extends flashLoanBase_1.FlashLoanBase {
+    async getFlashBorrowIx(params) {
+        const { reserve, lendingMarketAuthority, destinationAta } = await this.resolveSharedAccounts(params);
+        return stripAccountSigners((0, klend_sdk_1.getBorrowFlashLoanInstruction)({
+            userTransferAuthority: (0, common_1.createSignerFromAddress)(params.user),
+            lendingMarketAuthority,
+            lendingMarketAddress: params.pool,
+            reserve: reserve.rawData,
+            amountLamports: new decimal_js_1.default(params.amountBaseUnits.toString()),
+            destinationAta,
+            referrerAccount: (0, kit_1.none)(),
+            referrerTokenState: (0, kit_1.none)(),
+            programId: klend_sdk_1.PROGRAM_ID,
+        }));
+    }
+    async getAvailableFlashBorrowAmount(pool, reserve) {
+        const reserveData = await this.data.fetchReserve(pool, reserve);
+        return new core_1.BN(reserveData.rawData.getLiquidityAvailableAmount().toFixed(0));
+    }
+    async getFlashLoanFeeRate(pool, reserve) {
+        const reserveData = await this.data.fetchReserve(pool, reserve);
+        return reserveData.config.flashLoanFeePct;
+    }
+    async getFlashRepayIx(params) {
+        const { reserve, lendingMarketAuthority, destinationAta } = await this.resolveSharedAccounts(params);
+        return stripAccountSigners((0, klend_sdk_1.getRepayFlashLoanInstruction)({
+            borrowIxIndex: params.borrowIxIndex,
+            userTransferAuthority: (0, common_1.createSignerFromAddress)(params.user),
+            lendingMarketAuthority,
+            lendingMarketAddress: params.pool,
+            reserve: reserve.rawData,
+            amountLamports: new decimal_js_1.default(params.amountBaseUnits.toString()),
+            userSourceLiquidity: params.userSourceLiquidity ?? destinationAta,
+            referrerAccount: (0, kit_1.none)(),
+            referrerTokenState: (0, kit_1.none)(),
+            programId: klend_sdk_1.PROGRAM_ID,
+        }));
+    }
+    async resolveSharedAccounts(params) {
+        const reserve = await this.data.fetchReserve(params.pool, params.reserve);
+        const [lendingMarketAuthority] = await (0, klend_sdk_1.lendingMarketAuthPda)(params.pool);
+        const liquidityMint = reserve.mint.mint;
+        const tokenProgram = common_1.mints.get(liquidityMint)?.tokenProgram;
+        if (!tokenProgram) {
+            throw new Error(`Unsupported liquidity mint for flash loan: ${liquidityMint}`);
+        }
+        const destinationAta = params.destinationAta ?? (await (0, common_1.getAtaAddress)(liquidityMint, params.user, tokenProgram));
+        return { reserve, lendingMarketAuthority, destinationAta };
+    }
+}
+exports.KaminoFlashLoan = KaminoFlashLoan;

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

@@ -0,0 +1,5 @@
+export * from "./client";
+export * from "./flashLoan";
+export * from "./leverage";
+export * from "./lendingPosition";
+export * from "./reservesManager";

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

@@ -0,0 +1,21 @@
+"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("./client"), exports);
+__exportStar(require("./flashLoan"), exports);
+__exportStar(require("./leverage"), exports);
+__exportStar(require("./lendingPosition"), exports);
+__exportStar(require("./reservesManager"), exports);

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

@@ -0,0 +1,2 @@
+export * from "./lendingPositionManager";
+export * from "./types";

package/dist/shared/lending-platforms/src/services/lendingPosition/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("./lendingPositionManager"), exports);
+__exportStar(require("./types"), exports);