@kestrelfi/lyc-sdk 1.0.1

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

@@ -0,0 +1,6 @@
+export * from "./builders";
+export * from "./enums";
+export * from "./general";
+export * from "./ix";
+export * from "./planTypes/index";
+export * from "./tx";

package/dist/sdks/long-yield-carry/src/client/types/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("./builders"), exports);
+__exportStar(require("./enums"), exports);
+__exportStar(require("./general"), exports);
+__exportStar(require("./ix"), exports);
+__exportStar(require("./planTypes/index"), exports);
+__exportStar(require("./tx"), exports);

package/dist/sdks/long-yield-carry/src/client/types/ix.d.ts

@@ -0,0 +1,352 @@
+import { type BN } from "@anchor-lang/core";
+import { type Address } from "@solana/kit";
+import { type AnchorInterestDistribution, type AnchorLendingType } from "./enums";
+import { type OracleConfigDetails, type FeeConfig, type PricedMint } from "./general";
+import { type AnchorTokenProgram, type AnchorLendingPlatform, type AnchorOracleType, type InstructionRefs, type CustomAccountMeta, AnchorExternalLiquidityType } from "common";
+export interface CreateCpiPlanParams {
+    /** Unique ID used in PDA derivation. For rebalance_token this is the Token PDA. */
+    uniqueId: Address;
+    /** Unix timestamp seconds used in PDA derivation. */
+    createdTs: BN;
+    /** Up to 10 instruction refs packed into the zero-copy CPI plan account. */
+    refs: InstructionRefs[];
+}
+export interface CreateYieldingBankParams {
+    /** Unique ID for this yielding bank (u8), used in PDA derivation */
+    id: number;
+    /** Oracle configuration for pricing the base asset */
+    oracleConfig: OracleConfigDetails;
+    /** The mint used as the default source when redeeming from the bank */
+    defaultRedemptionMint: Address;
+}
+export interface UpdateYieldingBankConfigParams {
+    /** New default redemption mint (passed as a named account, not a param) */
+    defaultRedemptionMint: Address;
+}
+export interface UpdateTokenConfigurationParams {
+    performanceFeeBps: number;
+    mintingFeeBps: number;
+    burningFeeBps: number;
+    protocolMintBurnPctBps: number;
+    curatorMintBurnPctBps: number;
+    curatorPerfPctBps: number;
+    /**
+     * Cap (bps) on annualized price growth from the fee drip; `0` disables.
+     * Omit to preserve the token's current on-chain value.
+     */
+    feeDripMaxApyBps?: number;
+    /**
+     * Seconds over which absorbed mint/burn fees release into the price.
+     * `0` parks fees until recollateralization consumes them.
+     * Omit to preserve the token's current on-chain value.
+     */
+    feeDripDurationSecs?: BN;
+    burnRateLimit?: {
+        maxAmount: BN;
+        windowDurationSecs: BN;
+    };
+    /**
+     * When set, updates the deposit cap in raw collateral base units. Omit to leave unchanged.
+     * Pass `new BN(0)` to disable the cap (same semantics as `mint_token`).
+     */
+    depositLimit?: BN;
+}
+export interface CreateTokenParams {
+    /** Unique ID for this token (u8), used in PDA derivation */
+    id: number;
+    /** How interest is distributed */
+    interestDistribution: AnchorInterestDistribution;
+    /** Oracle configuration for pricing the collateral asset */
+    oracleConfig: OracleConfigDetails;
+    /** Fee configuration */
+    feeConfig: FeeConfig;
+}
+/** Configuration for the collateral or debt side of an external position */
+export interface AssetAllocationConfig {
+    mint: Address;
+    decimals: number;
+    tokenProgram: AnchorTokenProgram;
+}
+/**
+ * Configuration for adding a new asset holding.
+ *
+ * `mint` resolves the `allocation_mint` account — it is not serialized as an
+ * instruction param. Decimals and token program are read from the mint
+ * account on-chain.
+ */
+export interface AssetConfig {
+    mint: Address;
+    oracle: Address;
+    oracleType: AnchorOracleType;
+    externalLiquidityType: AnchorExternalLiquidityType;
+}
+/** Configuration for adding a new external yielding position */
+export interface ExternalPositionConfig {
+    lendingPlatform: AnchorLendingPlatform;
+    lendingType: AnchorLendingType;
+    pool: Address;
+    collateralReserve: Address;
+    debtReserve: Address;
+    protocolUserAcc: Address;
+    collateral: AssetAllocationConfig;
+    debt: AssetAllocationConfig;
+}
+/**
+ * Registers one new holding or external position before a rebalance.
+ * At most one of `assetHolding` or `externalPosition` may be set per call.
+ */
+export interface YieldingBankAllocationConfig {
+    assetHolding?: AssetConfig;
+    externalPosition?: ExternalPositionConfig;
+}
+export interface RebalanceYieldingBankParams {
+    /**
+     * Pre-built instruction refs containing deduplicated CPI account indices,
+     * CPI type registry indices, and packed args.
+     *
+     * Build with `createCpiRefs(cpis, { initialAccounts: oracleAccounts })` so
+     * that oracle and CPI accounts are deduplicated into a single pool and the
+     * indices in `ixRefs` already account for the oracle account positions.
+     */
+    ixRefs: InstructionRefs;
+    /**
+     * The fully deduplicated remaining-accounts pool for this instruction —
+     * oracle accounts at the front followed by any CPI-only accounts.
+     *
+     * This is the `accounts` array returned by `createCpiRefs` when called with
+     * `initialAccounts: oracleAccounts`.
+     */
+    remainingAccounts: CustomAccountMeta[];
+}
+/**
+ * Parameters for `createTokenLendingPosition`. Account-backed values (protocol
+ * user account, collateral reserve, debt oracle) are passed as accounts via
+ * `CreateTokenLendingPositionIxArgs.lpPosition`, not duplicated here.
+ */
+export interface CreateTokenLendingPositionParams {
+    lendingPlatform: AnchorLendingPlatform;
+    pool: Address;
+    debtReserve: Address;
+    targetUtilizationRateBps: number;
+    maxDeviationAboveTargetUtilBps: number;
+    maxDeviationBelowTargetUtilBps: number;
+    debtMint: Address;
+    debtDecimals: number;
+    debtTokenProgram: AnchorTokenProgram;
+    debtOracleType: AnchorOracleType;
+    /**
+     * Optional setup CPIs (e.g. Kamino init_user_metadata, init_obligation,
+     * refresh_reserve, refresh_obligation) signed by the Token PDA and executed
+     * before the final refresh. When provided, the on-chain refresh reads the
+     * freshly-initialized protocol user account; otherwise the refresh is a
+     * no-op over an empty account.
+     */
+    tokenCpis?: InstructionRefs;
+    /** Fully deduplicated remaining-accounts pool for `tokenCpis`. */
+    remainingAccounts?: CustomAccountMeta[];
+}
+/**
+ * Accounts that describe and back a new lending position. Their pubkeys are
+ * stored on the position; their on-chain state is read by the final refresh.
+ */
+export interface CreateTokenLendingPositionAccounts {
+    /** The program's user/authority account on the lending protocol. */
+    protocolUserAcc: Address;
+    /** The lending protocol's reserve/bank for the collateral asset. */
+    collateralReserve: Address;
+    /** Oracle for the debt asset's price. */
+    debtOracle: Address;
+}
+export interface UpdateLendingPositionConfigParams {
+    lendingPositionIndex: number;
+    targetUtilizationRateBps: number;
+    maxDeviationAboveTargetUtilBps: number;
+    maxDeviationBelowTargetUtilBps: number;
+}
+export interface DepositUnlentCollateralParams {
+    /** Pre-built deposit CPI refs (must contain exactly one Deposit CPI). */
+    ixRefs: InstructionRefs;
+    /** Index into the token's lending_positions array for the target position. */
+    lendingPositionIndex: number;
+    /** Fully deduplicated remaining-accounts pool for the deposit CPI. */
+    remainingAccounts: CustomAccountMeta[];
+}
+export interface IncreaseCarryPositionParams {
+    /** Optional prerequisite CPIs executed before any lending-position refresh. */
+    prerequisiteCpis?: InstructionRefs;
+    /** Pre-built borrow CPI refs (must contain exactly one Borrow CPI). */
+    ixRefs: InstructionRefs;
+    /** Index into the token's lending_positions array for the position to borrow against. */
+    lendingPositionIndex: number;
+    /**
+     * The fully deduplicated remaining-accounts pool for the borrow CPI.
+     * Carry-trade accounts (token, yieldingBank, tokenLpDebtTa, yieldingBankTa,
+     * lendingPositionUserAccount, lendingPositionCollateralReserve, debtOracle,
+     * debtTokenProgram) are prepended automatically.
+     */
+    remainingAccounts: CustomAccountMeta[];
+}
+export interface ClaimIncentivesParams {
+    /** Optional prerequisite CPIs (reserve / obligation refresh) executed before the claim CPI. */
+    prerequisiteCpis?: InstructionRefs;
+    /** Pre-built Kamino claim-incentive CPI refs. */
+    tokenIxRefs: InstructionRefs;
+    /** Index into the token's lending_positions array. */
+    lendingPositionIndex: number;
+    /** Incentive reward mint expected to be claimed. */
+    expectedIncentiveMint: Address;
+    /** Token program for the incentive mint. */
+    incentiveTokenProgram: Address;
+    /** Oracle type for `incentiveOracle`. Required on debt and collateral branches. */
+    incentiveOracleType: AnchorOracleType;
+    /**
+     * Yielding bank that receives the claimed rewards and mints carry shares.
+     * Required on the debt branch; null otherwise.
+     */
+    yieldingBank: Address | null;
+    /**
+     * Oracle pricing `expectedIncentiveMint`. Required on the debt and
+     * collateral branches; null on the fee branch.
+     */
+    incentiveOracle: Address | null;
+    /**
+     * Optional curator fee wallet override. When null/omitted, builders resolve
+     * `token.roles.curator_fee_wallet()` and still pass the fee wallet accounts.
+     */
+    feeWallet?: Address | null;
+    /** Fully deduplicated remaining-accounts pool for the claim CPI. */
+    remainingAccounts: CustomAccountMeta[];
+}
+export interface TokenLpPositionAccountOverrides {
+    /** Override for the lending position protocol user account. */
+    userAccount?: Address;
+    /** Override for the lending position collateral reserve. */
+    collateralReserve?: Address;
+    /** Override for the lending position debt oracle. */
+    debtOracle?: Address;
+}
+export interface RebalanceTokenParams {
+    /** Index into the token's lending_positions array for the position to rebalance in place. */
+    lpIndex: number;
+    /** Oracle type for the destination debt mint. Used to update the stored oracle_type after swapping debt in place. */
+    destinationDebtOracleType: AnchorOracleType;
+    /**
+     * Flash-loan fee in source-debt base units. The on-chain handler derives
+     * the total flash-repay amount from this plus the source-debt ATA balance
+     * observed at handler entry (= what Kamino actually flash-borrowed),
+     * caps it at 5 bps of the principal as a sanity check, and uses it as
+     * the post-swap balance threshold + dust-sweep cutoff + SPL Approve
+     * delegation amount.
+     */
+    flashFeeAmount: BN;
+    /**
+     * Source LP repay amount in the flash-borrowed mint's base units. The on-chain
+     * handler injects this into the repay CPI loaded from the CPI plan.
+     */
+    repayAmount: BN;
+    /** CPI plan PDA holding refs in order: repay, borrow, swap. */
+    cpiPlan: Address;
+    /**
+     * Fully deduplicated remaining-accounts pool. The first 7 slots must hold
+     * the rebalance-token initial accounts (see `buildRebalanceTokenInitialAccounts`),
+     * followed by any CPI accounts referenced by the CPI plan's refs.
+     */
+    remainingAccounts: CustomAccountMeta[];
+}
+export interface DecreaseCarryPositionParams {
+    /** Optional prerequisite CPIs executed before any lending-position refresh. */
+    prerequisiteCpis?: InstructionRefs;
+    /**
+     * Optional manager-only target utilization override used for the post-repay
+     * utilization check.
+     */
+    targetUtilizationRateBps?: number;
+    /**
+     * Optional CPI refs for yielding-bank operations (withdraw from external
+     * positions, swap yield-bearing asset into debt token). Omit this when the
+     * yielding bank already holds the debt tokens.
+     */
+    ybIxRefs?: InstructionRefs;
+    /** Pre-built repay CPI refs (must contain exactly one Repay CPI). */
+    tokenIxRefs: InstructionRefs;
+    /** Index into the token's lending_positions array for the position to repay. */
+    lendingPositionIndex: number;
+    /**
+     * Amount of debt tokens to repay. When omitted, `ybIxRefs` must be provided
+     * and the amount is derived from the yielding bank TA balance change.
+     * `AMOUNT_ALL_SENTINEL` repays the maximum available amount, capped by
+     * current debt. When set with `ybIxRefs`, the on-chain instruction only swaps
+     * if the yielding bank is short and caps non-manager swap over-output.
+     */
+    repayAmount?: BN;
+    /**
+     * Index of the asset holding used as the swap source (0 = base_asset,
+     * 1–12 = assets[0–11]). Required when `ybIxRefs` is provided.
+     * Non-manager signers may only specify a holding whose mint matches the
+     * bank's `default_redemption_mint`.
+     */
+    sourceAssetHoldingIndex?: number;
+    /** Optional redemption epoch that absorbs DCP unwind loss for async burns. */
+    redemptionEpoch?: Address;
+    /**
+     * The fully deduplicated remaining-accounts pool for the CPIs.
+     * Carry-trade accounts (token, yieldingBank, tokenLpDebtTa, yieldingBankTa,
+     * lendingPositionUserAccount, lendingPositionCollateralReserve, debtOracle,
+     * debtTokenProgram) are prepended automatically.
+     */
+    remainingAccounts: CustomAccountMeta[];
+}
+/**
+ * Low-level params for `ix.burnToken`. Pre-built refs and accounts must be
+ * assembled by the caller (typically `tx.getBurnTokenTx`).
+ */
+export interface BurnTokenIxParams {
+    burnAmount: BN | number;
+    asyncFallback?: {
+        epochId: BN | number;
+        requestSequence: BN | number;
+        redemptionEpoch?: Address;
+        request?: Address;
+    };
+}
+export interface SetRedemptionEpochStatusParams {
+    status: number;
+}
+export interface TopUpUnlentReservesParams {
+    prerequisiteCpis: InstructionRefs;
+    ixRefs: InstructionRefs;
+    lendingPositionIndex: number;
+    remainingAccounts: CustomAccountMeta[];
+    redemptionEpoch?: Address;
+}
+export interface UpdateTokenMetadataParams {
+    /** Pre-built Metaplex UpdateMetadataAccountV2 CPI refs (exactly one CPI). */
+    ixRefs: InstructionRefs;
+    /** Fully deduplicated remaining-accounts pool for the metadata CPI. */
+    remainingAccounts: CustomAccountMeta[];
+}
+export interface RecollateralizeLossParams {
+    /** Optional prerequisite CPIs executed before any lending-position refresh. */
+    prerequisiteCpis?: InstructionRefs;
+    /**
+     * CPI refs for the Withdraw -> Swap -> Repay sequence (exactly 1 of each,
+     * in that order). All three CPIs share one deduplicated account pool.
+     */
+    ixRefs: InstructionRefs;
+    /** Index into the token's lending_positions array. */
+    lendingPositionIndex: number;
+    /** Fully deduplicated remaining-accounts pool for the withdraw/swap/repay CPIs. */
+    remainingAccounts: CustomAccountMeta[];
+    /** Yielding bank to deposit any excess debt tokens after repay. Required for execution; may be omitted when testing pre-condition failures. */
+    yieldingBank?: Address;
+    /** Optional explicit overrides for LP refresh accounts. */
+    lpPosition?: TokenLpPositionAccountOverrides;
+}
+export interface CollectInterestParams {
+    /** Default redemption asset being sold in the swap. */
+    redemption: PricedMint;
+    /** Pre-built swap CPI refs (yielding bank assets -> collateral). */
+    refs: InstructionRefs;
+    /** Fully deduplicated remaining-accounts pool for the swap CPIs. */
+    remainingAccounts: CustomAccountMeta[];
+}

