@kestrelfi/lyc-sdk 1.0.1

package/dist/sdks/long-yield-carry/src/services/carry/carryAllocationConfig.d.ts

@@ -0,0 +1,103 @@
+import { type ReserveBase } from "lending-platforms";
+import type { Address } from "@solana/kit";
+import { type VolatilityRegime } from "../../constants/configs/carryTradePresets";
+/** Maximum value for `targetUtilizationRateBps` (100% in basis points). */
+export declare const MAX_TARGET_UTILIZATION_RATE_BPS = 10000;
+/**
+ * Maximum allowed value of `targetUtilizationRateBps + maxDeviationAboveTargetUtilBps`.
+ * Mirrors `MAX_LENDING_POSITION_UPPER_UTIL_BPS` in the on-chain program.
+ */
+export declare const MAX_LENDING_POSITION_UPPER_UTIL_BPS = 10500;
+/**
+ * Floor for `maxDeviationAboveTargetUtilBps` in preset-based computation.
+ *
+ * When the raw target is high enough that the unwind-trigger gap would be
+ * smaller than this, `computeCarryLendingAllocationConfig` pulls the target
+ * down so the above-deviation is at least this wide. This prevents
+ * near-zero unwind bands that would trigger constant rebalances.
+ */
+export declare const MIN_DEVIATION_ABOVE_TARGET_UTIL_BPS = 200;
+/**
+ * On-chain lending position tuning (see `LendingPositionConfig` in `long_yield_carry`).
+ */
+export type CarryLendingAllocationConfig = {
+    targetUtilizationRateBps: number;
+    maxDeviationAboveTargetUtilBps: number;
+    maxDeviationBelowTargetUtilBps: number;
+};
+export type ComputeCarryLendingAllocationConfigParams = {
+    /**
+     * Collateral drawdown buffer between the **target** utilization and liquidation (positive percent,
+     * e.g. `25` for 25%). At target utilization, a collateral drop of this size reaches the liquidation
+     * line: `target = (1 − drawdownPctFromTargetToLiq/100) × liquidationThreshold / maxLtv`.
+     *
+     * Must be greater than `drawdownPctFromUnwindToLiq` (the target sits further from liquidation than
+     * the unwind trigger).
+     */
+    drawdownPctFromTargetToLiq: number;
+    /**
+     * Collateral drawdown buffer between the **unwind trigger** and liquidation (positive percent,
+     * e.g. `10` for 10%). At the unwind trigger (`target + maxDeviationAbove`), a collateral drop of
+     * this size reaches the liquidation line:
+     * `unwindTrigger = (1 − drawdownPctFromUnwindToLiq/100) × liquidationThreshold / maxLtv`.
+     *
+     * Must be less than `drawdownPctFromTargetToLiq`.
+     */
+    drawdownPctFromUnwindToLiq: number;
+    /**
+     * Max collateral **appreciation** (positive percent, e.g. `25` for +25%). If you start exactly at
+     * target utilization and collateral rallies this much (debt USD fixed), utilization reaches the
+     * **boost** trigger: `target − maxDeviationBelow`.
+     */
+    maxPriceChangeUpPercent: number;
+    /** Effective max LTV for the pair (decimal `0.8` = 80%), e.g. `ReservesManager.maxLtv`. */
+    maxLtv: number;
+    /** Collateral liquidation threshold (decimal `0.85` = 85%), from reserve config. */
+    liquidationThreshold: number;
+};
+/** The price-band params without pair-specific LTV / liquidation fields. */
+export type CarryPriceBandPreset = Omit<ComputeCarryLendingAllocationConfigParams, "maxLtv" | "liquidationThreshold">;
+/**
+ * Clamps a lending position config so it satisfies the on-chain constraints in
+ * `require_valid_lending_position_config_bps`:
+ *
+ * - `targetUtilizationRateBps` is clamped to `[1, MAX_TARGET_UTILIZATION_RATE_BPS]`
+ * - `maxDeviationAboveTargetUtilBps` is clamped so `target + above ≤ MAX_LENDING_POSITION_UPPER_UTIL_BPS`
+ *
+ * Throws only for inputs that indicate a bug (non-integer, negative deviation, target ≤ maxDevBelow).
+ */
+export declare function clampLendingPositionConfigBps(config: CarryLendingAllocationConfig): CarryLendingAllocationConfig;
+/**
+ * Builds `targetUtilizationRateBps` and deviation bands from drawdown-to-liquidation buffers.
+ *
+ * **Model:** debt USD fixed; only collateral USD moves. Both the target and the unwind trigger are
+ * defined by how much collateral drawdown separates them from the liquidation line
+ * (`liquidationThreshold / maxLtv`). The boost trigger (below target) is set by a rally percentage.
+ *
+ * `maxDeviationAbove = unwindTriggerBps − targetBps` (derived, not from a price-change input).
+ */
+export declare function computeCarryLendingAllocationConfig(params: ComputeCarryLendingAllocationConfigParams): CarryLendingAllocationConfig;
+export interface ComputeConfigForCollateralArgs {
+    /** Collateral mint address — used to look up the symbol from the mint registry. */
+    collateralMint: Address;
+    /** Collateral reserve — used to read `liquidationThresholdPct`. */
+    collateralReserve: ReserveBase;
+    /** Debt reserve — paired with collateral to determine `maxLtv` (including e-mode). */
+    debtReserve: ReserveBase;
+    /**
+     * Override the volatility regime. When omitted, uses the asset's
+     * `defaultRegime` from `ASSET_PRESETS`.
+     */
+    regime?: VolatilityRegime;
+}
+/**
+ * Resolves the carry trade price-band preset for a collateral mint and
+ * computes the lending position config (target utilization + deviation bands)
+ * using the reserve pair's `maxLtv` and `liquidationThreshold`.
+ *
+ * Uses {@link ReservesManager} to derive `maxLtv` (including e-mode overrides)
+ * and normalizes `liquidationThresholdPct` to a decimal.
+ *
+ * Throws if the collateral mint symbol is not in `ASSET_PRESETS`.
+ */
+export declare function computeConfigForCollateral(args: ComputeConfigForCollateralArgs): CarryLendingAllocationConfig;

