@kestrelfi/lyc-sdk 1.0.1

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

@@ -0,0 +1,339 @@
+import type { BN } from "@anchor-lang/core";
+import type { Address } from "@solana/kit";
+import type { AnchorOracleType, CpiData, SwapClient, TransactionCacheInvalidation, TransactionPlan as BaseTransactionPlan } from "common";
+import { YieldingBankAllocationConfig } from "./ix";
+import type { DecreaseCarryPositionTxPlanParams, DecreaseCarryRepaySteering } from "./planTypes/decreaseCarryPosition";
+import type { TokenLpPositionAccountOverrides } from "./ix";
+/**
+ * Fully composed transaction output ready to pass to `sendTransaction`.
+ */
+export interface LongYieldCarryTransactionPlan extends BaseTransactionPlan {
+    /**
+     * Cache entries that should be cleared only after the transaction confirms.
+     *
+     * This keeps transaction builders pure while still letting callers invalidate
+     * stale off-chain snapshots when a successful on-chain write changes account
+     * topology (for example first-time lending account setup).
+     */
+    postSuccessCacheInvalidations?: TransactionCacheInvalidation[];
+    /** Optional lending-client transaction id reused across composed plans. */
+    txId?: string;
+    /** Optional diagnostics for operator-facing scripts and services. */
+    debug?: LongYieldCarryTransactionPlanDebug;
+}
+export interface LongYieldCarryTransactionPlanDebug {
+    processAsyncBurn?: {
+        epochId: bigint;
+        sequence: bigint;
+        request: Address;
+        user: Address;
+        /** How collateral is delivered when the request is processed. */
+        collateralDelivery: "nativeSol" | "tokenAta";
+        /** Populated for non-native collateral mints. */
+        userCollateralAccount?: Address;
+        /** Populated for wrapped SOL collateral (request-scoped WSOL escrow). */
+        requestCollateralAccount?: Address;
+    };
+}
+export interface MintTokenTxParams {
+    /**
+     * Collateral amount to deposit in base units (e.g. lamports).
+     *
+     * Pass `"all"` to deposit the entire collateral ATA balance. The on-chain
+     * instruction resolves `u64::MAX` to the ATA's live balance at execution time.
+     */
+    depositAmount: BN | "all";
+}
+export interface BurnTokenTxParams {
+    /**
+     * yToken amount to burn in base units (e.g. lamports for a 9-decimal token).
+     *
+     * Pass `"all"` to burn every yToken in the user's ATA. The on-chain
+     * instruction resolves `u64::MAX` to the ATA's live balance at execution time.
+     */
+    burnAmount: BN | number | "all";
+    /**
+     * Override the auto-derived redemption epoch ID. Defaults to
+     * {@link currentEpochId} (floored to the nearest minute).
+     */
+    epochId?: BN | number;
+    /**
+     * Override the auto-derived request sequence within the epoch. Defaults to
+     * the next available sequence read from on-chain epoch state (or 0 for a
+     * fresh epoch).
+     */
+    requestSequence?: BN | number;
+}
+export interface RebalanceSwapSpec {
+    /**
+     * Swap client used to quote and build CPI data for this rebalance leg.
+     * When omitted, `getRebalanceYieldingBankTx` uses the transaction client's
+     * default aggregate swap client (Perena for USD* ↔ supported stables, Jupiter otherwise).
+     */
+    swapClient?: SwapClient;
+    /** Mint being sold. */
+    inputMint: Address;
+    /** Mint being bought. */
+    outputMint: Address;
+    /** Exact input or requested quote amount, depending on the swap client. */
+    amount: number;
+    /** Slippage tolerance in basis points. Defaults to the caller's chosen swap behavior. */
+    slippageBps?: number;
+}
+/**
+ * Extra account that backs an asset holding's off-ATA liquidity during refresh.
+ *
+ * Example: a Perena withdrawal queue that temporarily escrows USD*-J shares after
+ * `request_unstake_junior`, while the YieldingBank still economically owns them.
+ */
+export interface YieldingBankExternalLiquiditySource {
+    /** Asset mint whose refresh should include this external source. */
+    mint: Address;
+    /** Account holding the pending balance for that mint. */
+    account: Address;
+}
+/**
+ * Inputs for `client.tx.rebalanceYieldingBank.getTx({...})`.
+ *
+ * The transaction must be signed by the program's manager; ATA setup in the plan uses the
+ * client's environment manager address.
+ */
+export interface RebalanceYieldingBankTxParams {
+    /** Pre-built CPI descriptors (one per swap / deposit step). */
+    cpiData?: CpiData[];
+    /**
+     * High-level swap specifications. Each is resolved into CPI data by calling
+     * `getQuote` + `getSwapCpiData` on the leg's `swapClient`, or the SDK aggregate
+     * swap client when `swapClient` is omitted. Resolved CPI data is appended after
+     * any explicit `cpiData` entries.
+     */
+    swaps?: RebalanceSwapSpec[];
+    /**
+     * Optional new holding or external position to register before the
+     * rebalance executes.
+     */
+    newAllocation?: {
+        config: YieldingBankAllocationConfig;
+    };
+}
+export interface RefreshTokensTxParams {
+    /** Token PDA addresses to refresh. */
+    tokens: Address[];
+    /**
+     * When true, always prepend `refresh_yielding_bank` for each bank referenced
+     * by the token's active carry positions, even if the bank appears fresh
+     * client-side.
+     *
+     * When false (default), the builder skips yielding-bank refreshes whose
+     * cached `lastRefreshedTs` is still inside the normal freshness window.
+     */
+    alwaysRefreshYieldingBanks?: boolean;
+}
+export interface TopUpUnlentReservesTxParams {
+    /** Index into the token's lending_positions array for the source position. */
+    lendingPositionIndex: number;
+    /**
+     * Withdrawal amount in UI units (e.g. 1.5 for 1.5 SOL).
+     * Pass `"all"` to withdraw the entire lending position's collateral.
+     */
+    uiAmount: number | "all";
+    /** Optional redemption epoch PDA to credit with the withdrawn amount. */
+    redemptionEpoch?: Address;
+    /** Optional txId reused across composed plans in the same transaction. */
+    txId?: string;
+}
+export interface ProcessAsyncBurnTxParams {
+    /** Epoch ID (the minute-bucketed timestamp used when the epoch was created). */
+    epochId: bigint | number;
+    /** FIFO sequence number of the request to process within the epoch. */
+    sequence: bigint | number;
+}
+export interface DepositUnlentCollateralTxParams {
+    /** Index into the token's lending_positions array for the target position. */
+    lendingPositionIndex: number;
+    /**
+     * Deposit amount in UI units (e.g. 1.5 for 1.5 SOL).
+     * Required unless `depositAll` is true.
+     */
+    uiAmount?: number;
+    /**
+     * When true, deposits all remaining unlent collateral. The token account
+     * is fetched to determine the exact amount, so `uiAmount` can be omitted.
+     */
+    depositAll?: boolean;
+    /** Optional txId reused across composed plans in the same transaction. */
+    txId?: string;
+}
+export interface IncreaseCarryPositionTxParams {
+    /** Index into the token's lending_positions array for the position to borrow against. */
+    lendingPositionIndex: number;
+    /** The YieldingBank PDA receiving the borrow proceeds. */
+    yieldingBank: Address;
+    /** Borrow amount in UI units (e.g. 100 for 100 USDC). */
+    uiAmount: number;
+    /** Optional txId reused across composed plans in the same transaction. */
+    txId?: string;
+}
+/**
+ * Inputs for `client.tx.rebalanceToken.getTx({...})`.
+ *
+ * When the source lending position would exceed target utilization after the
+ * collateral withdrawal, the builder automatically constructs the flash-loan-
+ * wrapped variant: flash-borrow source debt mint → repay source → withdraw
+ * collateral → deposit to destination → borrow destination debt mint →
+ * exact-out swap back to source debt mint → flash-repay.
+ */
+export interface RebalanceTokenTxParams {
+    /** Index into the token's lending_positions array for the position to rebalance in-place. */
+    lpIndex: number;
+    /**
+     * Target debt mint. The position's current debt is fully repaid via flash loan and this mint
+     * is borrowed instead on the same lending position. The builder resolves the corresponding
+     * reserve via `fetchReserveByMint` and the oracle via the oracle registry.
+     */
+    destinationDebtMint: Address;
+    /**
+     * Collateral amount used for destination borrow capacity sizing, in UI units. Pass `"all"` to
+     * size based on the full current source debt (uses the platform's repay-all sentinel so
+     * on-chain interest accrual between snapshot and landing cannot leave dust).
+     */
+    uiAmount: number | "all";
+    /** Slippage tolerance for the exact-out flash swap, in basis points. Defaults to 100. */
+    swapSlippageBps?: number;
+    /**
+     * Maximum acceptable execution cost (route fees + price impact) of the
+     * rebalance swap quote vs the oracle-fair cross rate, in bps (see
+     * `FlashRebalanceParams.maxSwapCostBps`). When breached, `getTx` throws
+     * `FlashRebalanceSwapCostExceededError` instead of returning a plan.
+     * Unset = no limit.
+     */
+    maxSwapCostBps?: number;
+    /**
+     * Maximum acceptable market basis between the two debt stables (oracle-fair
+     * cross rate vs 1:1), in bps, either direction (see
+     * `FlashRebalanceParams.maxMarketBasisBps`). Unset = no limit.
+     */
+    maxMarketBasisBps?: number;
+    /** Optional explicit overrides for the LP refresh accounts (user account, collateral reserve, debt oracle). */
+    lpPosition?: TokenLpPositionAccountOverrides;
+    /**
+     * Optional transaction identifier shared with lending clients so composed
+     * flows can hoist top-level pre-instructions.
+     */
+    txId?: string;
+    /**
+     * Yielding bank that absorbs the destination-debt slippage dust after the
+     * exact-out swap. Defaults to the first active yielding bank recorded in the
+     * token's `debtCarry` entries.
+     */
+    yieldingBank?: Address;
+}
+export interface DecreaseCarryPositionTxBuilderParams {
+    /** 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;
+    /** 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;
+    /** See {@link DecreaseCarryRepaySteering}. */
+    repaySteering?: DecreaseCarryRepaySteering;
+    /**
+     * Same as {@link DecreaseCarryPositionBuilderParams.permissionlessOperation}: when true,
+     * non-manager callers may execute the resulting plan subject to post-repay validation.
+     */
+    permissionlessOperation?: boolean;
+}
+/**
+ * Inputs accepted by `client.tx.decreaseCarryPosition.getTx({...})`.
+ *
+ * Pass raw builder params to have the SDK plan the instruction for you, or
+ * pass `{ plan }` when you have pre-built a plan via `buildDecreaseCarryPositionPlan`.
+ */
+export type DecreaseCarryPositionTxParams = DecreaseCarryPositionTxBuilderParams | DecreaseCarryPositionTxPlanParams;
+/**
+ * Inputs for `client.tx.recollateralizeLoss.getTx({...})`.
+ *
+ * The transaction builder internally:
+ *  1. Computes the debt excess (total_debt − total_carry) from on-chain state.
+ *  2. Quotes a collateral → debt swap to cover that excess.
+ *  3. Checks whether withdrawing the required collateral would push the LP
+ *     above its target utilization rate. If so, prepends a
+ *     `decrease_carry_position` sized to free the needed headroom.
+ *  4. Builds the Withdraw → Swap → Repay CPI sequence for the main instruction.
+ */
+export interface RecollateralizeLossTxParams {
+    /** Slippage tolerance for swaps (collateral → debt), in basis points. Defaults to 150. */
+    swapSlippageBps?: number;
+    /**
+     * Optional override for the asset redeemed from the yielding bank during DCP.
+     * Defaults to the bank's `defaultRedemptionMint`. Only used when a
+     * `decrease_carry_position` is needed to free collateral for the withdrawal.
+     */
+    sourceMint?: Address;
+    /** Optional txId shared with lending clients for pre-instruction deduplication. */
+    txId?: string;
+    /** Optional explicit overrides for LP refresh accounts. */
+    lpPosition?: TokenLpPositionAccountOverrides;
+}
+/**
+ * Inputs accepted by `client.tx.collectInterest.getTx({...})`.
+ */
+export interface CollectInterestTxParams {
+    /** Yielding bank whose carry position should collect accrued interest. */
+    yieldingBank: Address;
+    /** Slippage tolerance applied to all swaps. Defaults to 100 bps. */
+    slippageBps?: number;
+    /** Final output mint. Defaults to the token's collateral mint. */
+    outputMint?: 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;
+}
+export interface ClaimIncentivesTxParams {
+    /** Index into the token's lending_positions array. */
+    lendingPositionIndex: number;
+    /** Incentive reward mint to harvest. */
+    incentiveMint: Address;
+    /**
+     * Pre-resolved farm and user-farm addresses for the claim CPI. When provided
+     * the builder skips the on-chain incentive lookup — required when the same
+     * incentive mint appears from multiple farms (obligation vs. direct).
+     */
+    claimAccounts?: {
+        farm: Address;
+        userFarm: Address;
+    };
+    /**
+     * Yielding bank that receives the claimed rewards. Defaults to the first
+     * active yielding bank recorded in the token's `debtCarry` entries.
+     */
+    yieldingBank?: Address;
+    /**
+     * Oracle pricing `incentiveMint`. Auto-resolved when the mint matches the
+     * debt of an active lending position or is in the shared mints registry;
+     * required otherwise.
+     */
+    incentiveOracle?: Address;
+    /** Oracle type for `incentiveOracle`. Auto-resolved when `incentiveOracle` is. */
+    incentiveOracleType?: AnchorOracleType;
+}

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

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