package/dist/sdks/long-yield-carry/src/client/types/ix.js

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

package/dist/sdks/long-yield-carry/src/client/types/planTypes/collectInterest.d.ts

@@ -0,0 +1,91 @@
+import type { BN } from "@anchor-lang/core";
+import type { Address } from "@solana/kit";
+import type { CpiData } from "common";
+import type { PricedMint } from "../general";
+import type { SingleCpiExecutionPlan } from "./common";
+/**
+ * Deterministic inputs for deriving a `collect_interest` plan.
+ */
+export interface CollectInterestPlanParams {
+    /** Yielding bank whose active carry position should be partially redeemed. */
+    yieldingBank: Address;
+    /**
+     * Minimum net yield (in USD) below which collection is skipped.
+     * Prevents wasteful swaps when accrued interest is negligible.
+     * Value is in human-readable USD (e.g. 0.5 = $0.50).
+     */
+    minYieldUsd?: number;
+}
+/**
+ * One yielding-bank holding that should be redeemed during interest collection.
+ */
+export interface CollectInterestHoldingPlan {
+    /** Mint held by the yielding bank allocation. */
+    mint: Address;
+    /** Amount to redeem in raw base units for this holding. */
+    amount: BN;
+    /** Whether this holding came from the bank's base-asset slot. */
+    isBaseAsset: boolean;
+}
+/**
+ * Deterministic `collect_interest` plan produced by `client.planner`.
+ *
+ * This captures protocol-derived values only: the active carry position,
+ * shares to burn, and the ordered bank holdings that should be redeemed.
+ * It intentionally does not encode swap venue or routing policy.
+ */
+export interface CollectInterestPlan {
+    /** Token PDA whose carry position is collecting accrued yield. */
+    token: Address;
+    /** Yielding bank the active carry position is allocated to. */
+    yieldingBank: Address;
+    /** Base mint configured on the yielding bank. */
+    baseMint: Address;
+    /** Default redemption asset that accrued interest is collected from. */
+    redemption: PricedMint;
+    /** Token collateral asset that collection must ultimately end in. */
+    collateral: PricedMint;
+    /** Index of the active `debtCarry` entry on the token account. */
+    carryIndex: number;
+    /** Number of carry-position shares the program should burn. */
+    sharesToBurn: BN;
+    /** USD value represented by the burned shares, in program-scale units. */
+    sharesBurnedValueUsd: BN;
+    /** Ordered yielding-bank holdings to redeem before final collateral settlement. */
+    holdingsToRedeem: CollectInterestHoldingPlan[];
+}
+/**
+ * Caller-controlled routing inputs for turning a deterministic collect-interest
+ * plan into concrete swap CPI data.
+ */
+export interface CollectInterestRouteBuilderParams {
+    /** Final output mint. Defaults to `plan.collateral.mint`. */
+    outputMint?: Address;
+    /** Slippage tolerance applied to all collect-interest swaps. Defaults to `100`. */
+    slippageBps?: number;
+}
+/**
+ * Manual CPI inputs for callers that already know the exact swap sequence they
+ * want `collect_interest` to execute.
+ */
+export interface CollectInterestBuilderParams {
+    /** Yielding bank whose shares will be redeemed. */
+    yieldingBank: Address;
+    /** Prebuilt CPI descriptors that swap redeemed assets into collateral. */
+    cpiData: CpiData[];
+}
+/**
+ * Fully executable `collect_interest` plan produced by `client.routeBuilder`.
+ *
+ * Extends the deterministic planner result with the exact CPI sequence,
+ * pre-instructions, and initial accounts required by the final tx composer.
+ */
+export interface CollectInterestExecutionPlan extends CollectInterestPlan, SingleCpiExecutionPlan {
+}
+/**
+ * Precomputed execution-plan wrapper accepted by `client.tx.collectInterest.getTx({...})`.
+ */
+export interface CollectInterestTxPlanParams {
+    /** Route-builder result previously returned by `client.routeBuilder.buildCollectInterestRoutePlan()`. */
+    plan: CollectInterestExecutionPlan;
+}