package/dist/sdks/long-yield-carry/src/services/carry/carryAllocationConfig.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIN_DEVIATION_ABOVE_TARGET_UTIL_BPS = exports.MAX_LENDING_POSITION_UPPER_UTIL_BPS = exports.MAX_TARGET_UTILIZATION_RATE_BPS = void 0;
+exports.clampLendingPositionConfigBps = clampLendingPositionConfigBps;
+exports.computeCarryLendingAllocationConfig = computeCarryLendingAllocationConfig;
+exports.computeConfigForCollateral = computeConfigForCollateral;
+const lending_platforms_1 = require("lending-platforms");
+const common_1 = require("common");
+const carryTradePresets_1 = require("../../constants/configs/carryTradePresets");
+/** Maximum value for `targetUtilizationRateBps` (100% in basis points). */
+exports.MAX_TARGET_UTILIZATION_RATE_BPS = 10000;
+/**
+ * Maximum allowed value of `targetUtilizationRateBps + maxDeviationAboveTargetUtilBps`.
+ * Mirrors `MAX_LENDING_POSITION_UPPER_UTIL_BPS` in the on-chain program.
+ */
+exports.MAX_LENDING_POSITION_UPPER_UTIL_BPS = 10500;
+/**
+ * Floor for `maxDeviationAboveTargetUtilBps` in preset-based computation.
+ *
+ * When the raw target is high enough that the unwind-trigger gap would be
+ * smaller than this, `computeCarryLendingAllocationConfig` pulls the target
+ * down so the above-deviation is at least this wide. This prevents
+ * near-zero unwind bands that would trigger constant rebalances.
+ */
+exports.MIN_DEVIATION_ABOVE_TARGET_UTIL_BPS = 200;
+/**
+ * Clamps a lending position config so it satisfies the on-chain constraints in
+ * `require_valid_lending_position_config_bps`:
+ *
+ * - `targetUtilizationRateBps` is clamped to `[1, MAX_TARGET_UTILIZATION_RATE_BPS]`
+ * - `maxDeviationAboveTargetUtilBps` is clamped so `target + above ≤ MAX_LENDING_POSITION_UPPER_UTIL_BPS`
+ *
+ * Throws only for inputs that indicate a bug (non-integer, negative deviation, target ≤ maxDevBelow).
+ */
+function clampLendingPositionConfigBps(config) {
+    let { targetUtilizationRateBps, maxDeviationAboveTargetUtilBps, maxDeviationBelowTargetUtilBps } = config;
+    if (!Number.isInteger(targetUtilizationRateBps) || targetUtilizationRateBps <= 0) {
+        throw new Error("targetUtilizationRateBps must be a positive integer");
+    }
+    for (const [name, v] of [
+        ["maxDeviationAboveTargetUtilBps", maxDeviationAboveTargetUtilBps],
+        ["maxDeviationBelowTargetUtilBps", maxDeviationBelowTargetUtilBps],
+    ]) {
+        if (!Number.isInteger(v) || v < 0) {
+            throw new Error(`${name} must be a non-negative integer`);
+        }
+    }
+    targetUtilizationRateBps = Math.min(targetUtilizationRateBps, exports.MAX_TARGET_UTILIZATION_RATE_BPS);
+    maxDeviationAboveTargetUtilBps = Math.min(maxDeviationAboveTargetUtilBps, exports.MAX_LENDING_POSITION_UPPER_UTIL_BPS - targetUtilizationRateBps);
+    if (targetUtilizationRateBps <= maxDeviationBelowTargetUtilBps) {
+        throw new Error("targetUtilizationRateBps must be greater than maxDeviationBelowTargetUtilBps");
+    }
+    return {
+        targetUtilizationRateBps,
+        maxDeviationAboveTargetUtilBps,
+        maxDeviationBelowTargetUtilBps,
+    };
+}
+/**
+ * Builds `targetUtilizationRateBps` and deviation bands from drawdown-to-liquidation buffers.
+ *
+ * **Model:** debt USD fixed; only collateral USD moves. Both the target and the unwind trigger are
+ * defined by how much collateral drawdown separates them from the liquidation line
+ * (`liquidationThreshold / maxLtv`). The boost trigger (below target) is set by a rally percentage.
+ *
+ * `maxDeviationAbove = unwindTriggerBps − targetBps` (derived, not from a price-change input).
+ */
+function computeCarryLendingAllocationConfig(params) {
+    const { drawdownPctFromTargetToLiq, drawdownPctFromUnwindToLiq, maxPriceChangeUpPercent, maxLtv, liquidationThreshold, } = params;
+    if (!Number.isFinite(drawdownPctFromTargetToLiq) ||
+        drawdownPctFromTargetToLiq <= 0 ||
+        drawdownPctFromTargetToLiq >= 100) {
+        throw new RangeError("drawdownPctFromTargetToLiq must be in (0, 100)");
+    }
+    if (!Number.isFinite(drawdownPctFromUnwindToLiq) ||
+        drawdownPctFromUnwindToLiq < 0 ||
+        drawdownPctFromUnwindToLiq >= 100) {
+        throw new RangeError("drawdownPctFromUnwindToLiq must be in [0, 100)");
+    }
+    if (drawdownPctFromUnwindToLiq >= drawdownPctFromTargetToLiq) {
+        throw new RangeError("drawdownPctFromUnwindToLiq must be less than drawdownPctFromTargetToLiq (unwind trigger is closer to liquidation than target)");
+    }
+    if (!Number.isFinite(maxPriceChangeUpPercent) || maxPriceChangeUpPercent <= 0) {
+        throw new RangeError("maxPriceChangeUpPercent must be finite and positive");
+    }
+    const targetDecimal = (0, lending_platforms_1.maxLtvUtilBeforeCollDrawdown)({
+        drawdownPercent: drawdownPctFromTargetToLiq,
+        ltv: maxLtv,
+        liquidationThreshold,
+    });
+    let targetUtilizationRateBps = Math.min(Math.floor(targetDecimal * 10000), exports.MAX_TARGET_UTILIZATION_RATE_BPS);
+    if (targetUtilizationRateBps <= 0) {
+        throw new RangeError("Computed target utilization rounds to zero; reduce drawdownPctFromTargetToLiq or check maxLtv / liquidationThreshold");
+    }
+    const unwindTriggerDecimal = (0, lending_platforms_1.maxLtvUtilBeforeCollDrawdown)({
+        drawdownPercent: drawdownPctFromUnwindToLiq,
+        ltv: maxLtv,
+        liquidationThreshold,
+    });
+    const unwindTriggerBps = Math.floor(unwindTriggerDecimal * 10000);
+    let maxDeviationAboveTargetUtilBps = Math.min(unwindTriggerBps - targetUtilizationRateBps, exports.MAX_LENDING_POSITION_UPPER_UTIL_BPS - targetUtilizationRateBps);
+    // If the above-deviation is below the minimum (e.g. because the target was
+    // clamped to MAX_TARGET_UTILIZATION_RATE_BPS), pull the target down so the
+    // unwind band is at least MIN_DEVIATION_ABOVE_TARGET_UTIL_BPS wide.
+    if (maxDeviationAboveTargetUtilBps < exports.MIN_DEVIATION_ABOVE_TARGET_UTIL_BPS) {
+        maxDeviationAboveTargetUtilBps = exports.MIN_DEVIATION_ABOVE_TARGET_UTIL_BPS;
+        targetUtilizationRateBps = Math.min(targetUtilizationRateBps, exports.MAX_LENDING_POSITION_UPPER_UTIL_BPS - exports.MIN_DEVIATION_ABOVE_TARGET_UTIL_BPS);
+    }
+    const t = targetUtilizationRateBps / 10000;
+    const maxBelowDecimal = (0, lending_platforms_1.ltvUtilDeltaBelowTargForRallyPct)(t, maxPriceChangeUpPercent);
+    const maxDeviationBelowTargetUtilBps = Math.floor(maxBelowDecimal * 10000);
+    return clampLendingPositionConfigBps({
+        targetUtilizationRateBps,
+        maxDeviationAboveTargetUtilBps,
+        maxDeviationBelowTargetUtilBps,
+    });
+}
+/**
+ * Resolves the carry trade price-band preset for a collateral mint and
+ * computes the lending position config (target utilization + deviation bands)
+ * using the reserve pair's `maxLtv` and `liquidationThreshold`.
+ *
+ * Uses {@link ReservesManager} to derive `maxLtv` (including e-mode overrides)
+ * and normalizes `liquidationThresholdPct` to a decimal.
+ *
+ * Throws if the collateral mint symbol is not in `ASSET_PRESETS`.
+ */
+function computeConfigForCollateral(args) {
+    const { collateralMint, collateralReserve, debtReserve } = args;
+    const mintInfo = common_1.mints.get(collateralMint);
+    const symbol = mintInfo?.symbol ?? String(collateralMint);
+    const entry = (0, carryTradePresets_1.resolvePresets)(symbol);
+    if (!entry) {
+        throw new Error(`computeConfigForCollateral: no carry preset found for collateral "${symbol}" (${collateralMint})`);
+    }
+    const regime = args.regime ?? entry.defaultRegime;
+    const preset = entry.presets[regime];
+    const rm = new lending_platforms_1.ReservesManager(collateralReserve, debtReserve);
+    const pct = collateralReserve.config.liquidationThresholdPct;
+    const liquidationThreshold = pct <= 1 ? pct : pct / 100;
+    return computeCarryLendingAllocationConfig({
+        ...preset,
+        maxLtv: rm.maxLtv,
+        liquidationThreshold,
+    });
+}