package/dist/sdks/long-yield-carry/src/constants/configs/allocations.d.ts

@@ -0,0 +1,3 @@
+import { YieldingBankAllocationConfig } from "../../client";
+export declare const usdStarAllocationConfig: YieldingBankAllocationConfig;
+export declare const usdStarJuniorAllocationConfig: YieldingBankAllocationConfig;

package/dist/sdks/long-yield-carry/src/constants/configs/allocations.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usdStarJuniorAllocationConfig = exports.usdStarAllocationConfig = void 0;
+const common_1 = require("common");
+const oracle_1 = require("oracle");
+const USD_STAR = common_1.mints.get("USD*");
+const USD_STAR_JUNIOR = common_1.mints.get("USD*-J");
+exports.usdStarAllocationConfig = {
+    assetHolding: {
+        mint: USD_STAR.address,
+        oracle: oracle_1.oracle.getOracleData("USD*").oracle,
+        oracleType: (0, common_1.enumToOracleType)(common_1.OracleType.PerenaBank),
+        externalLiquidityType: (0, common_1.enumToExternalLiquidityType)(common_1.ExternalLiquidityType.None),
+    },
+};
+exports.usdStarJuniorAllocationConfig = {
+    assetHolding: {
+        mint: USD_STAR_JUNIOR.address,
+        oracle: oracle_1.oracle.getOracleData("USD*-J").oracle,
+        oracleType: (0, common_1.enumToOracleType)(common_1.OracleType.PerenaTranche),
+        externalLiquidityType: (0, common_1.enumToExternalLiquidityType)(common_1.ExternalLiquidityType.PerenaWithdrawalQueue),
+    },
+};