package/dist/sdks/long-yield-carry/src/client/types/planTypes/collectInterest.js

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

package/dist/sdks/long-yield-carry/src/client/types/planTypes/common.d.ts

@@ -0,0 +1,28 @@
+import type { Instruction } from "@solana/kit";
+import type { CpiData, CustomAccountMeta } from "common";
+/**
+ * Shared fields carried by normalized execution plans.
+ *
+ * These values are produced before the transaction layer resolves remaining
+ * account refs and ATA creation instructions.
+ */
+export interface PlannedInstructionBase {
+    /** Pre-instructions that must run before ATA creation or the main instruction. */
+    preInstructions: Instruction[];
+    /** Accounts that must lead the remaining-accounts pool before CPI accounts are appended. */
+    initialAccounts: CustomAccountMeta[];
+}
+/**
+ * Execution-plan shape for instructions that use a single CPI ref group.
+ */
+export interface SingleCpiExecutionPlan extends PlannedInstructionBase {
+    /** Ordered CPI descriptors consumed by one instruction-level refs input. */
+    cpiData: CpiData[];
+}
+/**
+ * Execution-plan shape for instructions that use multiple CPI ref groups.
+ */
+export interface GroupedCpiExecutionPlan extends PlannedInstructionBase {
+    /** Ordered CPI groups where each group maps to a distinct refs input. */
+    cpiDataGroups: CpiData[][];
+}