package/dist/sdks/long-yield-carry/src/services/carry/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./carryAllocationConfig";
+export * from "./lycLendingPositionManager";

package/dist/sdks/long-yield-carry/src/services/carry/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("./carryAllocationConfig"), exports);
+__exportStar(require("./lycLendingPositionManager"), exports);

package/dist/sdks/long-yield-carry/src/services/carry/lycLendingPositionManager.d.ts

@@ -0,0 +1,39 @@
+import { type Environment } from "common";
+import { LendingPlatformData, LendingPositionManager, ReserveBase, type CollateralPriceTriggerBand, type LendingPositionInspectMetrics } from "lending-platforms";
+import { TokenLendingPositionData } from "../../models/lycToken";
+import { type CarryLendingAllocationConfig, type CarryPriceBandPreset } from "./carryAllocationConfig";
+/**
+ * LYC-flavoured {@link LendingPositionManager}: adds carry-specific sizing
+ * signals ({@link shouldIncreaseCarryPosition}, {@link shouldDecreaseCarryPosition})
+ * and defaults utilization targets from the on-chain `LendingPositionConfig`.
+ */
+export declare class LycLendingPositionManager extends LendingPositionManager {
+    readonly lendingPosition: TokenLendingPositionData;
+    constructor(lpData: LendingPlatformData, lendingPosition: TokenLendingPositionData, collateralReserve: ReserveBase, debtReserve: ReserveBase, environment?: Environment);
+    static create(lpData: LendingPlatformData, lendingPosition: TokenLendingPositionData, environment?: Environment): Promise<LycLendingPositionManager>;
+    /**
+     * Derives `targetUtilizationRateBps` and carry trigger deviations from drawdown-to-liquidation
+     * buffers and a rally percentage, using this pair's {@link ReservesManager.maxLtv} and the
+     * collateral reserve's **base** `liquidationThresholdPct` (normalized to a decimal).
+     *
+     * For custom `maxLtv` / `liquidationThreshold` (e.g. e-mode liquidation threshold), call
+     * {@link computeCarryLendingAllocationConfig} directly.
+     */
+    getLendingAllocationConfigFromPriceBands(params: CarryPriceBandPreset): CarryLendingAllocationConfig;
+    /**
+     * Returns true when the current LTV utilization (valued at EMA prices) has
+     * fallen far enough below the target that the position should be boosted.
+     */
+    shouldIncreaseCarryPosition(): Promise<boolean>;
+    /**
+     * Returns true when the current LTV utilization (valued at realtime prices) has
+     * risen far enough above the target that the position should be unwound.
+     */
+    shouldDecreaseCarryPosition(): Promise<boolean>;
+    calcDebtChangeAmount(targetUtilizationRateBps?: number): Promise<number>;
+    calcPreWithdrawalTargetUtilizationRateBps(withdrawUiCollateralAmount: number, postWithdrawalTargetUtilizationRateBps?: number): Promise<number>;
+    calcDebtChangeAmountForCollateralWithdrawal(withdrawUiCollateralAmount: number, postWithdrawalTargetUtilizationRateBps?: number): Promise<number>;
+    getCollateralPriceTriggerBand(): Promise<CollateralPriceTriggerBand>;
+    getInspectMetrics(): Promise<LendingPositionInspectMetrics | null>;
+    private configTriggerBandBps;
+}