package/dist/sdks/long-yield-carry/src/constants/configs/carryTradePresets.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Per-asset carry trade price-band presets, split by volatility regime.
+ *
+ * Each preset defines three drawdown / rally buffers that control how aggressively a
+ * lending position is utilized relative to its liquidation line:
+ *
+ * - `drawdownPctFromTargetToLiq` — collateral drawdown (%) that separates the **target**
+ *    utilization from the liquidation line. Larger = more conservative target.
+ * - `drawdownPctFromUnwindToLiq` — collateral drawdown (%) that separates the **unwind
+ *    trigger** from the liquidation line. Smaller than target (closer to liquidation).
+ * - `maxPriceChangeUpPercent` — max collateral **rally** (%) before the boost trigger fires,
+ *    prompting the position to borrow more and return to target.
+ *
+ * ## Usage
+ *
+ * Select the appropriate asset preset and volatility regime, then pass it to
+ * `LycLendingPositionManager.getLendingAllocationConfigFromPriceBands(preset)`, which combines
+ * the price-band params with pair-specific `maxLtv` and `liquidationThreshold` to produce
+ * a `CarryLendingAllocationConfig` (target utilization + deviation bands in bps). The
+ * resulting config is used to update the on-chain `LendingPositionConfig`, adapting the
+ * position's risk envelope to the current market regime.
+ *
+ * ## Asset tiers (tightest → widest buffers)
+ *
+ * BTC → ETH → SOL → large-cap alts → small-cap alts
+ *
+ * Higher-volatility assets use wider buffers to avoid unnecessary unwinds during normal
+ * price swings, while lower-volatility assets can afford tighter bands for better capital
+ * efficiency.
+ */
+import type { CarryPriceBandPreset } from "../../services/carry/carryAllocationConfig";
+export declare const VOLATILITY_REGIMES: readonly ["lowVol", "highVol"];
+export type VolatilityRegime = (typeof VOLATILITY_REGIMES)[number];
+export declare function isVolatilityRegime(s: string): s is VolatilityRegime;
+export type CarryVolatilityPresets = {
+    lowVol: CarryPriceBandPreset;
+    highVol: CarryPriceBandPreset;
+};
+export interface AssetPresetEntry {
+    presets: CarryVolatilityPresets;
+    defaultRegime: VolatilityRegime;
+}
+export declare const STOCK_INDEX_PRESETS: CarryVolatilityPresets;
+export declare const BTC_CARRY_PRESETS: CarryVolatilityPresets;
+export declare const ETH_CARRY_PRESETS: CarryVolatilityPresets;
+export declare const SOL_CARRY_PRESETS: CarryVolatilityPresets;
+export declare const LST_CARRY_PRESETS: CarryVolatilityPresets;
+export declare const LARGE_CAP_ALT_CARRY_PRESETS: CarryVolatilityPresets;
+export declare const SMALL_CAP_ALT_CARRY_PRESETS: CarryVolatilityPresets;
+/**
+ * Maps collateral symbol (upper-cased) to its carry trade preset tier and
+ * default volatility regime. Used by scripts and backend services to resolve
+ * the correct price-band parameters when creating or reconfiguring lending
+ * positions.
+ */
+export declare const ASSET_PRESETS: Record<string, AssetPresetEntry>;
+/** Looks up the carry preset entry for a collateral symbol (case-insensitive). */
+export declare function resolvePresets(collateralSymbol: string): AssetPresetEntry | undefined;