package/dist/sdks/long-yield-carry/src/client/types/planTypes/common.js

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

package/dist/sdks/long-yield-carry/src/client/types/planTypes/decreaseCarryPosition.d.ts

@@ -0,0 +1,128 @@
+import type { Address } from "@solana/kit";
+import type BN from "bn.js";
+import type { LendingPlatformData, LpInstructionsBase } from "lending-platforms";
+import type { CpiData, Environment } from "common";
+import type { GroupedCpiExecutionPlan } from "./common";
+/**
+ * Mutually exclusive ways to steer repay sizing. Omit to use default obligation-relative
+ * sizing (`LycLendingPositionManager.calcDebtChangeAmount` with no utilization target).
+ *
+ * `DecreaseCarryPositionPlan.targetUtilizationRateBps` is set when the on-chain instruction
+ * must validate post-repay utilization against an explicit bps value (manager signer):
+ * - `explicitTargetUtilization` — caller supplies bps for both sizing and the instruction.
+ * - `collateralWithdrawal` with `allowBelowTargetOnChain` — sizing uses
+ *   `calcPreWithdrawalTargetUtilizationRateBps`; set the flag when this DCP must pass derived
+ *   utilization bps on-chain because post-repay utilization will sit **below** the position's
+ *   configured `targetUtilizationRateBps` (e.g. pre-rebalance unwind).
+ */
+export type DecreaseCarryRepaySteering = {
+    mode: "collateralWithdrawal";
+    /** Collateral (UI units) removed after this repay. */
+    collateralWithdrawalUiAmount: number;
+    /**
+     * Desired utilization after the later collateral withdrawal. Defaults to the
+     * position's configured target.
+     */
+    postWithdrawalTargetUtilizationRateBps?: number;
+    /**
+     * When true, allow passing derived utilization bps on-chain (same bps as sizing) so a
+     * manager `decrease_carry_position` can validate when post-repay utilization sits **below**
+     * the position's configured `targetUtilizationRateBps` (e.g. pre-rebalance unwind).
+     */
+    allowBelowTargetOnChain?: boolean;
+} | {
+    mode: "explicitTargetUtilization";
+    /**
+     * Caller supplies utilization (bps) for repay sizing and on-chain post-repay check (manager signer).
+     * Often equals or is derived from the position's configured target; this mode passes bps through
+     * explicitly, unlike `collateralWithdrawal`, which derives a target from UI collateral out.
+     */
+    targetUtilizationRateBps: number;
+};
+/**
+ * Deterministic inputs for deriving a `decrease_carry_position` plan.
+ *
+ * Pass this to `client.planner.buildDecreaseCarryPositionPlan()` when you want
+ * the SDK to compute repay math, swap requirements, and grouped CPI inputs.
+ */
+export interface DecreaseCarryPositionBuilderParams {
+    /** Index into the token's `lendingPositions` array for the position to repay. */
+    lendingPositionIndex: number;
+    /** Yielding bank PDA holding the funds that will be redeemed or swapped for repayment. */
+    yieldingBank: Address;
+    /** Lending-platform instruction client used to build the repay CPI sequence. */
+    lendingIx: LpInstructionsBase<LendingPlatformData>;
+    /** Deployment environment used for off-chain price fetches during repay sizing. */
+    environment?: Environment;
+    /** Slippage tolerance for any required DCP swap, in basis points. Defaults to `40`. */
+    swapSlippageBps?: number;
+    /** DEX labels to exclude from any required DCP swap (e.g. venues that failed a prior attempt). */
+    swapExcludeDexes?: string[];
+    /**
+     * Optional override for the asset redeemed from the yielding bank.
+     *
+     * Defaults to the bank's `defaultRedemptionMint`. On-chain permission checks
+     * may reject non-manager callers that override this away from the configured
+     * default redemption mint.
+     */
+    sourceMint?: Address;
+    /**
+     * Optional transaction identifier shared with the lending client.
+     *
+     * Reuse a parent transaction ID when composing this flow into a larger
+     * transaction so lending pre-instructions are not duplicated.
+     */
+    txId?: string;
+    /**
+     * Steers how the planner picks the obligation / repay size. At most one variant;
+     * omit for default sizing.
+     */
+    repaySteering?: DecreaseCarryRepaySteering;
+    /**
+     * When true (e.g. burn-token liquidity management), non-manager callers may execute
+     * the resulting plan subject to the instruction's post-repay validation.
+     */
+    permissionlessOperation?: boolean;
+}
+/**
+ * Precomputed plan wrapper accepted by `client.tx.decreaseCarryPosition.getTx({...})`.
+ */
+export interface DecreaseCarryPositionTxPlanParams {
+    /** Planner result previously returned by `client.planner.buildDecreaseCarryPositionPlan()`. */
+    plan: DecreaseCarryPositionPlan;
+}
+/**
+ * Deterministic execution plan for `decrease_carry_position`.
+ *
+ * Produced by `client.planner.buildDecreaseCarryPositionPlan()` and later
+ * consumed by `client.tx.decreaseCarryPosition.getTx({...})`. This keeps repay math,
+ * swap decisions, and grouped CPI assembly out of the transaction composer.
+ */
+export interface DecreaseCarryPositionPlan extends GroupedCpiExecutionPlan {
+    /** Optional prerequisite CPIs executed before any lending-position refresh. */
+    tokenPrerequisiteCpis?: CpiData[];
+    /**
+     * When set, passed through to `decrease_carry_position` for manager-only
+     * post-repay validation. Populated from explicit steering or from
+     * `collateralWithdrawal` + `allowBelowTargetOnChain` (derived bps = sizing target).
+     */
+    targetUtilizationRateBps?: number;
+    /** Index into the token account's `lendingPositions` array. */
+    lendingPositionIndex: number;
+    /** Raw debt repayment amount in base units. */
+    repayAmount: BN;
+    /**
+     * Yielding-bank holding index redeemed as the swap source.
+     *
+     * Omitted when no preliminary swap is needed because the debt asset is
+     * already held directly by the yielding bank.
+     */
+    sourceAssetHoldingIndex?: number;
+    /** Yielding bank refreshed immediately before the instruction executes. */
+    yieldingBank: Address;
+    /**
+     * When set, `decrease_carry_position` / burn unwind must encode `repay_amount` as null.
+     * This is only needed for flows where the exact repay amount must be derived on-chain.
+     */
+    omitOnChainRepayAmount?: boolean;
+}

package/dist/sdks/long-yield-carry/src/client/types/planTypes/decreaseCarryPosition.js

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

package/dist/sdks/long-yield-carry/src/client/types/planTypes/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./collectInterest";
+export * from "./common";
+export * from "./decreaseCarryPosition";

package/dist/sdks/long-yield-carry/src/client/types/planTypes/index.js

@@ -0,0 +1,19 @@
+"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("./collectInterest"), exports);
+__exportStar(require("./common"), exports);
+__exportStar(require("./decreaseCarryPosition"), exports);