package/dist/sdks/long-yield-carry/src/services/carry/lycLendingPositionManager.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LycLendingPositionManager = void 0;
+const common_1 = require("common");
+const lending_platforms_1 = require("lending-platforms");
+const carryAllocationConfig_1 = require("./carryAllocationConfig");
+/**
+ * LYC-flavoured {@link LendingPositionManager}: adds carry-specific sizing
+ * signals ({@link shouldIncreaseCarryPosition}, {@link shouldDecreaseCarryPosition})
+ * and defaults utilization targets from the on-chain `LendingPositionConfig`.
+ */
+class LycLendingPositionManager extends lending_platforms_1.LendingPositionManager {
+    constructor(lpData, lendingPosition, collateralReserve, debtReserve, environment) {
+        super(lpData, (0, common_1.fromWeb3Pk)(lendingPosition.pool), (0, common_1.fromWeb3Pk)(lendingPosition.protocolUserAcc), collateralReserve, debtReserve, environment);
+        this.lendingPosition = lendingPosition;
+    }
+    static async create(lpData, lendingPosition, environment) {
+        const pool = (0, common_1.fromWeb3Pk)(lendingPosition.pool);
+        const [collateralReserve, debtReserve] = await Promise.all([
+            lpData.fetchReserve(pool, (0, common_1.fromWeb3Pk)(lendingPosition.collateralReserve)),
+            lpData.fetchReserve(pool, (0, common_1.fromWeb3Pk)(lendingPosition.debtReserve)),
+        ]);
+        if (!collateralReserve || !debtReserve) {
+            throw new Error("Failed to fetch reserves");
+        }
+        return new LycLendingPositionManager(lpData, lendingPosition, collateralReserve, debtReserve, environment);
+    }
+    /**
+     * Derives `targetUtilizationRateBps` and carry trigger deviations from drawdown-to-liquidation
+     * buffers and a rally percentage, using this pair's {@link ReservesManager.maxLtv} and the
+     * collateral reserve's **base** `liquidationThresholdPct` (normalized to a decimal).
+     *
+     * For custom `maxLtv` / `liquidationThreshold` (e.g. e-mode liquidation threshold), call
+     * {@link computeCarryLendingAllocationConfig} directly.
+     */
+    getLendingAllocationConfigFromPriceBands(params) {
+        const pct = this.reservesManager.supplyReserve.config.liquidationThresholdPct;
+        const liquidationThreshold = pct <= 1 ? pct : pct / 100;
+        return (0, carryAllocationConfig_1.computeCarryLendingAllocationConfig)({
+            ...params,
+            maxLtv: this.reservesManager.maxLtv,
+            liquidationThreshold,
+        });
+    }
+    /**
+     * Returns true when the current LTV utilization (valued at EMA prices) has
+     * fallen far enough below the target that the position should be boosted.
+     */
+    async shouldIncreaseCarryPosition() {
+        const state = await this.getPositionState("ema");
+        if (!state)
+            return false;
+        const { supplyUsd, debtUsd } = state;
+        if (supplyUsd <= 0)
+            return false;
+        const currentUtilBps = this.reservesManager.calcLtvUtilizationRateBps(supplyUsd, debtUsd);
+        return (currentUtilBps <=
+            this.lendingPosition.config.targetUtilizationRateBps -
+                this.lendingPosition.config.maxDeviationBelowTargetUtilBps);
+    }
+    /**
+     * Returns true when the current LTV utilization (valued at realtime prices) has
+     * risen far enough above the target that the position should be unwound.
+     */
+    async shouldDecreaseCarryPosition() {
+        const state = await this.getPositionState("realtime");
+        if (!state)
+            return false;
+        const { supplyUsd, debtUsd } = state;
+        const currentUtilBps = this.reservesManager.calcLtvUtilizationRateBps(supplyUsd, debtUsd);
+        return (currentUtilBps >=
+            this.lendingPosition.config.targetUtilizationRateBps +
+                this.lendingPosition.config.maxDeviationAboveTargetUtilBps);
+    }
+    async calcDebtChangeAmount(targetUtilizationRateBps = this.lendingPosition.config.targetUtilizationRateBps) {
+        return super.calcDebtChangeAmount(targetUtilizationRateBps);
+    }
+    async calcPreWithdrawalTargetUtilizationRateBps(withdrawUiCollateralAmount, postWithdrawalTargetUtilizationRateBps = this.lendingPosition.config
+        .targetUtilizationRateBps) {
+        return super.calcPreWithdrawalTargetUtilizationRateBps(withdrawUiCollateralAmount, postWithdrawalTargetUtilizationRateBps);
+    }
+    async calcDebtChangeAmountForCollateralWithdrawal(withdrawUiCollateralAmount, postWithdrawalTargetUtilizationRateBps = this.lendingPosition.config
+        .targetUtilizationRateBps) {
+        return super.calcDebtChangeAmountForCollateralWithdrawal(withdrawUiCollateralAmount, postWithdrawalTargetUtilizationRateBps);
+    }
+    async getCollateralPriceTriggerBand() {
+        return super.getCollateralPriceTriggerBand(this.configTriggerBandBps());
+    }
+    async getInspectMetrics() {
+        return super.getInspectMetrics(this.configTriggerBandBps());
+    }
+    configTriggerBandBps() {
+        const { targetUtilizationRateBps, maxDeviationBelowTargetUtilBps, maxDeviationAboveTargetUtilBps, } = this.lendingPosition.config;
+        return {
+            lowerTargetUtilizationRateBps: targetUtilizationRateBps - maxDeviationBelowTargetUtilBps,
+            upperTargetUtilizationRateBps: targetUtilizationRateBps + maxDeviationAboveTargetUtilBps,
+        };
+    }
+}
+exports.LycLendingPositionManager = LycLendingPositionManager;