package/dist/sdks/long-yield-carry/src/constants/configs/carryTradePresets.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ASSET_PRESETS = exports.SMALL_CAP_ALT_CARRY_PRESETS = exports.LARGE_CAP_ALT_CARRY_PRESETS = exports.LST_CARRY_PRESETS = exports.SOL_CARRY_PRESETS = exports.ETH_CARRY_PRESETS = exports.BTC_CARRY_PRESETS = exports.STOCK_INDEX_PRESETS = exports.VOLATILITY_REGIMES = void 0;
+exports.isVolatilityRegime = isVolatilityRegime;
+exports.resolvePresets = resolvePresets;
+exports.VOLATILITY_REGIMES = ["lowVol", "highVol"];
+function isVolatilityRegime(s) {
+    return exports.VOLATILITY_REGIMES.includes(s);
+}
+exports.STOCK_INDEX_PRESETS = {
+    lowVol: {
+        drawdownPctFromTargetToLiq: 8,
+        drawdownPctFromUnwindToLiq: 5,
+        maxPriceChangeUpPercent: 2,
+    },
+    highVol: {
+        drawdownPctFromTargetToLiq: 11,
+        drawdownPctFromUnwindToLiq: 7,
+        maxPriceChangeUpPercent: 3,
+    },
+};
+exports.BTC_CARRY_PRESETS = {
+    lowVol: {
+        drawdownPctFromTargetToLiq: 12,
+        drawdownPctFromUnwindToLiq: 8,
+        maxPriceChangeUpPercent: 6,
+    },
+    highVol: {
+        drawdownPctFromTargetToLiq: 14,
+        drawdownPctFromUnwindToLiq: 10,
+        maxPriceChangeUpPercent: 8,
+    },
+};
+exports.ETH_CARRY_PRESETS = {
+    lowVol: {
+        drawdownPctFromTargetToLiq: 14,
+        drawdownPctFromUnwindToLiq: 10,
+        maxPriceChangeUpPercent: 7,
+    },
+    highVol: {
+        drawdownPctFromTargetToLiq: 17,
+        drawdownPctFromUnwindToLiq: 12,
+        maxPriceChangeUpPercent: 10,
+    },
+};
+exports.SOL_CARRY_PRESETS = {
+    lowVol: {
+        drawdownPctFromTargetToLiq: 16,
+        drawdownPctFromUnwindToLiq: 12,
+        maxPriceChangeUpPercent: 8,
+    },
+    highVol: {
+        drawdownPctFromTargetToLiq: 19,
+        drawdownPctFromUnwindToLiq: 14,
+        maxPriceChangeUpPercent: 11,
+    },
+};
+exports.LST_CARRY_PRESETS = {
+    lowVol: {
+        drawdownPctFromTargetToLiq: 19,
+        drawdownPctFromUnwindToLiq: 10,
+        maxPriceChangeUpPercent: 8,
+    },
+    highVol: {
+        drawdownPctFromTargetToLiq: 22,
+        drawdownPctFromUnwindToLiq: 12,
+        maxPriceChangeUpPercent: 11,
+    },
+};
+exports.LARGE_CAP_ALT_CARRY_PRESETS = {
+    lowVol: {
+        drawdownPctFromTargetToLiq: 22,
+        drawdownPctFromUnwindToLiq: 16,
+        maxPriceChangeUpPercent: 8,
+    },
+    highVol: {
+        drawdownPctFromTargetToLiq: 25,
+        drawdownPctFromUnwindToLiq: 18,
+        maxPriceChangeUpPercent: 10,
+    },
+};
+exports.SMALL_CAP_ALT_CARRY_PRESETS = {
+    lowVol: {
+        drawdownPctFromTargetToLiq: 26,
+        drawdownPctFromUnwindToLiq: 22,
+        maxPriceChangeUpPercent: 10,
+    },
+    highVol: {
+        drawdownPctFromTargetToLiq: 29,
+        drawdownPctFromUnwindToLiq: 24,
+        maxPriceChangeUpPercent: 12,
+    },
+};
+/**
+ * Maps collateral symbol (upper-cased) to its carry trade preset tier and
+ * default volatility regime. Used by scripts and backend services to resolve
+ * the correct price-band parameters when creating or reconfiguring lending
+ * positions.
+ */
+exports.ASSET_PRESETS = {
+    WBTC: { presets: exports.BTC_CARRY_PRESETS, defaultRegime: "lowVol" },
+    CBBTC: { presets: exports.BTC_CARRY_PRESETS, defaultRegime: "lowVol" },
+    WETH: { presets: exports.ETH_CARRY_PRESETS, defaultRegime: "lowVol" },
+    SOL: { presets: exports.SOL_CARRY_PRESETS, defaultRegime: "lowVol" },
+    JUPSOL: { presets: exports.LST_CARRY_PRESETS, defaultRegime: "lowVol" },
+    JITOSOL: { presets: exports.LST_CARRY_PRESETS, defaultRegime: "lowVol" },
+    DFDVSOL: { presets: exports.LST_CARRY_PRESETS, defaultRegime: "lowVol" },
+    SPYX: { presets: exports.STOCK_INDEX_PRESETS, defaultRegime: "lowVol" },
+    QQQX: { presets: exports.STOCK_INDEX_PRESETS, defaultRegime: "lowVol" },
+    LARGE_CAP: { presets: exports.LARGE_CAP_ALT_CARRY_PRESETS, defaultRegime: "lowVol" },
+    SMALL_CAP: { presets: exports.SMALL_CAP_ALT_CARRY_PRESETS, defaultRegime: "highVol" },
+};
+/** Looks up the carry preset entry for a collateral symbol (case-insensitive). */
+function resolvePresets(collateralSymbol) {
+    return exports.ASSET_PRESETS[collateralSymbol.toUpperCase()];
+}

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

@@ -0,0 +1,2 @@
+export * from "./allocations";
+export * from "./carryTradePresets";

package/dist/sdks/long-yield-carry/src/constants/configs/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("./allocations"), exports);
+__exportStar(require("./carryTradePresets"), exports);

package/dist/sdks/long-yield-carry/src/constants/general.d.ts

@@ -0,0 +1,70 @@
+import { BN } from "@anchor-lang/core";
+import { Address } from "@solana/kit";
+import { PROTOCOL_ADMIN, type DeployedEnv, type Environment } from "common";
+/** Program ID per environment */
+export declare const PROGRAM_ID: Record<Environment, Address>;
+/** Manager authority for manager-gated instruction accounts */
+export declare const MANAGER: Record<Environment, Address>;
+/** Circuit breaker controller for circuit-breaker-gated instruction accounts */
+export declare const CIRCUIT_BREAKER_CONTROLLER: Record<Environment, Address>;
+/** Re-exported from `common` — see {@link PROTOCOL_ADMIN} there. */
+export { PROTOCOL_ADMIN };
+/**
+ * Protocol fee wallet — receives the protocol share of mint/burn + perf fees
+ * and serves as the on-chain fallback for a token's `roles.fees` when unset
+ * (`TokenRoles::curator_fee_wallet()` delegates to `protocol_fee_wallet()`).
+ */
+export declare const PROTOCOL_FEE_WALLET: Record<Environment, Address>;
+/** Redemption epoch status: accepting new async burn requests. */
+export declare const REDEMPTION_EPOCH_STATUS_OPEN = 0;
+/** Redemption epoch status: closed to new requests, collateral being funded. */
+export declare const REDEMPTION_EPOCH_STATUS_FUNDING = 1;
+/** Redemption epoch status: funded, individual burn requests being processed. */
+export declare const REDEMPTION_EPOCH_STATUS_PROCESSING = 2;
+/**
+ * On-chain `TokenAccounting::MAX_FRESHNESS_SECS` = ONE_HOUR (3600s).
+ * We use a 120s buffer so the refresh lands before on-chain staleness kicks in.
+ */
+export declare const TOKEN_STALENESS_THRESHOLD_SECS: number;
+/** Maximum heap-frame size requested by composed multi-CPI transactions. */
+export declare const MAX_HEAP_FRAME_BYTES: number;
+/**
+ * Mirror of the on-chain `REBALANCE_TOKEN_RATE_LIMIT_SECS` (24 hours). The
+ * program rejects a `rebalance_token` on a lending position that was already
+ * rebalanced within this window (`RebalanceRateLimited`); the SDK skips such
+ * candidates client-side so we never build a transaction that would revert.
+ */
+export declare const REBALANCE_TOKEN_RATE_LIMIT_SECS: number;
+/** Default recollateralize-loss swap slippage, capped by the on-chain 150 bps check. */
+export declare const DEFAULT_RECOLLATERALIZE_LOSS_SLIPPAGE_BPS = 150;
+/**
+ * Minimum claimable reward (in the reward token's UI units) for an incentive to
+ * be worth harvesting. Below this, the on-chain `HarvestReward` moves only dust
+ * while still costing a transaction fee, so `getOutstandingIncentives` omits it.
+ */
+export declare const DEFAULT_MIN_INCENTIVE_UI_AMOUNT = 0.01;
+/**
+ * Sentinel value (u64::MAX) that callers can pass as an amount to `mint_token`
+ * or `burn_token` to indicate "use the entire balance".
+ * - mint_token: deposits the full collateral ATA balance.
+ * - burn_token: burns the full yToken ATA balance.
+ */
+export declare const AMOUNT_ALL_SENTINEL: BN;
+/** Re-exported from `common` — see {@link DEPLOYED_ADMIN_KEYPAIR_FP} there. */
+export declare const LYC_ADMIN_KEYPAIR_FP: Record<DeployedEnv, string>;
+/**
+ * Filesystem paths to the manager keypair for future manager CLI scripts,
+ * fixed per deployment tier (no env overrides).
+ */
+export declare const LYC_MANAGER_KEYPAIR_FP: Record<DeployedEnv, string>;
+/**
+ * Filesystem paths to the circuit breaker controller keypair.
+ * Used by emergency scripts (trigger circuit breaker, reset burn rate limit).
+ */
+export declare const LYC_CB_KEYPAIR_FP: Record<DeployedEnv, string>;
+/**
+ * Shared general LUT per remote deployment tier (`test` | `prod`), same split as
+ * {@link LYC_ADMIN_KEYPAIR_FP}. Populate via `pnpm run update-general-lut -- test|prod`.
+ */
+export declare const GENERAL_LOOKUP_TABLES: Record<DeployedEnv, Address>;
+export declare const TOKEN_LOOKUP_TABLES: Record<Address, Address>;