package/dist/sdks/long-yield-carry/src/services/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./allocation";
+export * from "./carry";
+export * from "./lendingPosition";
+export * from "./rebalance";
+export * from "./redemption";

package/dist/sdks/long-yield-carry/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("./allocation"), exports);
+__exportStar(require("./carry"), exports);
+__exportStar(require("./lendingPosition"), exports);
+__exportStar(require("./rebalance"), exports);
+__exportStar(require("./redemption"), exports);

package/dist/sdks/long-yield-carry/src/services/lendingPosition/index.d.ts

@@ -0,0 +1,2 @@
+export { LendingPositionService } from "./lendingPositionService";
+export type { EnsureInitialKaminoLendingPositionOptions, OptimalLendingPosition, } from "./lendingPositionService";

package/dist/sdks/long-yield-carry/src/services/lendingPosition/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LendingPositionService = void 0;
+var lendingPositionService_1 = require("./lendingPositionService");
+Object.defineProperty(exports, "LendingPositionService", { enumerable: true, get: function () { return lendingPositionService_1.LendingPositionService; } });

package/dist/sdks/long-yield-carry/src/services/lendingPosition/lendingPositionService.d.ts

@@ -0,0 +1,88 @@
+import { type Address, type TransactionSigner } from "@solana/kit";
+import type { LongYieldCarryClient } from "../../client/client";
+import type { LongYieldCarryTransactionPlan } from "../../client/types";
+import type { IndexedLendingPosition, LYCToken } from "../../models/lycToken";
+export interface OptimalLendingPosition {
+    /** The lending position selected. */
+    lp: IndexedLendingPosition;
+    /** Debt mint of the selected position. */
+    debtMint: Address;
+    /** Human-readable symbol of the debt mint. */
+    debtSymbol: string;
+    /** Whether this position uses the optimal debt mint (true) or is the best available fallback. */
+    isOptimal: boolean;
+}
+type LogFn = (msg: string) => void;
+export interface EnsureInitialKaminoLendingPositionOptions {
+    manager: TransactionSigner;
+    /** When set, refreshes the per-token LUT after the new LP is created. */
+    lutManager?: TransactionSigner;
+    token: LYCToken;
+    sendPlan: (plan: LongYieldCarryTransactionPlan, label: string) => Promise<void>;
+    log?: LogFn;
+}
+/**
+ * Shared logic for choosing and interacting with a token's lending positions
+ * based on allocation optimality. Used by {@link RedemptionService} (to
+ * prioritize which positions to unwind) and by deposit scripts / backend
+ * services (to deposit into the best position).
+ */
+export declare class LendingPositionService {
+    private readonly client;
+    constructor(client: LongYieldCarryClient);
+    /**
+     * Returns the lending position whose debt mint matches the current optimal
+     * allocation. If no position matches the optimal mint, returns the position
+     * with the most collateral as a fallback.
+     *
+     * Returns `null` only when the token has no active lending positions.
+     */
+    findOptimalLendingPosition(token: LYCToken, log?: LogFn): Promise<OptimalLendingPosition | null>;
+    /**
+     * Sorts lending positions so non-optimal debt mints come first. Useful for
+     * choosing which positions to unwind during redemptions — non-optimal
+     * positions are unwound first to preserve the best-yielding ones.
+     *
+     * Returns the original order if there's only one LP or the optimal mint
+     * lookup fails.
+     */
+    sortByOptimality(token: LYCToken, lps: IndexedLendingPosition[], log?: LogFn): Promise<IndexedLendingPosition[]>;
+    /**
+     * Opens the first Kamino lending position on a token that has none yet.
+     *
+     * Mirrors `scripts/createTokenLendingPosition.ts` and the create-LP branch in
+     * `TokenRebalanceWorker`: resolve pool + optimal debt mint, compute carry
+     * allocation config, send `createTokenLendingPosition`, then refetch the token.
+     *
+     * Kamino-specific: the flow resolves the default Kamino pool, fetches Kamino
+     * reserves, and uses {@link AllocationService} over Kamino reserve data. It is
+     * named accordingly until a second lending platform actually needs bootstrap
+     * support (avoid speculative platform abstraction with a single implementation).
+     *
+     * No-op when the token already has at least one active lending position slot.
+     *
+     * @throws {LendingPositionBootstrapError} when the token cannot be bootstrapped
+     *   because of a permanent configuration gap (collateral mint not in any pool,
+     *   no preset, no viable debt mint / reserve). Callers should treat this as a
+     *   skip rather than a retryable failure.
+     */
+    ensureInitialKaminoLendingPosition(options: EnsureInitialKaminoLendingPositionOptions): Promise<LYCToken>;
+    /**
+     * Deposits unlent collateral into the optimal lending position. Refreshes
+     * the token state first, then deposits all unlent collateral into the
+     * position returned by {@link findOptimalLendingPosition}.
+     */
+    depositToOptimalPosition(signer: TransactionSigner, token: LYCToken, log?: LogFn): Promise<{
+        signature: string;
+        lendingPositionIndex: number;
+        debtSymbol: string;
+    }>;
+    /**
+     * Queries `AllocationService.findOptimalDebtMint` for the token's
+     * pool + collateral pair. Returns null on any failure (missing reserve, etc.).
+     */
+    private findOptimalDebtMint;
+    private largestLp;
+    private toLpResult;
+}
+export {};