@kestrelfi/lyc-sdk 1.0.1 → 1.0.3

package/dist/{sdks/long-yield-carry/src/idl/long_yield_carry.d.ts → core-DP6wfpME.d.mts}

@@ -1,10 +1,20 @@
+import * as _solana_kit from '@solana/kit';
+import { Address, ProgramDerivedAddressBump, AccountRole, Instruction, Rpc, SolanaRpcApi, TransactionSigner, Signature } from '@solana/kit';
+import * as _anchor_lang_core from '@anchor-lang/core';
+import { IdlAccounts, BN, Program } from '@anchor-lang/core';
+import { AssociatedTokenSeeds } from '@solana-program/token';
+import BN$1 from 'bn.js';
+import { KaminoMarket, KlendPrices, KaminoObligation, KaminoReserve } from '@kamino-finance/klend-sdk';
+import { Farms, FarmState, UserFarm, FarmAndKey } from '@kamino-finance/farms-sdk';
+import { OraclePrices } from '@kamino-finance/scope-sdk/dist/@codegen/scope/accounts';
+
 /**
  * Program IDL in camelCase format in order to be used in JS/TS.
  *
  * Note that this is only a type helper and is not the actual IDL. The original
  * IDL can be found at `target/idl/long_yield_carry.json`.
  */
-export type LongYieldCarry = {
+type LongYieldCarry = {
     "address": "7YPAKESPJ7zJAvBuk45ZVziu6tXGKoNzg3p9YpvrH6pX";
     "metadata": {
         "name": "longYieldCarry";
@@ -1179,9 +1189,7 @@ export type LongYieldCarry = {
                 {
                     "name": "adminRole";
                     "docs": [
-                        "Token admin multisig. Pass `None` to use the feature-gated default —",
-                        "the stored role will be left as `Pubkey::default()` and",
-                        "`TokenRoles::admin()` will return the constant fallback."
+                        "Admin multisig. `None` means \"use the feature-gated default\"."
                     ];
                     "optional": true;
                 },
@@ -1193,7 +1201,7 @@ export type LongYieldCarry = {
                     "optional": true;
                 },
                 {
-                    "name": "feesRole";
+                    "name": "curatorFeeWallet";
                     "docs": [
                         "Curator fee wallet. `None` means \"use default\"."
                     ];
@@ -3201,7 +3209,8 @@ export type LongYieldCarry = {
                 {
                     "name": "admin";
                     "docs": [
-                        "Token admin for full configuration updates, or manager for fee-only updates."
+                        "Token admin for full configuration updates, manager for",
+                        "`fee_drip_max_apy_bps` only, or curator for curator-fee-wallet updates."
                     ];
                     "signer": true;
                 },
@@ -3217,9 +3226,10 @@ export type LongYieldCarry = {
                     "optional": true;
                 },
                 {
-                    "name": "feesRole";
+                    "name": "curatorFeeWallet";
                     "docs": [
-                        "Optional new fee wallet. `None` means \"no change\"."
+                        "Optional new curator fee wallet. `None` means \"no change\".",
+                        "Rotatable by the token admin or the token curator."
                     ];
                     "optional": true;
                 },
@@ -3229,6 +3239,21 @@ export type LongYieldCarry = {
                         "Optional new circuit-breaker activator. `None` means \"no change\"."
                     ];
                     "optional": true;
+                },
+                {
+                    "name": "curatorRole";
+                    "docs": [
+                        "Optional new curator. Must be in `WHITELISTED_CURATORS`.",
+                        "`None` means \"no change\"."
+                    ];
+                    "optional": true;
+                },
+                {
+                    "name": "adminRole";
+                    "docs": [
+                        "Optional new admin. `None` means \"no change\"."
+                    ];
+                    "optional": true;
                 }
             ];
             "args": [
@@ -3323,6 +3348,21 @@ export type LongYieldCarry = {
                         "Optional new circuit-breaker activator. `None` means \"no change\"."
                     ];
                     "optional": true;
+                },
+                {
+                    "name": "curatorRole";
+                    "docs": [
+                        "Optional new curator. Must be in `WHITELISTED_CURATORS`.",
+                        "`None` means \"no change\"."
+                    ];
+                    "optional": true;
+                },
+                {
+                    "name": "adminRole";
+                    "docs": [
+                        "Optional new admin. `None` means \"no change\"."
+                    ];
+                    "optional": true;
                 }
             ];
             "args": [
@@ -3843,7 +3883,7 @@ export type LongYieldCarry = {
         {
             "code": 8087;
             "name": "feeDripConfigRequired";
-            "msg": "A positive fee-drip duration requires a max APY when holder fees can accrue or a buffer exists";
+            "msg": "Reserved fee-drip configuration error";
         },
         {
             "code": 8088;
@@ -5323,18 +5363,10 @@ export type LongYieldCarry = {
                     {
                         "name": "feeDripMaxApyBps";
                         "docs": [
-                            "Cap (bps) on the annualized token-price growth contributed by the fee",
-                            "drip. `0` disables the cap. See `TokenFees::fee_drip_max_apy_bps`."
+                            "Target and hard cap (bps) for annualized token-price growth during fee",
+                            "release. `0` parks absorbed fees."
                         ];
                         "type": "u16";
-                    },
-                    {
-                        "name": "feeDripDurationSecs";
-                        "docs": [
-                            "Duration (seconds) over which absorbed mint/burn fees release into the",
-                            "price. `0` parks fees until `recollateralize_loss` consumes them."
-                        ];
-                        "type": "u64";
                     }
                 ];
             };
@@ -5357,12 +5389,10 @@ export type LongYieldCarry = {
                 "absorbed fee a fixed nominal amount: it does not ride the token's appreciation",
                 "while parked, and ongoing yield flows fully to holders during the drip window.",
                 "",
-                "The release is strictly linear toward `drip_end_ts`: between top-ups the",
-                "buffer drains to zero at `drip_end_ts`. Each top-up blends the deadline",
-                "(amount-weighted) so a steady stream of mints keeps releasing rather than",
-                "perpetually resetting the clock. A configurable APY cap",
-                "(`TokenFees::fee_drip_max_apy_bps`) can throttle the release below the",
-                "linear rate; throttled amounts simply release on later refreshes.",
+                "A configurable APY target and hard cap",
+                "(`TokenFees::fee_drip_max_apy_bps`) releases enough of the buffer on each",
+                "refresh to bring annualized price growth up to the target without exceeding",
+                "it. A zero target parks the buffer.",
                 "`recollateralize_loss` may consume this buffer after exhausting any pending",
                 "unwind residual, before the deficit reaches ordinary collateral backing."
             ];
@@ -5382,20 +5412,13 @@ export type LongYieldCarry = {
                         "type": "u64";
                     },
                     {
-                        "name": "dripEndTs";
-                        "docs": [
-                            "Timestamp at which the current buffer fully vests. The buffer drains",
-                            "linearly toward zero at this instant; re-blended on every top-up."
-                        ];
-                        "type": "u64";
-                    },
-                    {
-                        "name": "lastDripTs";
-                        "docs": [
-                            "Start of the current release interval. Kept separate from the token's",
-                            "refresh timestamp so time spent parked cannot create drip headroom."
-                        ];
-                        "type": "u64";
+                        "name": "padding0";
+                        "type": {
+                            "array": [
+                                "u64",
+                                2
+                            ];
+                        };
                     },
                     {
                         "name": "apyReferencePrice";
@@ -5413,7 +5436,7 @@ export type LongYieldCarry = {
                         "type": "u64";
                     },
                     {
-                        "name": "padding";
+                        "name": "padding1";
                         "type": {
                             "array": [
                                 "u64",
@@ -6350,9 +6373,9 @@ export type LongYieldCarry = {
                     {
                         "name": "feeDrip";
                         "docs": [
-                            "Mint/burn fee-drip buffer and its linear-release schedule. Appended after",
-                            "`roles` (consuming reserved padding) so all preceding field offsets stay",
-                            "stable for already-deployed accounts."
+                            "Mint/burn fee-drip buffer and APY reference. Appended after `roles`",
+                            "(consuming reserved padding) so all preceding field offsets stay stable",
+                            "for already-deployed accounts."
                         ];
                         "type": {
                             "defined": {
@@ -6642,11 +6665,10 @@ export type LongYieldCarry = {
                     {
                         "name": "feeDripMaxApyBps";
                         "docs": [
-                            "Cap (in bps) on the annualized token-price growth contributed by the",
-                            "fee drip. On refresh, the buffer release is throttled so it never lifts",
-                            "the price faster than this APY. This only bounds the drip's contribution",
-                            "— natural yield can push the realized APY higher (it cannot be clawed",
-                            "back). `0` disables the cap (release is limited only by the linear rate)."
+                            "Target and hard cap (in bps) for annualized token-price growth during fee",
+                            "release. Refreshes release enough buffered collateral to approach this",
+                            "target without exceeding it. Natural yield can exceed the target and",
+                            "cannot be clawed back. `0` parks the buffer."
                         ];
                         "type": "u16";
                     },
@@ -6659,21 +6681,12 @@ export type LongYieldCarry = {
                             ];
                         };
                     },
-                    {
-                        "name": "feeDripDurationSecs";
-                        "docs": [
-                            "Duration (seconds) over which an absorbed mint/burn fee releases into the",
-                            "price. `0` parks the buffer indefinitely: refreshes do not release it,",
-                            "but `recollateralize_loss` can consume it to cover a carry deficit."
-                        ];
-                        "type": "u64";
-                    },
                     {
                         "name": "padding2";
                         "type": {
                             "array": [
                                 "u64",
-                                4
+                                5
                             ];
                         };
                     }
@@ -6753,8 +6766,9 @@ export type LongYieldCarry = {
                         "docs": [
                             "The whitelisted curator that created this token. Treated as the \"creator\"",
                             "and used for cross-state curator-match checks (e.g. increase_carry_position",
-                            "requires token.curator == yielding_bank.curator). Set at creation from the",
-                            "signer and never rotated."
+                            "requires token.curator == yielding_bank.curator). Rotatable by the token",
+                            "admin to another `WHITELISTED_CURATORS` entry via",
+                            "`update_token_configuration`."
                         ];
                         "type": "pubkey";
                     },
@@ -6763,7 +6777,7 @@ export type LongYieldCarry = {
                         "docs": [
                             "Authority for token-level config updates, metadata changes, fee edits, and",
                             "circuit-breaker deactivation. Intended to be a multisig in production.",
-                            "Cannot be rotated after creation."
+                            "Rotatable by the current admin via `update_token_configuration`."
                         ];
                         "type": "pubkey";
                     },
@@ -6780,7 +6794,8 @@ export type LongYieldCarry = {
                         "name": "fees";
                         "docs": [
                             "Curator's fee wallet — receives the curator's share of mint/burn fees and",
-                            "performance fees. Rotatable via `update_token_configuration`."
+                            "performance fees. Rotatable by the token admin or the token curator via",
+                            "`update_token_configuration`."
                         ];
                         "type": "pubkey";
                     },
@@ -6865,60 +6880,67 @@ export type LongYieldCarry = {
             "docs": [
                 "Parameters for updating a token's mutable configuration.",
                 "",
-                "Oracle configuration is immutable after creation — use `create_token` to set",
-                "the oracle, and deploy a new token if it needs to change."
+                "Every field is optional: `None` means \"no change\". Oracle configuration is",
+                "immutable after creation — use `create_token` to set the oracle, and deploy a",
+                "new token if it needs to change."
             ];
             "type": {
                 "kind": "struct";
                 "fields": [
                     {
                         "name": "performanceFeeBps";
-                        "type": "u16";
+                        "type": {
+                            "option": "u16";
+                        };
                     },
                     {
                         "name": "mintingFeeBps";
-                        "type": "u16";
+                        "type": {
+                            "option": "u16";
+                        };
                     },
                     {
                         "name": "burningFeeBps";
-                        "type": "u16";
+                        "type": {
+                            "option": "u16";
+                        };
                     },
                     {
                         "name": "protocolMintBurnPctBps";
                         "docs": [
                             "Percentage of mint/burn fees that go to the protocol (in bps)"
                         ];
-                        "type": "u16";
+                        "type": {
+                            "option": "u16";
+                        };
                     },
                     {
                         "name": "curatorMintBurnPctBps";
                         "docs": [
                             "Percentage of mint/burn fees that go to the curator (in bps)"
                         ];
-                        "type": "u16";
+                        "type": {
+                            "option": "u16";
+                        };
                     },
                     {
                         "name": "curatorPerfPctBps";
                         "docs": [
                             "Curator's share of performance fees (in bps); protocol implicitly gets the rest."
                         ];
-                        "type": "u16";
+                        "type": {
+                            "option": "u16";
+                        };
                     },
                     {
                         "name": "feeDripMaxApyBps";
                         "docs": [
-                            "Cap (bps) on the annualized price growth contributed by the fee drip.",
-                            "`0` disables the cap. See `TokenFees::fee_drip_max_apy_bps`."
-                        ];
-                        "type": "u16";
-                    },
-                    {
-                        "name": "feeDripDurationSecs";
-                        "docs": [
-                            "Duration (seconds) over which absorbed mint/burn fees release into the",
-                            "price. `0` parks fees until `recollateralize_loss` consumes them."
+                            "Target and hard cap (bps) for annualized price growth during fee release.",
+                            "`Some(0)` parks absorbed fees."
                         ];
-                        "type": "u64";
+                        "type": {
+                            "option": "u16";
+                        };
                     },
                     {
                         "name": "burnRateLimit";
@@ -7155,7 +7177,8 @@ export type LongYieldCarry = {
                         "docs": [
                             "The whitelisted curator that created this yielding bank. Must match the",
                             "token's curator when attaching a carry position via `increase_carry_position`.",
-                            "Set at creation from the signer and never rotated."
+                            "Rotatable by the bank admin to another `WHITELISTED_CURATORS` entry via",
+                            "`update_yielding_bank_config`."
                         ];
                         "type": "pubkey";
                     },
@@ -7163,7 +7186,8 @@ export type LongYieldCarry = {
                         "name": "admin";
                         "docs": [
                             "Authority for yielding-bank config updates and circuit-breaker deactivation.",
-                            "Intended to be a multisig in production. Cannot be rotated after creation."
+                            "Intended to be a multisig in production. Rotatable by the current admin via",
+                            "`update_yielding_bank_config`."
                         ];
                         "type": "pubkey";
                     },
@@ -7324,4 +7348,3138 @@ export type LongYieldCarry = {
         }
     ];
 };
-export declare const IDL: LongYieldCarry;
+declare const IDL: LongYieldCarry;
+
+/**
+ * PDA derivation for the long_yield_carry program.
+ *
+ * The program ID is injected via constructor — no global state.
+ */
+declare class PdaClient {
+    private readonly programAddress;
+    constructor(programAddress: Address);
+    /**
+     * Derives the Token PDA for a given mint and ID.
+     *
+     * Seeds: ["TOKEN", mint_pubkey, id]
+     *
+     * @param mintAddress - The yToken mint address
+     * @param id - The token ID (u8)
+     * @returns Tuple of [PDA address, bump seed]
+     */
+    deriveTokenPda(mintAddress: Address, id: number): Promise<readonly [Address, ProgramDerivedAddressBump]>;
+    /**
+     * Derives the YieldingBank PDA for a given base mint and yielding ID.
+     *
+     * Seeds: ["YIELDING_BANK", base_mint_pubkey, id_le_bytes]
+     *
+     * @param baseMint - The base mint address
+     * @param yieldingId - The yielding bank ID (u8)
+     * @returns Tuple of [PDA address, bump seed]
+     */
+    deriveYieldingBankPda(baseMint: Address, yieldingId: number): Promise<readonly [Address, ProgramDerivedAddressBump]>;
+    deriveRedemptionEpochPda(token: Address, epochId: bigint | number): Promise<readonly [Address, ProgramDerivedAddressBump]>;
+    deriveAsyncBurnRequestPda(token: Address, epochId: bigint | number, sequence: bigint | number): Promise<readonly [Address, ProgramDerivedAddressBump]>;
+    deriveCpiPlanPda(uniqueId: Address, createdTs: bigint | number): Promise<readonly [Address, ProgramDerivedAddressBump]>;
+}
+
+interface CacheEntry<T> {
+    data: T;
+    timestamp: number;
+}
+interface CacheTtlConfig {
+    defaultTtlMs?: number;
+    categoryTtlMs?: Record<string, number>;
+}
+declare class DataCache {
+    protected cache: Map<string, Map<string, CacheEntry<any>>>;
+    protected ttlConfig: CacheTtlConfig;
+    constructor(ttlConfig?: CacheTtlConfig);
+    getData<T>(fetchFn: () => Promise<T | null>, category: string, id: string, options?: {
+        cacheNull?: boolean;
+    }): Promise<{
+        data: T | null;
+        fromCache: boolean;
+    }>;
+    getDataOrThrow<T>(fetchFn: () => Promise<T | null>, category: string, id: string, options?: {
+        cacheNull?: boolean;
+    }): Promise<{
+        data: T;
+        fromCache: boolean;
+    }>;
+    getDataBatch<T>(fetchFn: () => Promise<(T | null)[]>, category: string, ids: string[]): Promise<{
+        data: T[];
+        fromCache: boolean;
+    }>;
+    private getTtlForCategory;
+    protected isStale(entry: CacheEntry<any>, category: string): boolean;
+    /** Returns null if not found or stale */
+    protected tryFromCache<T>(category: string, id: string): T | null;
+    protected getCacheAge(category: string, id: string): number | null;
+    setCache(category: string, id: string, data: any): void;
+    refreshCategory(category: string): void;
+    clearCacheEntry(category: string, id: string): boolean;
+    clearStaleEntries(category: string): number;
+    clearAllStaleEntries(): number;
+    clearAllCache(): void;
+}
+
+type Environment = "local" | "test" | "prod";
+/**
+ * Remote deployment tiers only (`test` | `prod`). `local` is dev/Surfpool and is excluded from
+ * types that describe on-chain deployed program tiers (e.g. operator keypair paths per cluster).
+ */
+type DeployedEnv = Exclude<Environment, "local">;
+/** A mint address or token symbol (case-insensitive) */
+type MintIdentifier = string | Address;
+/**
+ * Cache entries to clear after a successful transaction.
+ *
+ * Kamino entries target lending SDK caches; `lycToken` / `lycYieldingBank` clear
+ * long-yield-carry program DataCache entries; `splAta` clears the SPL ATA existence
+ * cache for one address (must match `SPL_ATA_CACHE_CATEGORY` in
+ * `services/baseAccountClient.ts`); `perena` clears one entry from a Perena client
+ * DataCache after the transaction confirms.
+ */
+type TransactionCacheInvalidation = {
+    client: "kamino";
+    category: string;
+    id: Address;
+} | {
+    client: "lycToken";
+    tokenPda: Address;
+} | {
+    client: "lycYieldingBank";
+    yieldingBankPda: Address;
+} | {
+    client: "splAta";
+    ata: Address;
+} | {
+    client: "perena";
+    dataCache: DataCache;
+    category: string;
+    id: Address;
+};
+
+type CustomAccountMeta = {
+    address: Address;
+    role: AccountRole;
+    isRequiredAta?: AssociatedTokenSeeds;
+};
+interface CpiData {
+    cpiType: number;
+    programId: Address;
+    accounts: CustomAccountMeta[];
+    /** Instruction data for the given CPI. if not provided, it implies the program should provide it internally. Can pass new UInt8Array() if no data is expected */
+    data?: Uint8Array;
+    lookupTables?: Address[];
+    postSuccessCacheInvalidations?: TransactionCacheInvalidation[];
+    /**
+     * Top-level instructions that must run before the host transaction's CPI
+     * dispatcher (e.g. createATA for intermediate-mint accounts a multi-hop
+     * Jupiter route will write into). The host bundler is responsible for
+     * placing these before the CPI but after lending-platform pre-instructions.
+     */
+    preInstructions?: Instruction[];
+}
+
+/**
+ * CPI account mapping utilities for multi-CPI transactions.
+ */
+
+/**
+ * Mapping for extracting accounts from `remainingAccounts` across multiple CPIs.
+ *
+ * @example
+ * For 2 CPIs where CPI 0 needs 10 accounts and CPI 1 needs 8 accounts:
+ * ```
+ * indices: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 2, 5, 7, 10, 11, 12, 13, 14]
+ * lengths: [10, 8]
+ *
+ * CPI 0 uses indices[0..10]
+ * CPI 1 uses indices[10..18]
+ * ```
+ *
+ * Matches Rust `CpiMapping` struct.
+ */
+interface CpiMapping {
+    /** All indices into the account pool, flattened across all CPIs */
+    indices: Buffer;
+    /** Number of accounts per CPI - used to slice indices */
+    lengths: Buffer;
+}
+
+/**
+ * Generic CPI-related types for instruction building.
+ *
+ * Protocol-specific args types belong in their respective packages
+ * (e.g., perena-helpers, jupiter-helpers).
+ */
+
+/**
+ * References for CPI invocations.
+ *
+ * Matches Rust `CpiRefs` struct in common/src/cpi/refs.rs.
+ */
+interface CpiRefs {
+    /** Account indices per CPI (first account of each CPI = program) */
+    accounts: CpiMapping;
+    /** Index into CPI_REGISTRY for each CPI slot */
+    types: Buffer;
+    /** Packed CPI args buffer built by CpiArgsBuilder */
+    args: Buffer;
+}
+/**
+ * Top-level references for an instruction.
+ *
+ * Matches Rust `InstructionRefs` struct in common/src/accounts/refs.rs.
+ *
+ * @property cpi - CPI refs (accounts, types, args)
+ * @property tracked - Indices of accounts to access directly
+ */
+interface InstructionRefs {
+    /** CPI account mapping, type indices, and packed args */
+    cpi: CpiRefs;
+    /** Indices of accounts to access directly */
+    tracked: Buffer;
+}
+
+type AnchorOracleType = {
+    pyth: {};
+} | {
+    switchboard: {};
+} | {
+    perenaBank: {};
+} | {
+    perenaTranche: {};
+} | {
+    tpConsensusOracle: {};
+} | {
+    pythSplStake: {};
+};
+type AnchorExternalLiquidityType = {
+    none: {};
+} | {
+    perenaWithdrawalQueue: {};
+};
+type AnchorTokenProgram = {
+    spl: {};
+} | {
+    token2022: {};
+};
+type AnchorLendingPlatform = {
+    none: {};
+} | {
+    marginfi: {};
+} | {
+    kamino: {};
+};
+declare enum LendingPlatform$1 {
+    None = 0,
+    Marginfi = 1,
+    Kamino = 2
+}
+
+/**
+ * Program-agnostic account helpers: shared {@link DataCache} wiring and SPL ATA existence
+ * checks for instruction builders (e.g. `getCreateAtaIxIfNeeded`). Extend this in per-program
+ * SDKs for typed account fetchers and domain-specific cache categories.
+ */
+declare class BaseAccountClient {
+    protected readonly rpc: Rpc<SolanaRpcApi>;
+    readonly dataCache: DataCache;
+    protected constructor(rpc: Rpc<SolanaRpcApi>, options?: Pick<CacheTtlConfig, "defaultTtlMs" | "categoryTtlMs">);
+    /**
+     * Whether an SPL token account exists at `ata`. Cached under {@link SPL_ATA_CACHE_CATEGORY};
+     * clear via post-success `splAta` transaction cache invalidations after successful creates.
+     */
+    splAtaExists(ata: Address): Promise<boolean>;
+}
+
+interface CreateAtaIxIfNeededResult {
+    instruction: Instruction | null;
+    postSuccessCacheInvalidations: TransactionCacheInvalidation[];
+}
+
+/** Helius priority levels accepted by `getPriorityFeeEstimate`. */
+declare enum PriorityFeeSetting {
+    Min = "Min",
+    Low = "Low",
+    Medium = "Medium",
+    High = "High",
+    VeryHigh = "VeryHigh"
+}
+
+/**
+ * Options for signSendAndConfirmTransaction.
+ */
+interface SendTransactionOptions {
+    /** Address lookup tables for transaction compression */
+    lookupTables?: Address[];
+    /** Additional signers beyond the fee payer (e.g., mint authority) */
+    additionalSigners?: TransactionSigner[];
+    /** Whether or not to print transaction logs after a simulation or transaction failure */
+    hideFailureInfo?: boolean;
+    /**
+     * Jito tip in lamports for bundle submissions. Default: 10,000.
+     * Set to 0 to disable bundle fallback (throws on oversize instead).
+     */
+    jitoTipLamports?: number;
+    /**
+     * Force the Jito bundle path even when the transaction fits in a single tx.
+     * Useful for smoke-testing bundle submission on mainnet. Requires
+     * `jitoTipLamports` > 0 unless {@link sendOversizedAsSequentialTransactions}
+     * is set.
+     */
+    forceJitoBundle?: boolean;
+    /**
+     * When the oversize path runs, send each split transaction with normal
+     * `sendTransaction` + confirmation instead of a Jito bundle. For Surfpool,
+     * local validators, and other RPCs that do not implement `sendBundle`.
+     *
+     * Not atomic: ledger state may change between sub-transactions. Does not
+     * add a Jito tip (`jitoTipLamports` is ignored). Uses a fresh blockhash per
+     * sub-transaction so earlier confirmations cannot expire the next send.
+     */
+    sendOversizedAsSequentialTransactions?: boolean;
+    /**
+     * Override the estimated compute-unit price (in micro-lamports). When set,
+     * skips priority-fee estimation and uses this value directly.
+     */
+    computeUnitPriceMicroLamports?: number;
+    /**
+     * Helius-compatible priority level requested through the configured RPC.
+     * Explicit `computeUnitPriceMicroLamports` takes precedence. When both
+     * options are omitted, no compute-unit-price instruction is added.
+     */
+    priorityFeeSetting?: PriorityFeeSetting;
+    /**
+     * Multiplier applied to simulated `unitsConsumed` when setting the compute
+     * unit limit. Defaults to {@link DEFAULT_COMPUTE_UNIT_LIMIT_MULTIPLIER}.
+     */
+    computeUnitLimitMultiplier?: number;
+}
+interface TransactionPlan {
+    instructions: Instruction[];
+    lookupTables?: Address[];
+    /**
+     * Partition of `instructions` into indivisible segments when splitting for
+     * wire size (Jito bundle or sequential oversize). Lengths must be positive
+     * and sum to `instructions.length`. Omitted or undefined: each instruction
+     * is its own segment (legacy `Instruction[]` behavior).
+     *
+     * Example: [1, 2, 3] means the first 1 instruction is in the first bin, the
+     * next 2 are in the second bin, and the last 3 are in the third bin.
+     *
+     * Use this to keep an atomic group together — e.g. a Kamino flash
+     * borrow/rebalance/repay triple, where the borrow's `flash_ixs.rs` check
+     * introspects its own tx's instructions sysvar to find the matching repay.
+     */
+    segmentLengths?: number[];
+    /**
+     * Indices into the segments produced by `segmentLengths` that must
+     * always start a fresh bin. The current bin (if any) is flushed before
+     * the segment is appended, regardless of whether it would have fit.
+     *
+     * Use this when a CPI in the segment encodes a position-relative index at
+     * build time (e.g. Kamino's flash-borrow records the position of the
+     * matching repay in its data) — forcing the segment to start a new bin
+     * keeps that index stable across runs.
+     */
+    freshBinSegments?: number[];
+}
+type SendTransactionOptionsWithPostSuccess = SendTransactionOptions & {
+    onSuccess?: () => void;
+};
+/**
+ * Build, sign, send, and confirm a transaction using embedded signers.
+ *
+ * Use this with instructions that have TransactionSigner objects embedded
+ * in their accounts.
+ *
+ * @param rpc - Solana RPC client
+ * @param payer - Fee payer with TransactionSigner
+ * @param instructionsOrPlan - Kit Instructions or a composed transaction plan
+ *                             (with embedded signers)
+ * @param options - Optional configuration
+ * @returns Transaction signature
+ *
+ * @example
+ * ```typescript
+ * const sig = await signSendAndConfirmTransaction(rpc, payer, [
+ *   computeBudgetIx,
+ *   transferIx,
+ * ]);
+ * ```
+ */
+declare function signSendAndConfirmTransaction(rpc: Rpc<SolanaRpcApi>, payer: TransactionSigner, instructionsOrPlan: Instruction[] | TransactionPlan, options?: SendTransactionOptionsWithPostSuccess): Promise<Signature>;
+
+/**
+ * Program-level admin pubkey shared across deployed programs (LYC protocol admin,
+ * consensus oracle admin seed, etc.). Matches Rust `PROTOCOL_ADMIN`.
+ */
+declare const PROTOCOL_ADMIN: Record<Environment, Address>;
+
+/**
+ * Shared base for SDK instruction/transaction builders.
+ *
+ * `getIx(args)` is intentionally explicit: callers must provide the fully
+ * resolved instruction inputs. Higher-level `getTx()` paths should derive those
+ * inputs locally, then call `getIx(args)` without persisting them on the
+ * builder instance.
+ */
+declare abstract class BaseIXBuilderService<TContext, TIxArgs, TTxArgs = TIxArgs, TTxResult = TransactionPlan> {
+    protected readonly context: TContext;
+    constructor(context: TContext);
+    abstract getIx(args: TIxArgs): Promise<Instruction>;
+    abstract getTx(args: TTxArgs): Promise<TTxResult>;
+}
+
+/**
+ * Parameters for requesting a swap quote.
+ */
+interface SwapQuoteParams {
+    /** Input token mint address */
+    inputMint: Address;
+    /** Output token mint address */
+    outputMint: Address;
+    /** Amount to swap in smallest units (e.g., lamports, not SOL) */
+    amount: number;
+    /** Slippage tolerance in basis points (e.g., 500 = 5%) */
+    slippageBps?: number;
+    /**
+     * If true, restrict the quote to direct routes (no intermediate hops).
+     * Useful for CPI flows where intermediate-mint ATAs (e.g. WSOL) wouldn't
+     * exist for a PDA caller. Backends that don't multi-hop ignore this.
+     */
+    onlyDirectRoutes?: boolean;
+    /**
+     * Optional backend-specific route account budget. Jupiter uses this to
+     * decide whether larger multi-hop routes are eligible.
+     */
+    maxAccounts?: number;
+    /**
+     * DEX labels to exclude from routing, merged with any client-level default
+     * exclusions. Backends without venue routing (Perena) ignore this.
+     */
+    excludeDexes?: string[];
+}
+/**
+ * Parameters for sizing a swap so realized output is at least a target, without
+ * exceeding a maximum input spend (base units). Backends may use oracle math
+ * (Perena) or exact-out routing (Jupiter), etc.
+ */
+interface SwapQuoteCoveringMinOutputParams {
+    inputMint: Address;
+    outputMint: Address;
+    /** Minimum output amount required (smallest units of `outputMint`). */
+    minOutputAmount: bigint;
+    /** Maximum input amount allowed (smallest units of `inputMint`). */
+    maxInputAmount: bigint;
+    slippageBps?: number;
+}
+/**
+ * Normalized swap quote returned by any swap client.
+ *
+ * @typeParam TRawQuote - Platform-specific quote type (e.g., Jupiter's QuoteResponse)
+ */
+interface SwapQuote<TRawQuote = unknown> {
+    /** Input token mint address */
+    inputMint: Address;
+    /** Output token mint address */
+    outputMint: Address;
+    /** Input amount in smallest units */
+    inputAmount: bigint;
+    /** Expected output amount in smallest units */
+    outputAmount: bigint;
+    /** Price impact as a percentage (e.g., 0.5 = 0.5%) */
+    priceImpactPct: number;
+    /** Platform-specific quote data (e.g., Jupiter's QuoteResponse) */
+    rawQuote: TRawQuote;
+}
+/**
+ * Options for building a swap instruction.
+ */
+interface SwapInstructionOptions {
+    /** Whether to automatically wrap/unwrap SOL (default: false for CPI) */
+    wrapAndUnwrapSol?: boolean;
+    /**
+     * Real signer that pays for any pre-instructions the swap client needs
+     * (e.g. createATA for intermediate-mint accounts on a multi-hop route).
+     * The swap authority (`userPublicKey`) is typically a PDA and cannot pay.
+     * When omitted, the swap client skips emitting pre-instructions.
+     */
+    payer?: Address;
+}
+
+/**
+ * Base interface for swap clients.
+ *
+ * Implementations of this interface provide a unified API for interacting
+ * with different DEX aggregators (Jupiter, Raydium, etc.) for CPI swaps
+ * in addition to direct integration with other swap-like programs, like USD* mint/burn.
+ *
+ * @typeParam TRawQuote - Platform-specific quote type
+ *
+ * @example
+ * ```typescript
+ * const client: SwapClient = new JupiterSwapClient(rpc);
+ * const quote = await client.getQuote({ inputMint, outputMint, amount });
+ * const { data, accounts, programId } = await client.getSwapCpiData(quote, userPda);
+ * ```
+ */
+interface SwapClient<TRawQuote = unknown> {
+    /**
+     * Get a swap quote for the given parameters.
+     *
+     * @param params - Quote parameters (mints, amount, slippage)
+     * @returns Normalized swap quote with expected output amount
+     */
+    getQuote(params: SwapQuoteParams): Promise<SwapQuote<TRawQuote>>;
+    /**
+     * Size a swap so expected output is at least {@link SwapQuoteCoveringMinOutputParams.minOutputAmount}
+     * while spending no more than {@link SwapQuoteCoveringMinOutputParams.maxInputAmount} input.
+     *
+     * Implementations use backend-specific mechanics (e.g. Perena oracle linearization,
+     * Jupiter `ExactOut` quotes).
+     */
+    getQuoteCoveringMinOutput(params: SwapQuoteCoveringMinOutputParams): Promise<SwapQuote<TRawQuote>>;
+    /**
+     * Build the swap instruction for CPI.
+     *
+     * @param quote - Quote from getQuote()
+     * @param userPublicKey - Address that will execute the swap (can be a PDA)
+     * @param options - Optional settings (e.g., wrapAndUnwrapSol)
+     * @returns Instruction data and accounts for CPI
+     */
+    getSwapCpiData(quote: SwapQuote<TRawQuote>, userPublicKey: Address, options?: SwapInstructionOptions): Promise<CpiData>;
+}
+
+/** Lightweight read-only snapshot of a `RedemptionEpoch` account. */
+interface RedemptionEpochSnapshot {
+    pda: Address;
+    tokenPda: Address;
+    epochId: bigint;
+    /** SOL rent payer recorded when the epoch PDA was first funded (`Pubkey.default` on legacy accounts). */
+    payer: Address;
+    status: number;
+    requestCount: number;
+    processedRequestCount: number;
+    grossCollateralClaim: bigint;
+    realizedUnwindLoss: bigint;
+    fundedCollateral: bigint;
+}
+interface OracleConfigDetails {
+    /** Oracle account address */
+    oracle: Address;
+    /** Oracle type */
+    oracleType: AnchorOracleType;
+    /** Optional secondary oracle account for composite oracle types (e.g. the
+     * SPL stake pool account for `PythSplStake`). Omit for single-account types. */
+    secondaryOracle?: Address;
+}
+/**
+ * Accounts required to reference a priced SPL mint: the mint itself, the
+ * SPL token program that governs it, and the oracle that prices it.
+ */
+interface PricedMint {
+    mint: Address;
+    tokenProgram: Address;
+    oracle: Address;
+}
+interface FeeConfig {
+    /** Management fee in basis points */
+    performanceFeeBps: number;
+    /** Minting fee in basis points */
+    mintingFeeBps: number;
+    /** Burning fee in basis points */
+    burningFeeBps: number;
+    /** Percentage of mint/burn fees that go to the protocol (in bps) */
+    protocolMintBurnPctBps: number;
+    /** Percentage of mint/burn fees that go to the curator (in bps) */
+    curatorMintBurnPctBps: number;
+    /** Curator's share of performance fees (in bps); protocol implicitly gets the rest. */
+    curatorPerfPctBps: number;
+    /**
+     * Target and hard cap (in bps) for annualized token-price growth during fee
+     * release. `0` parks absorbed fees.
+     * Omit to default to 200 bps on test/prod or `0` on local.
+     */
+    feeDripMaxApyBps?: number;
+}
+/** Base-unit breakdown of the accounting effects of a mint. */
+interface MintAmounts {
+    tokensToUser: bigint;
+    protocolFee: bigint;
+    curatorFee: bigint;
+}
+/** Base-unit breakdown of the accounting effects of a burn. */
+interface BurnAmounts {
+    collateralToUser: bigint;
+    protocolFee: bigint;
+    curatorFee: bigint;
+    supplyReduction: bigint;
+}
+/**
+ * A single LYC yToken position held by a wallet.
+ *
+ * Returned by `AccountClient.fetchUserHoldings`. `token` is the full
+ * {@link LYCToken} model so callers can access price, label, decimals, and all
+ * on-chain accounting without a second fetch.
+ */
+interface UserHolding {
+    /** The LYC Token domain object (price, label, decimals, TVL, etc.). */
+    token: LYCToken;
+    /** User's ATA address for this yToken mint. */
+    tokenAccount: Address;
+    /** Raw balance in the yToken's smallest unit. */
+    balance: bigint;
+    /** Decimal-adjusted balance (e.g. `1.5` for 1.5 yTokens). */
+    uiBalance: number;
+    /**
+     * Wallet USD notional when the caller supplies a collateral USD price
+     * (`uiBalance × token.price × priceMap[collateralMint]`). Omitted if no
+     * usable collateral price was available.
+     */
+    valueUsd?: number;
+}
+
+/** Decoded on-chain data for a Token account, derived from the IDL. */
+type TokenAccountData = IdlAccounts<LongYieldCarry>["token"];
+type TokenLendingPositionData = TokenAccountData["lendingPositions"][number];
+type TokenCarryPositionData = TokenAccountData["debtCarry"][number];
+/** A carry position paired with its index in the `debtCarry` array. */
+interface IndexedCarryPosition {
+    index: number;
+    data: TokenCarryPositionData;
+}
+/** A lending position paired with its index in the `lendingPositions` array. */
+interface IndexedLendingPosition {
+    index: number;
+    data: TokenLendingPositionData;
+}
+/**
+ * Wrapper around the raw Token account data from the program.
+ *
+ * Provides typed access to on-chain state and a home for
+ * derived/computed helpers as the SDK grows.
+ */
+declare class LYCToken {
+    /** The Token PDA address this data was fetched from */
+    readonly address: Address;
+    /** Deserialized account data */
+    readonly data: TokenAccountData;
+    constructor(
+    /** The Token PDA address this data was fetched from */
+    address: Address, 
+    /** Deserialized account data */
+    data: TokenAccountData);
+    get circuitBreaker(): number;
+    /** Whether the token is operational (circuit breaker is off). */
+    get isActive(): boolean;
+    /**
+     * Returns carry positions that have a non-default yielding base mint and
+     * positive shares — i.e. positions with actual yield exposure. Includes the
+     * original array index so callers can reference `debtCarry[index]` on-chain.
+     */
+    get activeCarryPositions(): IndexedCarryPosition[];
+    /**
+     * Returns lending positions that have a non-None platform — i.e. positions
+     * with an active lending protocol. Includes the original array index so
+     * callers can reference `lendingPositions[index]` on-chain.
+     */
+    get activeLendingPositions(): IndexedLendingPosition[];
+    /**
+     * Subset of {@link activeLendingPositions} that currently has supplied
+     * collateral on-chain. Filters out slots whose platform is set but whose
+     * collateral has been fully withdrawn — those slots can still report
+     * non-zero protocol-level state via a shared obligation, which makes them
+     * unsafe targets for borrow/withdraw flows.
+     */
+    get usedLendingPositions(): IndexedLendingPosition[];
+    get config(): TokenAccountData["config"];
+    get collateral(): TokenAccountData["collateral"];
+    get fees(): TokenAccountData["fees"];
+    get accounting(): TokenAccountData["accounting"];
+    get id(): number;
+    get mint(): Address;
+    get collateralMint(): Address;
+    get label(): string;
+    get decimals(): number;
+    /**
+     * On-chain token price: **collateral per yToken** in UI units (same decimals as
+     * the yToken), not USD. At genesis this is 1:1 with the collateral asset; it
+     * moves with NAV. For USD notional use `tvlUsd` / `totalSupply`, or
+     * `client.account.fetchUserHoldings` (pro-rata TVL).
+     */
+    get price(): number;
+    get totalSupply(): number;
+    /**
+     * Total protocol TVL in USD (on-chain `accounting.tvlUsd` is 8-decimal
+     * fixed-point USD, $1 = 10^8).
+     */
+    get tvlUsd(): number;
+    get depositLimitUi(): number;
+    /**
+     * Sum of active `debtCarry[*].tvlUsd` (8-decimal normalized USD stored on-chain).
+     * Mirrors the on-chain `Token::total_carry_tvl_usd` helper.
+     */
+    get totalCarryTvlUsd(): bigint;
+    /**
+     * Sum of active `lendingPositions[*].accounting.debt.tvlUsd` (8-decimal normalized USD).
+     * Mirrors the on-chain `Token::total_lp_debt_usd` helper.
+     */
+    get totalLendingDebtTvlUsd(): bigint;
+    /**
+     * Collectable net yield (8-dec USD): any carry surplus above debt. Zero when
+     * carry TVL does not exceed debt TVL.
+     */
+    get collectableNetYieldUsd(): bigint;
+    /**
+     * True when the token is active and carry TVL exceeds debt by at most 1 bp.
+     */
+    hasInterestToCollect(): boolean;
+    /**
+     * Returns every active lending position whose debt mint matches `debtMint`,
+     * in on-chain slot order. A token may hold more than one position on the same
+     * debt mint, so callers should loop over all of them. Empty when none match.
+     */
+    findLendingPositionsByDebtMint(debtMint: Address): IndexedLendingPosition[];
+    /**
+     * Mirror the on-chain `Token::compute_mint_amounts` formula.
+     *
+     * The holder price-fee (the residual after protocol/curator take their split)
+     * is a gift to the pre-mint supply `S`. To stop the minter clawing back their
+     * own gift, all minted tokens are sized at the post-gift price — i.e. scaled by
+     * `S / (S + priceFee)`. The fee is not applied to the price on-chain at mint
+     * time; it is buffered and released gradually by `refreshTokenState`, so this
+     * quote returns the same base-unit amounts the program mints.
+     *
+     * When `totalSupply === 0`, the user is priced at the current price, protocol
+     * and curator receive their configured base shares, and the residual is
+     * buffered without post-gift scaling.
+     */
+    computeMintAmounts(depositAmount: BN | number): MintAmounts;
+    /**
+     * Mirror the on-chain `Token::compute_burn_amounts` formula.
+     *
+     * Returns exact base-unit values for the three accounting effects of a burn:
+     *   - `collateralToUser`: collateral returned to the burner
+     *   - `protocolFee`: yTokens accrued as pending protocol fees
+     *   - `supplyReduction`: net decrease in total supply
+     *
+     * The holder price-fee (residual after protocol/curator take their split) is
+     * not paid out as collateral; on-chain it is buffered and dripped into the
+     * price for the remaining holders. The burner is leaving, so there is no
+     * self-dealing to guard against and no post-gift scaling is applied. The same
+     * configured split applies when all circulating supply is burned; the residual
+     * remains buffered until it can be released gradually.
+     */
+    computeBurnAmounts(burnAmount: BN | number): BurnAmounts;
+    /**
+     * Convenience wrapper around {@link computeBurnAmounts} that returns only
+     * the collateral owed to the user, converted to a UI amount
+     * (divided by 10^collateral.decimals).
+     */
+    computeBurnWithdrawUiAmount(burnAmount: BN | number): number;
+    /**
+     * Derives the YieldingBank PDA for the `debtCarry` entry at `debtCarryIndex`.
+     *
+     * @param debtCarryIndex - Index into `data.debtCarry`
+     * @param pda - Program PDA client (`YIELDING_BANK` seeds match on-chain).
+     */
+    deriveYieldingBankAddressForDebtCarryIndex(debtCarryIndex: number, pda: PdaClient): Promise<Address>;
+    /**
+     * Resolves the YieldingBank PDA for the token's first active `debtCarry`
+     * entry. Used as a default when callers haven't picked a specific bank.
+     */
+    resolveFirstYieldingBankAddress(pda: PdaClient): Promise<Address>;
+}
+
+/** Decoded on-chain data for a YieldingBank account, derived from the IDL. */
+type YieldingBankAccountData = IdlAccounts<LongYieldCarry>["yieldingBank"];
+/**
+ * Wrapper around the raw YieldingBank account data from the program.
+ *
+ * Provides typed access to on-chain state and a home for
+ * derived/computed helpers as the SDK grows.
+ */
+declare class LYCYieldingBank {
+    /** The YieldingBank PDA address this data was fetched from */
+    readonly address: Address;
+    /** Deserialized account data */
+    readonly data: YieldingBankAccountData;
+    constructor(
+    /** The YieldingBank PDA address this data was fetched from */
+    address: Address, 
+    /** Deserialized account data */
+    data: YieldingBankAccountData);
+    get circuitBreaker(): number;
+    get isActive(): boolean;
+    get config(): YieldingBankAccountData["config"];
+    get accounting(): YieldingBankAccountData["accounting"];
+    get baseMint(): Address;
+    get defaultRedemptionMint(): Address;
+    get id(): number;
+    get decimals(): number;
+    get timeCreatedTs(): bigint;
+    get sharePrice(): number;
+    get totalShares(): number;
+    /**
+     * `true` when the bank's cached `lastRefreshedTs` is older than the
+     * client-side staleness threshold and a `refresh_yielding_bank` ix should
+     * be prepended before any handler that calls `verify_price_is_fresh`.
+     */
+    get isStale(): boolean;
+    get baseAsset(): YieldingBankAccountData["baseAsset"];
+    get assets(): YieldingBankAccountData["assets"];
+    get externalYieldingPositions(): YieldingBankAccountData["externalYieldingPositions"];
+    /**
+     * Find the asset holding entry for a given mint across the bank's
+     * base asset and additional assets. Returns null if not held.
+     */
+    findAssetHolding(mint: Address): YieldingBankAccountData["baseAsset"] | null;
+    /**
+     * Returns the flat index for the asset holding matching the given mint
+     * (0 = base_asset, 1–12 = assets[0–11]), or null if not found.
+     */
+    findAssetHoldingIndex(mint: Address): number | null;
+}
+
+interface YieldingBankRefreshExternalLiquidity {
+    externalLiquiditySources: YieldingBankExternalLiquiditySource[];
+    postSuccessCacheInvalidations: TransactionCacheInvalidation[];
+}
+declare class LongYieldCarryExternalLiquidityResolver {
+    private readonly perena;
+    constructor(rpcUrl: string);
+    resolveYieldingBankRefreshExternalLiquidity(accountClient: AccountClient, yieldingBank: Address, cpiData?: readonly CpiData[]): Promise<YieldingBankRefreshExternalLiquidity>;
+}
+
+/** Supported lending platforms */
+declare enum LendingPlatform {
+    Kamino = 0
+}
+interface OutstandingIncentiveClaimAccounts {
+    farm: Address;
+    userFarm: Address;
+}
+/**
+ * Represents a hypothetical change to a user's position.
+ * Used for simulating APY changes before executing transactions.
+ * Values are in UI units (token amounts, not raw).
+ */
+interface PositionBalanceChange {
+    /** Change in collateral amount (positive = deposit, negative = withdraw) */
+    collateralChange?: number;
+    /** Change in debt amount (positive = borrow, negative = repay) */
+    debtChange?: number;
+}
+/** A claimable lending-platform incentive balance for a specific claim path. */
+interface OutstandingIncentive {
+    mint: Address;
+    /** Claimable balance in the reward token's raw base units. */
+    amount: number;
+    /** Decimals of the reward token mint (0 if unknown). */
+    decimals: number;
+    /** Claimable balance in UI units (`amount / 10 ** decimals`). */
+    uiAmount: number;
+    claimAccounts?: OutstandingIncentiveClaimAccounts;
+}
+
+/**
+ * Abstract base class for fetching and caching lending platform data.
+ * Provides a unified interface for accessing markets, reserves, and user positions
+ * across different lending protocols with built-in TTL-based caching.
+ */
+declare abstract class LendingPlatformData {
+    protected rpc: Rpc<SolanaRpcApi>;
+    protected cache: DataCache;
+    poolCatKey: string;
+    reserveCatKey: string;
+    userAccountCatKey: string;
+    constructor(rpcUrl: string, cacheTtlConfig?: CacheTtlConfig, rpcUrls?: string[]);
+    /** Returns the platform identifier for this data provider */
+    abstract platform(): LendingPlatform;
+    /** Loads and caches data for the specified lending pools/markets */
+    abstract load(pools: Address[]): Promise<void>;
+    clearCache(): void;
+    clearCacheEntry(category: string, id: string): void;
+    /** Returns the current slot, cached to reduce RPC calls */
+    getSlot(): Promise<bigint>;
+    /** Fetches a single user position by address if it exists */
+    abstract maybeFetchUserPositionInPool(pool: Address, userPosition: Address): Promise<UserPositionBase | null>;
+    /** Fetches multiple user positions by their addresses */
+    abstract fetchUserPositionsInPool(pool: Address, userPositions: Address[]): Promise<UserPositionBase[]>;
+    /** Fetches all positions owned by a user in a specific pool */
+    abstract fetchAllUserPositionsForUserInPool(pool: Address, user: Address): Promise<UserPositionBase[]>;
+    /** Fetches reserve data by reserve address */
+    abstract fetchReserve(pool: Address, reserve: Address): Promise<ReserveBase | null>;
+    /** Fetches reserve data by the underlying token mint */
+    abstract fetchReserveByMint(pool: Address, mint: Address): Promise<ReserveBase | null>;
+}
+
+/** Cache configuration for Kamino data with optional market-specific TTL */
+interface KaminoCacheConfig extends CacheTtlConfig {
+    marketsTtlMs?: number;
+}
+/**
+ * Data provider for Kamino Lend protocol.
+ * Handles fetching and caching of markets, reserves, obligations, farms, and prices.
+ * Supports both standard reserve farms and "extra" farms (paired collateral/debt incentives).
+ */
+declare class KaminoData extends LendingPlatformData {
+    farms: Farms;
+    private scope;
+    constructor(rpcUrl: string, cacheConfig?: KaminoCacheConfig, rpcUrls?: string[]);
+    platform(): LendingPlatform;
+    /**
+     * Warms the market cache for the requested pools. Single-pool calls reuse the
+     * normal lazy fetch path; multi-pool calls use Kamino's batched loader.
+     */
+    load(pools: Address[]): Promise<void>;
+    /** Fetches a market by address, loading from cache if available */
+    fetchMarket(market: Address): Promise<KaminoMarket>;
+    /** Fetches all oracle prices for assets in the specified market */
+    fetchPrices(pool: Address): Promise<KlendPrices>;
+    /** Fetches an obligation (user position) by address */
+    fetchObligation(market: KaminoMarket, obligation: Address): Promise<KaminoObligation | null>;
+    /** Batch fetches farm states by their addresses */
+    fetchFarms(farms: Address[]): Promise<FarmState[]>;
+    private fetchExtraFarms;
+    /**
+     * Collects all farm incentives for a reserve, including both standard
+     * collateral/debt farms and extra paired farms from Kamino CDN config.
+     */
+    private fetchFarmsForReserve;
+    fetchUserActiveIncentives(user: Address, specificFarm?: Address): Promise<UserFarm[]>;
+    maybeFetchUserPositionInPool(pool: Address, userPosition: Address): Promise<KaminoUserPositionData | null>;
+    fetchUserPositionsInPool(pool: Address, userPositions: Address[]): Promise<KaminoUserPositionData[]>;
+    fetchAllUserPositionsForUserInPool(pool: Address, user: Address): Promise<KaminoUserPositionData[]>;
+    fetchReserve(pool: Address, reserve: Address): Promise<KaminoReserveData>;
+    fetchReserveByMint(pool: Address, mint: Address): Promise<KaminoReserveData>;
+    private mapReserve;
+    /**
+     * Fetches and caches the Scope OraclePrices account for a given price feed.
+     * @returns The deserialized OraclePrices, or null if the account doesn't exist
+     */
+    fetchScopeOraclePrices(priceFeed: Address): Promise<OraclePrices | null>;
+    /**
+     * Resolves and caches the Scope Configuration account address for a given OraclePrices account.
+     * The first call per price feed does a getProgramAccounts lookup; subsequent calls use cache.
+     */
+    fetchScopeConfigAddress(priceFeed: Address): Promise<Address>;
+}
+
+/**
+ * Categorizes when an incentive reward applies:
+ * - LendingOnly: Only for lending
+ * - BorrowingOnly: Only for borroweing
+ * - Pair: Requires both collateral and debt in specific reserves
+ */
+declare enum IncentiveType {
+    LendingOnly = "Lending",
+    BorrowingOnly = "Borrowing",
+    Pair = "Pair"
+}
+interface IncentiveConfig {
+    rewardMint: Address;
+    incentiveType: IncentiveType;
+    /** If set, this incentive only applies when paired with this reserve */
+    requiresPairReserve?: Address;
+}
+/**
+ * Abstract base class for token reward incentives on lending reserves.
+ * Incentives can apply to deposits, borrows, or paired positions.
+ */
+declare abstract class TokenIncentiveBase {
+    address: Address;
+    config: IncentiveConfig;
+    constructor(address: Address, config: IncentiveConfig);
+    /** Returns true if the incentive is currently active and emitting rewards */
+    abstract active(): boolean;
+    /** Returns the current APY from this incentive */
+    abstract apy(): number;
+    /** Simulates the APY after a hypothetical position change after changing total collateral deposits or debt borrows */
+    abstract simulateNewAPY(args: PositionBalanceChange): number;
+}
+
+/** Arguments for constructing a KaminoIncentiveData instance */
+interface KaminoIncentiveDataArgs {
+    data: FarmAndKey;
+    /** Index of the reward within the farm's rewardInfos array */
+    rewardIndex: number;
+    /** If set, this incentive requires a paired position with this reserve */
+    requiresPairReserve?: Address;
+    /** True if this is a debt farm (rewards borrowers), false for collateral farm */
+    isDebtFarm: boolean;
+}
+
+type IncentiveSide = "supply" | "borrow";
+/** Token mint information for a reserve's underlying asset */
+interface ReserveMint {
+    mint: Address;
+    mintDecimals: number;
+    mintTokenProgram: Address;
+    price?: number;
+    emaPrice?: number;
+}
+/** Risk and fee parameters for a reserve */
+interface ReserveConfig {
+    ltvPct: number;
+    liquidationThresholdPct: number;
+    borrowFeePct: number;
+    flashLoanFeePct: number;
+    /** E-mode configurations for enhanced LTV with specific debt reserves */
+    emodes?: EmodeConfig[];
+}
+/** Aggregated metrics for deposit/borrow activity */
+interface ReserveInteractionInfo {
+    /** In UI amounts, e.g. 1.234 */
+    totalAmount: number;
+    /** In UI amounts, e.g. 1.234 */
+    limit: number;
+    apy: number;
+}
+interface ReserveState {
+    utilizationRatePct: number;
+    availableLiquidity: number;
+}
+/** E-mode (efficiency mode) configuration for enhanced collateral ratios */
+interface EmodeConfig {
+    id?: number;
+    debtReserve?: Address;
+    ltvPct: number;
+    liquidationThresholdPct: number;
+}
+/**
+ * Abstract base class representing a lending reserve (asset pool).
+ * Contains normalized data about deposits, borrows, rates, and incentives.
+ */
+declare abstract class ReserveBase {
+    address: Address;
+    mint: ReserveMint;
+    config: ReserveConfig;
+    deposits: ReserveInteractionInfo;
+    borrows: ReserveInteractionInfo;
+    private state;
+    incentives?: TokenIncentiveBase[] | undefined;
+    private createdAt;
+    constructor(address: Address, mint: ReserveMint, config: ReserveConfig, deposits: ReserveInteractionInfo, borrows: ReserveInteractionInfo, state: ReserveState, incentives?: TokenIncentiveBase[] | undefined);
+    private normalizeLtvPct;
+    /** Returns the cached price, or undefined if stale */
+    get mintPrice(): number | undefined;
+    /** Returns the cached EMA price, or undefined if stale/missing */
+    get mintEmaPrice(): number | undefined;
+    /** Returns oracle account addresses used for price feeds */
+    abstract getOracleAccounts(): Record<string, Address | undefined>;
+    /**
+     * Returns the reserve LTV in decimal form, where `0.5 = 50%`.
+     */
+    get ltvPct(): number;
+    /**
+     * Returns e-mode configs with `ltvPct` normalized to decimal form, where
+     * `0.5 = 50%`.
+     */
+    get emodes(): EmodeConfig[] | undefined;
+    utilizationRatePct(): number;
+    /** Returns borrowable liquidity, accounting for both available balance and borrow limits, in UI amount (e.g. 1.234) */
+    liquidityAvailable(): number;
+    /**
+     * Returns the total supply APY including base rate and eligible supply-side
+     * incentives (types `LendingOnly` and `Pair`). Borrow-side incentives are
+     * excluded here — they reward borrowers, not lenders.
+     * @param usingDebtReserve - When specified, includes paired incentives requiring this debt reserve
+     */
+    supplyAPY(usingDebtReserve?: Address): number;
+    /** Simulates supply APY after a position change */
+    abstract simulateNewSupplyAPY(args: PositionBalanceChange, usingDebtReserve?: Address): number;
+    /**
+     * Returns the effective borrow APY (base rate minus eligible borrow-side
+     * incentive rebates, i.e. `BorrowingOnly`). Lender-side incentives are
+     * excluded — they are paid to lenders and do not offset borrower cost.
+     * @param usingSupplyReserve - When specified, includes paired incentives requiring this collateral
+     */
+    borrowAPY(usingSupplyReserve?: Address): number;
+    /** Simulates borrow APY after a position change */
+    abstract simulateNewBorrowAPY(args: PositionBalanceChange, usingSupplyReserve?: Address): number;
+    /** Sums APY from incentives eligible for the given side and paired reserve */
+    protected sumEligibleIncentivesAPY(side: IncentiveSide, usingPairReserve?: Address): number;
+    /** Sums the new simulated APY from incentives eligible for the given side and paired reserve */
+    protected simulateNewEligbleIncentivesAPY(args: PositionBalanceChange, side: IncentiveSide, usingPairReserve?: Address): number;
+    /**
+     * Filters incentives eligible for the given side (supply vs borrow) and
+     * paired reserve.
+     *
+     * Side filter:
+     * - `supply`: `LendingOnly` and `Pair` (collateral-farm incentives,
+     *   optionally gated on a specific debt reserve).
+     * - `borrow`: `BorrowingOnly` (debt-farm incentives, optionally gated on a
+     *   specific collateral reserve via `requiresPairReserve`).
+     *
+     * Pair filter: incentives with `requiresPairReserve` only apply when that
+     * reserve matches the caller's pair.
+     */
+    protected getEligibleIncentives(side: IncentiveSide, usingPairReserve?: Address): TokenIncentiveBase[];
+    canDeposit(amount: number): boolean;
+    abstract canWithdraw(amount: number): boolean;
+    canBorrow(amount: number): boolean;
+}
+
+/** Supported oracle types for Kamino price feeds */
+type OracleType = "pythPrice" | "switchboardPrice" | "switchboardTwap" | "scope";
+type ReserveOracleAccounts = Record<OracleType, Address | undefined>;
+/**
+ * Kamino-specific reserve data implementation.
+ * Wraps KaminoReserve with normalized accessors and oracle account resolution.
+ */
+declare class KaminoReserveData extends ReserveBase {
+    rawData: KaminoReserve;
+    slot: bigint;
+    /**
+     * Creates a KaminoReserveData instance from raw SDK types.
+     * Extracts and normalizes configuration, rates, limits, and incentives.
+     */
+    static loadData(market: KaminoMarket, reserve: KaminoReserve, reserveFarms: KaminoIncentiveDataArgs[], prices: KlendPrices, slot: bigint): KaminoReserveData;
+    /** Checks if TWAP price validation is enabled for this reserve */
+    protected isTwapEnabled(): boolean;
+    /**
+     * Determines if the reserve's on-chain price data is stale and needs refreshing.
+     */
+    requiresRefresh(): boolean;
+    /**
+     * Returns all configured oracle account addresses for this reserve.
+     * Only includes accounts that are actually enabled.
+     */
+    getOracleAccounts(): ReserveOracleAccounts;
+    /**
+     * Simulates the supply APY after a position balance change.
+     * Uses the SDK's calcSimulatedSupplyAPR which accounts for utilization changes.
+     */
+    simulateNewSupplyAPY(args: PositionBalanceChange, usingDebtReserve?: Address): number;
+    /**
+     * Simulates the borrow APY after a position balance change.
+     * Uses the SDK's calcSimulatedBorrowAPR which accounts for utilization changes.
+     */
+    simulateNewBorrowAPY(args: PositionBalanceChange, usingSupplyReserve?: Address): number;
+    canWithdraw(amount: number): boolean;
+    canBorrow(amount: number): boolean;
+    private hasCapacity;
+}
+
+/** Represents a single asset position (deposit or borrow) within an obligation */
+interface PositionInfo {
+    reserve: Address;
+    mint: Address;
+    amount: BN;
+    valueUsd: number;
+}
+/**
+ * Base class representing a user's lending position.
+ * Contains aggregated data about deposits, borrows, and health metrics.
+ */
+declare class UserPositionBase {
+    address: Address;
+    /** Current utilization as a ratio of borrowed value to borrow limit (0-1) */
+    utilizationRate: number;
+    deposits: PositionInfo[];
+    borrows: PositionInfo[];
+    /** Loan-to-value ratio (if applicable based on elevation group) */
+    ltv?: number | undefined;
+    /** Liquidation threshold percentage (if applicable) */
+    liquidationThreshold?: number | undefined;
+    /**
+     * Obligation-level max borrow capacity in USD (`borrowedUsd / utilizationRate`).
+     * Each platform loader must set this from that protocol's position health model.
+     */
+    borrowLimitUsd?: number | undefined;
+    constructor(address: Address, 
+    /** Current utilization as a ratio of borrowed value to borrow limit (0-1) */
+    utilizationRate: number, deposits: PositionInfo[], borrows: PositionInfo[], 
+    /** Loan-to-value ratio (if applicable based on elevation group) */
+    ltv?: number | undefined, 
+    /** Liquidation threshold percentage (if applicable) */
+    liquidationThreshold?: number | undefined, 
+    /**
+     * Obligation-level max borrow capacity in USD (`borrowedUsd / utilizationRate`).
+     * Each platform loader must set this from that protocol's position health model.
+     */
+    borrowLimitUsd?: number | undefined);
+    /** Aggregate borrowed USD for headroom; prefers per-borrow breakdown when present. */
+    private userPositionBorrowedValueUsd;
+    /**
+     * 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: number, debtDecimals: number): number | undefined;
+}
+
+/**
+ * Kamino-specific user position data.
+ * Extracts deposit/borrow positions and health metrics from a KaminoObligation.
+ */
+declare class KaminoUserPositionData extends UserPositionBase {
+    rawData: KaminoObligation;
+    /** Creates a KaminoUserPositionData from a raw KaminoObligation */
+    static loadData(obligation: KaminoObligation): KaminoUserPositionData;
+    /**
+     * Determines if the obligation needs a refresh_obligation instruction.
+     */
+    requiresRefresh(): boolean;
+}
+
+declare abstract class LpAccountsBase<T extends LendingPlatformData> {
+    data: T;
+    constructor(data: T);
+    abstract getUserAccountAddress(pool: Address, user: Address, id: number): Promise<Address>;
+}
+
+declare class KaminoAccounts extends LpAccountsBase<KaminoData> {
+    getUserAccountAddress(pool: Address, user: Address, id: number): Promise<Address>;
+    getUserMetadataAddress(user: Address): Promise<Address<string>>;
+    /**
+     * Gets the obligation farm accounts for a reserve.
+     */
+    getFarmAccounts(pool: Address, reserve: Address, obligation: Address, farmMode: "collateral" | "debt"): Promise<{
+        userFarm: CustomAccountMeta;
+        farm: CustomAccountMeta;
+    }>;
+    /**
+     * Returns the obligationFarmUserState PDA addresses for all active farms
+     * (collateral and debt) on a reserve. The farm addresses themselves live on
+     * the Kamino LUTs; only the user-specific state needs the per-token LUT.
+     */
+    getUserFarmAddresses(pool: Address, reserve: Address, obligation: Address): Promise<Address[]>;
+    /**
+     * Get all relevant account metas needed for interacting with the Kamino lending market.
+     */
+    reserveInteractionDetails(user: Address, pool: Address, reserve: Address, obligation?: Address, amount?: number, baseUnitAmountOverride?: BN): Promise<{
+        baseUnitAmount: BN | undefined;
+        signer: CustomAccountMeta;
+        obligation: CustomAccountMeta | undefined;
+        reserve: CustomAccountMeta;
+        reserveFeeVault: CustomAccountMeta;
+        reserveLiquidityMint: CustomAccountMeta;
+        reserveLiquiditySupply: CustomAccountMeta;
+        reserveCollateralMint: CustomAccountMeta;
+        reserveCollateralSupply: CustomAccountMeta;
+        lendingMarket: CustomAccountMeta;
+        lendingMarketAuthority: CustomAccountMeta;
+        userLiquidityTa: CustomAccountMeta;
+        userCollateralTa: CustomAccountMeta;
+        liquidityMintTokenProgram: CustomAccountMeta;
+        collateralMintTokenProgram: CustomAccountMeta;
+        farmsProgram: CustomAccountMeta;
+    }>;
+}
+
+interface RefreshPrerequisiteTarget {
+    pool: Address;
+    userAccount: Address;
+    collateralReserves: Address[];
+    debtReserves: Address[];
+}
+
+/** Parameters for deposit, withdraw, and borrow operations */
+interface LendingOperationParams {
+    user: Address;
+    payer: Address;
+    pool: Address;
+    reserve: Address;
+    userAccount: Address;
+    /**
+     * UI-unit amount, or `"all"` (withdraw-only) to encode the platform's
+     * "withdraw all" sentinel (Kamino: `u64::MAX` collateral amount) so the
+     * obligation's deposit is fully drained on-chain — no dust left behind
+     * from off-chain cToken/liquidity rate drift.
+     *
+     * If neither this nor {@link baseUnitAmount} is provided, the amount is
+     * implied to be derived in the program.
+     */
+    uiAmount?: number | "all";
+    /**
+     * Exact liquidity base units for the operation (e.g. lamports for SOL). Prefer over
+     * {@link uiAmount} when float round-trips would undershoot on-chain requirements.
+     * Pass `"all"` (withdraw-only) for the same sentinel semantics as {@link uiAmount}.
+     */
+    baseUnitAmount?: BN | "all";
+    txId: string;
+}
+/** Parameters for repay operations, with option for full repayment */
+interface RepayOperationParams extends LendingOperationParams {
+    /** Repay amount in UI units. The withdraw-only `"all"` sentinel is not valid here. */
+    uiAmount?: number;
+    /** Exact repay amount in liquidity base units. */
+    baseUnitAmount?: BN;
+    /** When true, repays the entire debt balance regardless of `amount` */
+    full?: boolean;
+}
+/** CPI data split into instruction-level prerequisite CPIs and main operation CPIs. */
+interface SplitLpOperationCpiData {
+    prerequisiteCpis: CpiData[];
+    cpis: CpiData[];
+    allCpis: CpiData[];
+}
+/** Split CPI data plus flattened post-success cache invalidations from all nested CPIs. */
+interface LendingOperationCpiBundle extends SplitLpOperationCpiData {
+    postSuccessCacheInvalidations: TransactionCacheInvalidation[];
+}
+/** Whether a reserve is used as collateral or debt for a user account */
+type ReserveRole = "collateral" | "debt";
+/** Tracks a reserve's pool and which user accounts reference it (with roles) */
+interface TxReserveInfo {
+    pool: Address;
+    userAccounts: Map<string, Set<ReserveRole>>;
+}
+/**
+ * Abstract base class for lending platform instruction builders.
+ * Provides a unified interface for building CPI data for different lending protocols.
+ * Each platform implementation provides the account metas needed to construct CPI calls.
+ *
+ * @typeParam T - The platform-specific data class extending LendingPlatformData
+ */
+declare abstract class LpInstructionsBase<T extends LendingPlatformData> {
+    rpc: Rpc<SolanaRpcApi>;
+    rpcUrl: string;
+    data: T;
+    abstract programId: Address;
+    abstract lookupTable: Address;
+    accounts: LpAccountsBase<T>;
+    /** Tracks which reserves (and their pools/roles) are involved in each transaction */
+    protected txReserves: Map<string, Map<string, TxReserveInfo>>;
+    /**
+     * Per-txId per-obligation set of debt reserves that the caller has flagged
+     * as being fully repaid earlier in the same transaction. Subsequent
+     * `RefreshObligation` builds for that obligation must NOT include these
+     * reserves in the borrow accounts list — by execution time the borrow row
+     * has been removed from the obligation, and Kamino's `handler_refresh_obligation`
+     * checks the passed account count against the live obligation state and
+     * fails with `InvalidAccountInput` (klend error 6006) on a mismatch.
+     *
+     * Set via {@link markObligationDebtCleared}, read via {@link getTxObligationClearedDebt}.
+     */
+    protected txClearedDebt: Map<string, Map<string, Set<string>>>;
+    constructor(rpc: Rpc<SolanaRpcApi>, rpcUrl: string, data: T, accounts: LpAccountsBase<T>);
+    emptyAccountMeta(): CustomAccountMeta;
+    clearCacheEntry(category: string, id: string): void;
+    protected getCacheInvalidation(invalidation: {
+        category: string;
+        id: Address;
+    }): TransactionCacheInvalidation;
+    applyPostSuccessCacheInvalidations(invalidations: TransactionCacheInvalidation[]): void;
+    protected getCpiData(cpiType: number, accounts: CustomAccountMeta[], data?: Uint8Array, programId?: Address, postSuccessCacheInvalidations?: TransactionCacheInvalidation[]): CpiData;
+    protected createSplitOperationCpiData(prerequisiteCpis: CpiData[], cpis: CpiData[]): SplitLpOperationCpiData;
+    protected buildLendingOperationCpiBundle(cpiData: SplitLpOperationCpiData): LendingOperationCpiBundle;
+    getInitAndDepositCpiBundle(params: LendingOperationParams, userAccountId: number): Promise<LendingOperationCpiBundle>;
+    getInitBorrowPositionCpiBundle(params: LendingOperationParams, collReserve: Address): Promise<LendingOperationCpiBundle>;
+    getDepositCpiBundle(params: LendingOperationParams): Promise<LendingOperationCpiBundle>;
+    getWithdrawCpiBundle(params: LendingOperationParams): Promise<LendingOperationCpiBundle>;
+    getBorrowCpiBundle(params: LendingOperationParams): Promise<LendingOperationCpiBundle>;
+    getRepayCpiBundle(params: RepayOperationParams): Promise<LendingOperationCpiBundle>;
+    /**
+     * Registers a reserve as being used in a transaction.
+     * When userAccount and role are provided, also tracks the collateral/debt role
+     * for that specific user account.
+     */
+    protected registerTxReserve(txId: string, pool: Address, reserve: Address, userAccount?: Address, role?: ReserveRole): void;
+    /**
+     * Returns the collateral and debt reserves registered in the tx cache
+     * for a specific user account (obligation).
+     */
+    protected getTxUserAccountReserves(txId: string, userAccount: Address): {
+        collateral: Address[];
+        debt: Address[];
+    };
+    /**
+     * Mark that `reserve` will be fully repaid for `userAccount` earlier in the
+     * `txId` flow, so subsequent obligation-refresh builders drop it from the
+     * borrow accounts they emit. Call after building a "repay all" CPI; it has
+     * no effect on the repay itself.
+     */
+    markObligationDebtCleared(txId: string, userAccount: Address, reserve: Address): void;
+    /** Returns the set of debt reserves marked cleared for `(txId, userAccount)`. */
+    protected getTxObligationClearedDebt(txId: string, userAccount: Address): Set<Address>;
+    /**
+     * Clears the transaction cache for a given transaction or all transactions.
+     * Call after finishing building a transaction to free memory.
+     */
+    clearTransactionCache(txId?: string): void;
+    /**
+     * Returns standalone instructions that must be executed at the top level
+     * BEFORE the the main CPIs. Should be called after all CPI methods for this
+     * txId have been invoked.
+     */
+    abstract getPreInstructions(txId: string): Promise<Instruction[]>;
+    /**
+     * Returns prerequisite CPIs needed before reading refreshed account state for
+     * a batch of lending positions outside a normal deposit/withdraw/borrow/repay
+     * flow.
+     */
+    getPrerequisiteCpisForRefresh(_targets: RefreshPrerequisiteTarget[]): Promise<CpiData[]>;
+    /** Returns CPI data for initializing a user's lending account */
+    abstract getInitUserAccountCpiData(pool: Address, user: Address, feePayer: Address, id: number): Promise<SplitLpOperationCpiData>;
+    /**
+     * Returns CPI data for initializing a lending position end-to-end: the user
+     * account itself plus any per-reserve accessory accounts (e.g. Kamino
+     * obligation farm user states for the collateral and debt reserves). Called
+     * at position-creation time so subsequent deposit/borrow flows don't need
+     * to init these inline.
+     *
+     * Default: delegates to {@link getInitUserAccountCpiData}. Platforms with
+     * per-reserve accessory accounts override this to add their inits.
+     */
+    getInitLendingPositionCpiData(params: {
+        pool: Address;
+        user: Address;
+        payer: Address;
+        userAccountId: number;
+        collateralReserve: Address;
+        debtReserve: Address;
+    }): Promise<SplitLpOperationCpiData>;
+    /** Returns CPI data for initializing user account, incentive account (if necessary) and depositing */
+    abstract getInitAndDepositCpiData(params: LendingOperationParams, userAccountId: number): Promise<SplitLpOperationCpiData>;
+    /** Returns CPI data for initializing a new borrow position */
+    abstract getInitBorrowPositionCpiData(params: LendingOperationParams, collReserve: Address): Promise<SplitLpOperationCpiData>;
+    /** Returns deposit CPI data split into optional prerequisite CPIs and main CPIs. */
+    abstract getDepositCpiData(params: LendingOperationParams): Promise<SplitLpOperationCpiData>;
+    /** Returns withdraw CPI data split into optional prerequisite CPIs and main CPIs. */
+    abstract getWithdrawCpiData(params: LendingOperationParams): Promise<SplitLpOperationCpiData>;
+    /** Returns borrow CPI data split into optional prerequisite CPIs and main CPIs. */
+    abstract getBorrowCpiData(params: LendingOperationParams): Promise<SplitLpOperationCpiData>;
+    /** Returns repay CPI data split into optional prerequisite CPIs and main CPIs. */
+    abstract getRepayCpiData(params: RepayOperationParams): Promise<SplitLpOperationCpiData>;
+}
+
+/**
+ * Instruction builder for Kamino Lend protocol.
+ * Provides methods to build CPI account metas for lending operations.
+ */
+declare class KaminoInstructions extends LpInstructionsBase<KaminoData> {
+    accounts: KaminoAccounts;
+    programId: Address;
+    lookupTable: Address<"bzdjSeDDPEdsGpK73oevQ87x4Sm6QRsnzupPLQEaFFN">;
+    constructor(rpc: Rpc<SolanaRpcApi>, rpcUrl: string, data: KaminoData, accounts: KaminoAccounts);
+    clearTransactionCache(txId?: string): void;
+    private getUserAccountCacheInvalidations;
+    private getInitUserMetadataCpiData;
+    getInitLendingPositionCpiData(params: {
+        pool: Address;
+        user: Address;
+        payer: Address;
+        userAccountId: number;
+        collateralReserve: Address;
+        debtReserve: Address;
+    }): Promise<SplitLpOperationCpiData>;
+    getInitUserAccountCpiData(pool: Address, user: Address, payer: Address, id: number, userLookupTable?: Address): Promise<SplitLpOperationCpiData>;
+    private getInitObligationFarmsForReserveCpiData;
+    /**
+     * Returns CPI accounts for refreshing a reserve's state.
+     * Includes the market, reserve, and all configured oracle accounts.
+     */
+    private getRefreshReserveCpiData;
+    private getRefreshObligationCpiData;
+    private getRefreshObligationCpiDataFromReserves;
+    getPrerequisiteCpisForRefresh(targets: RefreshPrerequisiteTarget[]): Promise<CpiData[]>;
+    private getRefreshUserFarmCpiData;
+    /**
+     * Checks if refresh CPIs are needed for the given reserve and obligation.
+     * Also registers all involved reserves in the txReserves cache for getPreInstructions.
+     *
+     * The instruction `reserve` (collateral vs debt) is also listed on the obligation;
+     * `dedupeOrderedAddresses` ensures one RefreshReserve CPI per reserve pubkey.
+     */
+    private getRefreshCpisIfNeeded;
+    getPreInstructions(txId: string): Promise<Instruction[]>;
+    getClaimIncentiveCpiData(user: Address, payer: Address, pool: Address, reserve: Address, obligation: Address, farm: Address, userFarm: Address, mint: Address): Promise<CpiData[]>;
+    getRequestElevationGroupCpiData(elevationGroup: number, user: Address, obligation: Address, pool: Address, txId: string): Promise<CpiData>;
+    getInitAndDepositCpiData(params: LendingOperationParams, userAccountId: number): Promise<SplitLpOperationCpiData>;
+    getInitBorrowPositionCpiData(params: LendingOperationParams, collReserve: Address): Promise<SplitLpOperationCpiData>;
+    getDepositCpiData(params: LendingOperationParams): Promise<SplitLpOperationCpiData>;
+    getWithdrawCpiData(params: LendingOperationParams): Promise<SplitLpOperationCpiData>;
+    getBorrowCpiData(params: LendingOperationParams): Promise<SplitLpOperationCpiData>;
+    getRepayCpiData(params: RepayOperationParams): Promise<SplitLpOperationCpiData>;
+}
+
+/** Parameters for building a flash-borrow instruction. */
+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. */
+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
+ */
+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>;
+}
+
+/**
+ * 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
+ */
+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[]>;
+}
+
+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;
+}
+
+/**
+ * Client for interacting with Kamino Lend protocol.
+ * Provides access to data, accounts, and instruction builders for lending operations.
+ */
+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;
+}
+
+interface SupportedLendingPlatformClients {
+    kamino: KaminoClient;
+}
+/**
+ * Central registry for protocol-specific lending clients used throughout the
+ * long-yield-carry SDK.
+ */
+declare class LendingPlatformClientRegistry {
+    private readonly kaminoClient;
+    constructor(clients: SupportedLendingPlatformClients);
+    getAll(): LendingPlatformClientBase<LendingPlatformData>[];
+    getPlatformForPosition(position: TokenLendingPositionData): LendingPlatform$1;
+    getForPosition(position: TokenLendingPositionData): LendingPlatformClientBase<LendingPlatformData>;
+    getByPlatform(platform: LendingPlatform$1.Kamino): KaminoClient;
+    getByPlatform(platform: LendingPlatform$1): LendingPlatformClientBase<LendingPlatformData>;
+}
+
+interface LongYieldCarryBuilderContext {
+    rpc: Rpc<SolanaRpcApi>;
+    environment: Environment;
+    program: Program<LongYieldCarry>;
+    account: AccountClient;
+    pda: PdaClient;
+    swap: SwapClient;
+    externalLiquidityResolver: LongYieldCarryExternalLiquidityResolver;
+    lendingPlatformClients: LendingPlatformClientRegistry;
+}
+
+type AnchorInterestDistribution = {
+    intoTokenPrice: {};
+} | {
+    intoWallets: {};
+};
+declare enum InterestDistribution {
+    IntoTokenPrice = 0,
+    IntoWallets = 1
+}
+declare function interestDistributionToEnum(v: AnchorInterestDistribution): InterestDistribution;
+declare function enumToInterestDistribution(t: InterestDistribution): AnchorInterestDistribution;
+type AnchorLendingType = {
+    lendingMarket: {};
+} | {
+    vault: {};
+};
+declare enum LendingType {
+    LendingMarket = 0,
+    Vault = 1
+}
+declare function lendingTypeToEnum(v: AnchorLendingType): LendingType;
+declare function enumToLendingType(t: LendingType): AnchorLendingType;
+
+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[];
+}
+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;
+}
+interface UpdateYieldingBankConfigParams {
+    /** New default redemption mint (passed as a named account, not a param) */
+    defaultRedemptionMint: Address;
+}
+interface UpdateTokenConfigurationParams {
+    /** Omit to leave unchanged. */
+    performanceFeeBps?: number;
+    /** Omit to leave unchanged. */
+    mintingFeeBps?: number;
+    /** Omit to leave unchanged. */
+    burningFeeBps?: number;
+    /** Omit to leave unchanged. */
+    protocolMintBurnPctBps?: number;
+    /** Omit to leave unchanged. */
+    curatorMintBurnPctBps?: number;
+    /** Omit to leave unchanged. */
+    curatorPerfPctBps?: number;
+    /**
+     * Target and hard cap (bps) for annualized price growth during fee release;
+     * `0` parks absorbed fees.
+     * Omit to leave unchanged.
+     */
+    feeDripMaxApyBps?: number;
+    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;
+}
+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 */
+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.
+ */
+interface AssetConfig {
+    mint: Address;
+    oracle: Address;
+    oracleType: AnchorOracleType;
+    externalLiquidityType: AnchorExternalLiquidityType;
+}
+/** Configuration for adding a new external yielding position */
+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.
+ */
+interface YieldingBankAllocationConfig {
+    assetHolding?: AssetConfig;
+    externalPosition?: ExternalPositionConfig;
+}
+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.
+ */
+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.
+ */
+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;
+}
+interface UpdateLendingPositionConfigParams {
+    lendingPositionIndex: number;
+    targetUtilizationRateBps: number;
+    maxDeviationAboveTargetUtilBps: number;
+    maxDeviationBelowTargetUtilBps: number;
+}
+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[];
+}
+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[];
+}
+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[];
+}
+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;
+}
+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[];
+}
+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`).
+ */
+interface BurnTokenIxParams {
+    burnAmount: BN | number;
+    asyncFallback?: {
+        epochId: BN | number;
+        requestSequence: BN | number;
+        redemptionEpoch?: Address;
+        request?: Address;
+    };
+}
+interface SetRedemptionEpochStatusParams {
+    status: number;
+}
+interface TopUpUnlentReservesParams {
+    prerequisiteCpis: InstructionRefs;
+    ixRefs: InstructionRefs;
+    lendingPositionIndex: number;
+    remainingAccounts: CustomAccountMeta[];
+    redemptionEpoch?: Address;
+}
+interface UpdateTokenMetadataParams {
+    /** Pre-built Metaplex UpdateMetadataAccountV2 CPI refs (exactly one CPI). */
+    ixRefs: InstructionRefs;
+    /** Fully deduplicated remaining-accounts pool for the metadata CPI. */
+    remainingAccounts: CustomAccountMeta[];
+}
+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;
+}
+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[];
+}
+
+/**
+ * Shared fields carried by normalized execution plans.
+ *
+ * These values are produced before the transaction layer resolves remaining
+ * account refs and ATA creation instructions.
+ */
+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.
+ */
+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.
+ */
+interface GroupedCpiExecutionPlan extends PlannedInstructionBase {
+    /** Ordered CPI groups where each group maps to a distinct refs input. */
+    cpiDataGroups: CpiData[][];
+}
+
+/**
+ * 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).
+ */
+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.
+ */
+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({...})`.
+ */
+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.
+ */
+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$1;
+    /**
+     * 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;
+}
+
+/**
+ * Fully composed transaction output ready to pass to `sendTransaction`.
+ */
+interface LongYieldCarryTransactionPlan extends TransactionPlan {
+    /**
+     * 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;
+}
+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;
+    };
+}
+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";
+}
+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;
+}
+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.
+ */
+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.
+ */
+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;
+    };
+}
+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;
+}
+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;
+}
+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;
+}
+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;
+}
+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.
+ */
+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;
+}
+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`.
+ */
+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.
+ */
+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({...})`.
+ */
+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;
+}
+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;
+}
+
+/**
+ * Account fetchers for the long_yield_carry program.
+ *
+ * Extends {@link BaseAccountClient} for shared DataCache + `splAtaExists`, then adds LYC-specific
+ * deserialization and helpers (Token, YieldingBank, carry-trade metas).
+ */
+declare class AccountClient extends BaseAccountClient {
+    private readonly program;
+    readonly pda: PdaClient;
+    constructor(program: Program<LongYieldCarry>, pda: PdaClient, rpc: Rpc<SolanaRpcApi>);
+    /** Fetch and deserialize a Token account by its PDA address. */
+    fetchToken(token: Address, opts?: {
+        fresh?: boolean;
+    }): Promise<LYCToken>;
+    /** Fetch and deserialize multiple Token accounts by their PDA addresses. */
+    fetchTokens(tokens: Address[]): Promise<LYCToken[]>;
+    /**
+     * Fetch all Token accounts owned by the program.
+     *
+     * Pass `{ fresh: true }` to clear the cached `"all"` entry before reading,
+     * forcing a fresh `getProgramAccounts` call. The returned data is
+     * re-cached so subsequent callers benefit from the same refresh.
+     */
+    fetchAllTokens(opts?: {
+        fresh?: boolean;
+    }): Promise<LYCToken[]>;
+    /** Fetch and deserialize a YieldingBank account by its PDA address. */
+    fetchYieldingBank(bank: Address): Promise<LYCYieldingBank>;
+    /** Fetch and deserialize multiple YieldingBank accounts by their PDA addresses. */
+    fetchYieldingBanks(banks: Address[]): Promise<LYCYieldingBank[]>;
+    /** Fetch all YieldingBank accounts owned by the program. */
+    fetchAllYieldingBanks(): Promise<LYCYieldingBank[]>;
+    /** Fetch and deserialize a RedemptionEpoch account by its PDA address. */
+    fetchRedemptionEpoch(epochPda: Address, opts?: {
+        fresh?: boolean;
+    }): Promise<RedemptionEpochSnapshot>;
+    /** Fetch all RedemptionEpoch accounts owned by the program. */
+    fetchAllRedemptionEpochs(opts?: {
+        fresh?: boolean;
+    }): Promise<RedemptionEpochSnapshot[]>;
+    /**
+     * Fetch all LYC yToken holdings for a wallet.
+     *
+     * Reads the user's ATA per LYC token directly via `getMultipleAccounts` —
+     * cost scales with the LYC token count (typically <10), not the wallet's
+     * total token-account count, which can be in the hundreds for active users.
+     *
+     * USD valuation: only when `opts.priceMap` supplies a positive USD price for
+     * the collateral mint and `token.price` (NAV) is positive:
+     *   `valueUsd = uiBalance × token.price × priceMap[collateralMint]`.
+     * If the caller does not supply a usable collateral price, `valueUsd` is
+     * omitted — we do not infer USD from on-chain `tvlUsd` / `totalSupply`, since
+     * those can lag risk-asset markets by tens of minutes.
+     *
+     * Tokens with no user ATA or a zero balance are filtered out unless
+     * `opts.includeEmpty` is set.
+     *
+     * Pass `opts.tokens` when the caller already has a list of tokens (e.g. a
+     * backend service with its own shorter-lived tokens cache) to skip the
+     * internal `fetchAllTokens` call and its 5-minute SDK cache.
+     */
+    fetchUserHoldings(owner: Address, opts?: {
+        includeEmpty?: boolean;
+        tokens?: LYCToken[];
+        priceMap?: Partial<Record<Address, number>>;
+    }): Promise<UserHolding[]>;
+    /** Fetch all Token and YieldingBank accounts in parallel. */
+    fetchAllTokensAndYieldingBanks(): Promise<{
+        tokens: LYCToken[];
+        yieldingBanks: LYCYieldingBank[];
+    }>;
+    /**
+     * Build the ordered remaining-accounts list required by refresh_yielding_bank
+     * (and embedded within rebalance_yielding_bank):
+     *
+     *   1. base_asset: [token_account, oracle, external_liquidity...] (if active)
+     *   2. Per active asset holding (in slot order): [token_account, oracle, external_liquidity...]
+     *      The token_account is the mint's ATA owned by the bank PDA; the program
+     *      reads its raw balance to sync asset.amount on every refresh.
+     *   3. One user account per active external yielding position (in slot order)
+     *
+     * If `newAllocation` is provided, its [token_account, oracle, external_liquidity...]
+     * tuple is injected at the first inactive slot, matching where `apply_allocation`
+     * will register it.
+     */
+    getYieldingBankRefreshAccounts(bank: Address, newAllocation?: YieldingBankAllocationConfig, externalLiquiditySources?: YieldingBankExternalLiquiditySource[]): Promise<CustomAccountMeta[]>;
+    /**
+     * Build the carry-trade remaining accounts for increase/decrease carry
+     * position instructions.
+     *
+     * Fetches the token's lending position at `lendingPositionIndex`, derives
+     * the debt ATAs, and returns the ordered account metas that
+     * `parse_carry_trade_accounts` expects on the Rust side.
+     *
+     * Returns the fixed carry-trade account prefix, including the instructions
+     * sysvar in slot 8 so CPI refs are derived against the on-chain layout.
+     *
+     * @param lendingPositionUserAccount - Override for the protocol user account.
+     *   Defaults to the value stored in the on-chain lending position.
+     */
+    getCarryTradeAccounts(token: Address, yieldingBank: Address, lendingPositionIndex: number, lendingPositionUserAccount?: Address): Promise<CustomAccountMeta[]>;
+    /**
+     * Derive the account set needed to refresh a single token lending position.
+     *
+     * This pulls the protocol user account, collateral reserve, and debt oracle
+     * from the selected lending position so callers can pass the exact accounts
+     * required by refresh-oriented instructions. Optional overrides let tests or
+     * advanced callers substitute explicit addresses when needed.
+     */
+    getTokenLendingPositionRefreshAccounts(tokenData: TokenAccountData, lendingPositionIndex: number, overrides?: TokenLpPositionAccountOverrides): {
+        userAccount: Address;
+        collateralReserve: Address;
+        debtOracle: Address;
+    };
+    /**
+     * Build the fixed initial-accounts prefix for `rebalance_token`.
+     *
+     * The Rust handler reads these positionally from the front of
+     * `remaining_accounts` (see `RebalanceTokenAccounts::parse`). Returning the
+     * prefix as `initialAccounts` to `createMultiCpiRefs` lets every CPI in the
+     * flash-rebalance bundle deduplicate against these slots, shrinking the
+     * transaction's account list compared to declaring them as named ix
+     * accounts that would force separate copies in the message header.
+     */
+    getRebalanceTokenInitialAccounts(token: Address, yieldingBank: Address, lpIndex: number, destinationDebtOracle: Address, overrides?: TokenLpPositionAccountOverrides): Promise<CustomAccountMeta[]>;
+    /**
+     * Build the initial account pool seed for refresh_token_state.
+     *
+     * These accounts are placed at the front of the deduplicated remaining_accounts
+     * pool (positions 0..N-1), so the index-based TokenRefreshRefs computed by
+     * the builder remain stable whether or not prereq CPIs introduce additional accounts.
+     *
+     * Order:
+     *   1. Per active lending position (in slot order): protocol_user_acc, collateral_reserve, debt_oracle
+     *   2. One YieldingBank PDA per active carry position (in slot order)
+     */
+    getTokenRefreshAccounts(token: Address): Promise<CustomAccountMeta[]>;
+    private toRedemptionEpochSnapshot;
+}
+
+interface CreateTokenIxArgs {
+    mint: Address;
+    collateralMint: Address;
+    params: CreateTokenParams;
+    tokenProgram?: Address;
+    collateralTokenProgram?: Address;
+    /** Curator signer. Must be in the on-chain `WHITELISTED_CURATORS` list.
+     *  Defaults to the builder's admin wallet. */
+    curator?: Address;
+    /** Optional per-token admin override. Omit to use the program default. */
+    adminRole?: Address;
+    /** Optional per-token manager override. Omit to use the program default. */
+    managerRole?: Address;
+    /** Optional per-token curator-fees wallet override. Omit to use the program default. */
+    curatorFeeWallet?: Address;
+    /** Optional per-token circuit-breaker controller override. Omit to use the program default. */
+    cbControllerRole?: Address;
+}
+interface CreateCpiPlanIxArgs {
+    cpiPlan: Address;
+    manager: Address;
+    params: CreateCpiPlanParams;
+}
+interface UpdateTokenMetadataIxArgs {
+    token: Address;
+    mint: Address;
+    params: UpdateTokenMetadataParams;
+}
+interface CreateTokenLendingPositionIxArgs {
+    token: Address;
+    params: CreateTokenLendingPositionParams;
+    /**
+     * Accounts that describe the new lending position — their pubkeys are
+     * stored on the position and their on-chain state is read by the final
+     * refresh.
+     */
+    accounts: CreateTokenLendingPositionAccounts;
+}
+interface CreateTokenLendingPositionTxArgs {
+    /** Token PDA that will own the new lending position. */
+    token: Address;
+    /**
+     * Debt mint address. Decimals, token program, and oracle metadata are
+     * derived from the mint registry / oracle service.
+     */
+    debtMint: Address;
+    /** Debt reserve address. Looked up by `debtMint` against the pool when omitted. */
+    debtReserve?: Address;
+    /**
+     * Lending-protocol user-account ID used when the obligation must be
+     * created. Ignored when the protocol user account already exists.
+     * Defaults to 0. For Kamino this is the obligation sub-account index.
+     */
+    userAccountId?: number;
+    /**
+     * Lending pool. When omitted, resolved automatically from the token's
+     * collateral mint via {@link resolveDefaultPool}. Throws if the mint
+     * is listed in zero or multiple pools (caller must disambiguate).
+     */
+    pool?: Address;
+    /** @default LendingPlatform.Kamino */
+    lendingPlatform?: LendingPlatform$1;
+    /** @default 9000 */
+    targetUtilizationRateBps?: number;
+    /** @default 150 */
+    maxDeviationAboveTargetUtilBps?: number;
+    /** @default 300 */
+    maxDeviationBelowTargetUtilBps?: number;
+    /** Optional txId reused across composed plans in the same transaction. */
+    txId?: string;
+}
+interface CreateYieldingBankIxArgs {
+    baseMint: Address;
+    params: CreateYieldingBankParams;
+    baseMintTokenProgram?: Address;
+    /** Curator signer. Must be in on-chain `WHITELISTED_CURATORS`. Defaults to builder admin. */
+    curator?: Address;
+    /** Optional admin override. Omit to use the program default. */
+    adminRole?: Address;
+    /** Optional manager override. Omit to use the program default. */
+    managerRole?: Address;
+    /** Optional circuit-breaker controller override. Omit to use the program default. */
+    cbControllerRole?: Address;
+}
+interface RefreshYieldingBankIxArgs {
+    signer: Address;
+    yieldingBank: Address;
+    externalLiquiditySources?: YieldingBankExternalLiquiditySource[];
+}
+interface RefreshYieldingBankTxArgs {
+    signer: Address;
+    yieldingBank: Address;
+}
+interface CreateYieldingBankAllocationIxArgs {
+    yieldingBank: Address;
+    config: YieldingBankAllocationConfig;
+}
+interface RebalanceYieldingBankIxArgs {
+    yieldingBank: Address;
+    params: RebalanceYieldingBankParams;
+}
+interface RebalanceYieldingBankTxArgs {
+    yieldingBank: Address;
+    params: RebalanceYieldingBankTxParams;
+}
+interface RefreshTokenStateIxArgs {
+    signer: Address;
+    token: Address;
+    collateralOracle: Address;
+    /** Optional secondary oracle account, required only for composite oracle
+     * types. For `PythSplStake` collateral this is the SPL stake pool account. */
+    secondaryCollateralOracle?: Address;
+    collateralTokenAccount: Address;
+    collateralTokenProgram: Address;
+}
+interface RefreshTokensBuilderTxArgs {
+    signer: Address;
+    params: RefreshTokensTxParams;
+}
+interface IncreaseCarryPositionIxArgs {
+    token: Address;
+    params: IncreaseCarryPositionParams;
+}
+interface IncreaseCarryPositionTxArgs {
+    manager: Address;
+    token: Address;
+    params: IncreaseCarryPositionTxParams;
+}
+interface RebalanceTokenIxArgs {
+    token: Address;
+    params: RebalanceTokenParams;
+}
+interface RebalanceTokenTxArgs {
+    token: Address;
+    params: RebalanceTokenTxParams;
+}
+interface RecollateralizeLossIxArgs {
+    token: Address;
+    params: RecollateralizeLossParams;
+}
+interface RecollateralizeLossTxArgs {
+    token: Address;
+    params: RecollateralizeLossTxParams;
+}
+interface DecreaseCarryPositionIxArgs {
+    signer: Address;
+    params: DecreaseCarryPositionParams;
+}
+interface DecreaseCarryPositionTxArgs {
+    signer: Address;
+    token: Address;
+    params: DecreaseCarryPositionTxParams;
+    /** When set, the DCP loss is attributed to this epoch instead of socialised into the price. */
+    redemptionEpoch?: Address;
+}
+interface UpdateLendingPositionConfigIxArgs {
+    token: Address;
+    params: UpdateLendingPositionConfigParams;
+}
+interface DepositUnlentCollateralIxArgs {
+    token: Address;
+    params: DepositUnlentCollateralParams;
+}
+interface SetTokenCircuitBreakerIxArgs {
+    authority: Address;
+    token: Address;
+    active: boolean;
+}
+interface SetTokenCircuitBreakerTxArgs {
+    authority: Address;
+    token: Address;
+    active: boolean;
+}
+interface MintTokenIxArgs {
+    signer: Address;
+    token: Address;
+    depositAmount: BN;
+}
+interface MintTokenTxArgs {
+    signer: Address;
+    token: Address;
+    params: MintTokenTxParams;
+}
+interface BurnTokenIxArgs {
+    signer: Address;
+    token: Address;
+    params: BurnTokenIxParams;
+    /** Pays rent for async-path accounts; must sign the transaction. Defaults to signer. */
+    payer?: Address;
+}
+interface BurnTokenTxArgs {
+    signer: Address;
+    token: Address;
+    params: BurnTokenTxParams;
+    /** Pays rent for async-path accounts; must sign the transaction. Defaults to signer. */
+    payer?: Address;
+}
+interface SetRedemptionEpochStatusIxArgs {
+    token: Address;
+    redemptionEpoch: Address;
+    params: SetRedemptionEpochStatusParams;
+}
+interface TopUpUnlentReservesIxArgs {
+    token: Address;
+    params: TopUpUnlentReservesParams;
+}
+interface TopUpUnlentReservesTxArgs {
+    token: Address;
+    params: TopUpUnlentReservesTxParams;
+}
+interface CreditUnlentToRedemptionEpochIxArgs {
+    token: Address;
+    redemptionEpoch: Address;
+}
+interface ProcessAsyncBurnIxArgs {
+    token: Address;
+    redemptionEpoch: Address;
+    request: Address;
+}
+interface ProcessAsyncBurnTxArgs {
+    token: Address;
+    params: ProcessAsyncBurnTxParams;
+}
+interface ClaimIncentivesIxArgs {
+    token: Address;
+    params: ClaimIncentivesParams;
+}
+interface ClaimIncentivesTxArgs {
+    token: Address;
+    params: ClaimIncentivesTxParams;
+}
+interface CollectInterestIxArgs {
+    token: Address;
+    yieldingBank: Address;
+    params: CollectInterestParams;
+}
+interface CollectInterestTxArgs {
+    manager: Address;
+    token: Address;
+    params: CollectInterestTxParams;
+}
+interface SetYieldingBankCircuitBreakerIxArgs {
+    authority: Address;
+    yieldingBank: Address;
+    active: boolean;
+}
+interface SetYieldingBankCircuitBreakerTxArgs {
+    authority: Address;
+    yieldingBank: Address;
+    active: boolean;
+}
+interface UpdateYieldingBankConfigIxArgs {
+    yieldingBank: Address;
+    params: UpdateYieldingBankConfigParams;
+    /** Optional admin signer override. */
+    admin?: Address;
+    /** Optional new manager. Omit for no change. */
+    managerRole?: Address;
+    /** Optional new circuit-breaker controller. Omit for no change. */
+    cbControllerRole?: Address;
+    /** Optional new whitelisted curator. Omit for no change. */
+    curatorRole?: Address;
+    /** Optional new admin. Omit for no change. */
+    adminRole?: Address;
+}
+interface ResetTokenBurnRateLimitIxArgs {
+    token: Address;
+}
+interface UpdateTokenConfigurationIxArgs {
+    token: Address;
+    params: UpdateTokenConfigurationParams;
+    /**
+     * Optional authority signer. The token admin may update all configuration;
+     * the token curator may update the curator fee wallet only; the token manager
+     * may update `feeDripMaxApyBps` only. Defaults to the token admin.
+     */
+    admin?: Address;
+    /** Optional new manager. Omit for no change. */
+    managerRole?: Address;
+    /** Optional new curator-fees wallet. Rotatable by admin or curator. Omit for no change. */
+    curatorFeeWallet?: Address;
+    /** Optional new circuit-breaker controller. Omit for no change. */
+    cbControllerRole?: Address;
+    /** Optional new whitelisted curator. Omit for no change. */
+    curatorRole?: Address;
+    /** Optional new admin. Omit for no change. */
+    adminRole?: Address;
+}
+interface CollectFeesIxArgs {
+    token: Address;
+    /**
+     * Signer collecting the fees. Must be either the token's `roles.curator`
+     * (drains `pending_curator_fees` into the curator fee wallet) or the
+     * program-wide `PROTOCOL_ADMIN` (drains `pending_protocol_fees` into the
+     * protocol fee wallet). The fee bucket and destination wallet are both
+     * derived from whichever role this signer matches.
+     */
+    authority: Address;
+}
+interface DepositUnlentCollateralTxArgs {
+    manager: Address;
+    token: Address;
+    params: DepositUnlentCollateralTxParams;
+}
+
+interface BundledBurnPlan {
+    instructions?: Instruction[];
+    [key: string]: unknown;
+}
+declare class BurnTokenBuilder extends LongYieldCarryBuilderBase<BurnTokenIxArgs, BurnTokenTxArgs> {
+    getIx(args: BurnTokenIxArgs): Promise<Instruction>;
+    getTx(args: BurnTokenTxArgs): Promise<LongYieldCarryTransactionPlan>;
+    buildBundledBurnPlan(..._args: unknown[]): Promise<BundledBurnPlan>;
+    private resolveAllSentinel;
+    private resolveAsyncFallbackParams;
+    private resolveNextRequestSequence;
+    private resolveAsyncAccounts;
+    private getUnwrapSolAfterBurnIfCollateralSol;
+}
+
+declare class MintTokenBuilder extends LongYieldCarryBuilderBase<MintTokenIxArgs, MintTokenTxArgs> {
+    getIx(args: MintTokenIxArgs): Promise<Instruction>;
+    getTx(args: MintTokenTxArgs): Promise<LongYieldCarryTransactionPlan>;
+}
+
+declare abstract class LongYieldCarryBuilderBase<TIxArgs, TTxArgs = TIxArgs, TTxResult = LongYieldCarryTransactionPlan> extends BaseIXBuilderService<LongYieldCarryBuilderContext, TIxArgs, TTxArgs, TTxResult> {
+    protected get rpc(): _solana_kit.Rpc<_solana_kit.RequestAirdropApi & _solana_kit.GetAccountInfoApi & _solana_kit.GetBalanceApi & _solana_kit.GetBlockApi & _solana_kit.GetBlockCommitmentApi & _solana_kit.GetBlockHeightApi & _solana_kit.GetBlockProductionApi & _solana_kit.GetBlocksApi & _solana_kit.GetBlocksWithLimitApi & _solana_kit.GetBlockTimeApi & _solana_kit.GetClusterNodesApi & _solana_kit.GetEpochInfoApi & _solana_kit.GetEpochScheduleApi & _solana_kit.GetFeeForMessageApi & _solana_kit.GetFirstAvailableBlockApi & _solana_kit.GetGenesisHashApi & _solana_kit.GetHealthApi & _solana_kit.GetHighestSnapshotSlotApi & _solana_kit.GetIdentityApi & _solana_kit.GetInflationGovernorApi & _solana_kit.GetInflationRateApi & _solana_kit.GetInflationRewardApi & _solana_kit.GetLargestAccountsApi & _solana_kit.GetLatestBlockhashApi & _solana_kit.GetLeaderScheduleApi & _solana_kit.GetMaxRetransmitSlotApi & _solana_kit.GetMaxShredInsertSlotApi & _solana_kit.GetMinimumBalanceForRentExemptionApi & _solana_kit.GetMultipleAccountsApi & _solana_kit.GetProgramAccountsApi & _solana_kit.GetRecentPerformanceSamplesApi & _solana_kit.GetRecentPrioritizationFeesApi & _solana_kit.GetSignaturesForAddressApi & _solana_kit.GetSignatureStatusesApi & _solana_kit.GetSlotApi & _solana_kit.GetSlotLeaderApi & _solana_kit.GetSlotLeadersApi & _solana_kit.GetStakeMinimumDelegationApi & _solana_kit.GetSupplyApi & _solana_kit.GetTokenAccountBalanceApi & _solana_kit.GetTokenAccountsByDelegateApi & _solana_kit.GetTokenAccountsByOwnerApi & _solana_kit.GetTokenLargestAccountsApi & _solana_kit.GetTokenSupplyApi & _solana_kit.GetTransactionApi & _solana_kit.GetTransactionCountApi & _solana_kit.GetVersionApi & _solana_kit.GetVoteAccountsApi & _solana_kit.IsBlockhashValidApi & _solana_kit.MinimumLedgerSlotApi & _solana_kit.SendTransactionApi & _solana_kit.SimulateTransactionApi>;
+    protected get program(): _anchor_lang_core.Program<LongYieldCarry>;
+    protected get account(): AccountClient;
+    protected get pda(): PdaClient;
+    protected get swap(): SwapClient<unknown>;
+    protected get externalLiquidityResolver(): LongYieldCarryExternalLiquidityResolver;
+    protected get environment(): Environment;
+    protected get lendingPlatformClients(): LendingPlatformClientRegistry;
+    /**
+     * Environment-level manager fallback. Use {@link resolveTokenManager} /
+     * {@link resolveYieldingBankManager} whenever a specific token/bank's role
+     * might override the default.
+     */
+    private get manager();
+    /**
+     * Environment-level circuit-breaker-controller fallback. Use
+     * {@link resolveTokenCbController} / {@link resolveYieldingBankCbController}
+     * whenever a specific token/bank's role might override the default.
+     */
+    private get circuitBreakerController();
+    /**
+     * Program-level admin. Also doubles as the environment-level fallback for
+     * `TokenRoles::admin()` / `YieldingBankRoles::admin()` when their stored role
+     * is unset — both Rust fallbacks resolve to this same pubkey by design.
+     */
+    private get protocolAdmin();
+    /**
+     * Program-level fee wallet. Also doubles as the fallback for
+     * `TokenRoles::curator_fee_wallet()` when a token's `roles.fees` is unset —
+     * the Rust `curator_fee_wallet()` getter delegates to `protocol_fee_wallet()`.
+     */
+    protected get protocolFeeWallet(): Address;
+    /** Program ID for this environment — used as the "no-change"/"use-default" sentinel on role accounts. */
+    protected get programId(): Address;
+    /**
+     * Return the on-chain role key if it's set, otherwise the environment
+     * fallback. Mirrors the Rust role getter pattern (`if self.role != default()
+     * { self.role } else { <env default> }`).
+     */
+    private resolveStoredOrFallback;
+    protected resolveTokenAdmin(tokenData: TokenAccountData): Address;
+    protected resolveTokenManager(tokenData: TokenAccountData): Address;
+    protected resolveTokenCuratorFeeWallet(tokenData: TokenAccountData): Address;
+    protected resolveTokenCbController(tokenData: TokenAccountData): Address;
+    /**
+     * Optional composite collateral oracle (e.g. SPL stake pool for PythSplStake).
+     * Anchor optional accounts must be passed as `null` when unset.
+     */
+    protected resolveOptionalSecondaryCollateralOracle(collateral: TokenAccountData["collateral"]): Address | null;
+    protected resolveYieldingBankAdmin(bankData: YieldingBankAccountData): Address;
+    protected resolveYieldingBankManager(bankData: YieldingBankAccountData): Address;
+    protected resolveYieldingBankCbController(bankData: YieldingBankAccountData): Address;
+    protected getTxLookupTables(tokenPda?: Address | readonly Address[], existingLookupTables?: readonly Address[]): Address[];
+    protected getLendingPlatformClient(position: TokenLendingPositionData): LendingPlatformClientBase<LendingPlatformData>;
+    protected getCreateUserCollateralAtaIxIfNeeded(owner: Address, collateralMint: Address, collateralTokenProgram: Address): Promise<CreateAtaIxIfNeededResult>;
+    protected getWrapSolInstructionsIfMintIsSol(owner: Address, mint: Address, lamports: BN): Promise<{
+        instructions?: Instruction[];
+        postSuccessCacheInvalidations?: LongYieldCarryTransactionPlan["postSuccessCacheInvalidations"];
+    }>;
+    protected getLendingOperationCpiData(token: Address, manager: Address, position: TokenLendingPositionData, txId: string, operation: "deposit" | "withdraw" | "borrow" | "repay", uiAmount?: number | "all"): Promise<LendingOperationCpiBundle>;
+}
+declare abstract class LongYieldCarrySingleInstructionBuilderService<TIxArgs, TTxArgs = TIxArgs, TTxPlan extends LongYieldCarryTransactionPlan = LongYieldCarryTransactionPlan> extends LongYieldCarryBuilderBase<TIxArgs, TTxArgs, TTxPlan> {
+    protected deriveIxArgs(txArgs: TTxArgs): Promise<TIxArgs>;
+    protected buildPreambleInstructions(_args: TIxArgs, _txArgs: TTxArgs): Promise<Instruction[]>;
+    protected buildLookupTables(_args: TIxArgs, _txArgs: TTxArgs): Promise<readonly Address[] | undefined>;
+    protected buildPlanExtras(_args: TIxArgs, _txArgs: TTxArgs): Promise<Omit<TTxPlan, "instructions" | "lookupTables"> | undefined>;
+    getTx(txArgs: TTxArgs): Promise<TTxPlan>;
+}
+
+/** Program ID per environment */
+declare const PROGRAM_ID: Record<Environment, Address>;
+/** Deployed `long_yield_carry` program IDs. */
+declare const LYC_PROGRAM_IDS: Set<string>;
+/** Manager authority for manager-gated instruction accounts */
+declare const MANAGER: Record<Environment, Address>;
+/** Circuit breaker controller for circuit-breaker-gated instruction accounts */
+declare const CIRCUIT_BREAKER_CONTROLLER: Record<Environment, Address>;
+
+/**
+ * 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()`).
+ */
+declare const PROTOCOL_FEE_WALLET: Record<Environment, Address>;
+/** Redemption epoch status: accepting new async burn requests. */
+declare const REDEMPTION_EPOCH_STATUS_OPEN = 0;
+/** Redemption epoch status: closed to new requests, collateral being funded. */
+declare const REDEMPTION_EPOCH_STATUS_FUNDING = 1;
+/** Redemption epoch status: funded, individual burn requests being processed. */
+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.
+ */
+declare const TOKEN_STALENESS_THRESHOLD_SECS: number;
+/** Maximum heap-frame size requested by composed multi-CPI transactions. */
+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.
+ */
+declare const REBALANCE_TOKEN_RATE_LIMIT_SECS: number;
+/** Default recollateralize-loss swap slippage, capped by the on-chain 150 bps check. */
+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.
+ */
+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.
+ */
+declare const AMOUNT_ALL_SENTINEL: BN;
+/** Re-exported from `common` — see {@link DEPLOYED_ADMIN_KEYPAIR_FP} there. */
+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).
+ */
+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).
+ */
+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`.
+ */
+declare const GENERAL_LOOKUP_TABLES: Record<DeployedEnv, Address>;
+declare const TOKEN_LOOKUP_TABLES: Record<Address, Address>;
+
+/**
+ * Display fields used as the fallback when on-chain Metaplex Token-Metadata
+ * is missing or empty. Mirrors {@link OnchainTokenMetadata} on the read path
+ * so the consumer can treat both sources uniformly.
+ */
+interface LycTokenMetadataEntry {
+    /** Brand-cased symbol shown as the primary label (e.g. "ksBTC", "primeBTC"). */
+    symbol: string;
+    /** Human-readable name (e.g. "Kestrel BTC", "Prime BTC"). */
+    name: string;
+}
+/**
+ * Curated fallback registry of LYC token display metadata, keyed by the
+ * token's mint address. Only used when on-chain Metaplex Token-Metadata
+ * isn't set yet — the on-chain value always wins.
+ *
+ * This exists because:
+ *   1. Multiple LYC tokens can share the same underlying collateral
+ *      (e.g. ksBTC and primeBTC both built on cbBTC), so the LYC token's
+ *      symbol cannot be synthesized from the collateral's symbol alone.
+ *   2. Metaplex `update_token_metadata` requires an admin transaction we
+ *      don't always run before a token starts surfacing in the UI.
+ *
+ * Keyed by environment because LYC mints are unique per program deployment.
+ *
+ * To populate, add the LYC token mint address as the key. Once metadata is
+ * set on-chain via:
+ *
+ *   pnpm --filter @kestrelfi/lyc-sdk run \
+ *     update-token-metadata -- test|prod <TOKEN_PDA|COLLATERAL_SYMBOL> \
+ *     --name "<Display Name>" --symbol "<ksXXX>" --uri "<json uri>"
+ *
+ * the entry here can be removed.
+ */
+declare const LYC_TOKEN_METADATA: Record<Environment, Record<string, LycTokenMetadataEntry>>;
+
+export { type RebalanceTokenIxArgs as $, AccountClient as A, type BurnAmounts as B, type CpiData as C, type CustomAccountMeta as D, type Environment as E, type DecreaseCarryPositionPlan as F, type LongYieldCarry as G, type YieldingBankExternalLiquiditySource as H, type InstructionRefs as I, type TransactionCacheInvalidation as J, type CreateTokenLendingPositionParams as K, LendingPlatformData as L, type MintIdentifier as M, type CreateTokenLendingPositionAccounts as N, type DecreaseCarryPositionIxArgs as O, type PositionBalanceChange as P, type DecreaseCarryPositionTxArgs as Q, ReserveBase as R, type SingleCpiExecutionPlan as S, type TopUpUnlentReservesIxArgs as T, type DecreaseCarryPositionTxParams as U, type DecreaseCarryPositionTxBuilderParams as V, type DepositUnlentCollateralIxArgs as W, type DepositUnlentCollateralTxArgs as X, type YieldingBankAllocationConfig as Y, type IncreaseCarryPositionIxArgs as Z, type IncreaseCarryPositionTxArgs as _, type PricedMint as a, LYC_ADMIN_KEYPAIR_FP as a$, type RebalanceTokenTxArgs as a0, type RebalanceYieldingBankIxArgs as a1, type RebalanceYieldingBankTxArgs as a2, type RecollateralizeLossIxArgs as a3, type RecollateralizeLossTxArgs as a4, type RefreshTokenStateIxArgs as a5, type RefreshTokensBuilderTxArgs as a6, type RefreshYieldingBankIxArgs as a7, type RefreshYieldingBankTxArgs as a8, type ResetTokenBurnRateLimitIxArgs as a9, type AssetConfig as aA, type BundledBurnPlan as aB, type BurnTokenIxParams as aC, type BurnTokenTxParams as aD, CIRCUIT_BREAKER_CONTROLLER as aE, type ClaimIncentivesParams as aF, type ClaimIncentivesTxParams as aG, type CollectInterestParams as aH, type CollectInterestTxParams as aI, type CreateCpiPlanParams as aJ, type CreateTokenParams as aK, type CreateYieldingBankParams as aL, DEFAULT_MIN_INCENTIVE_UI_AMOUNT as aM, DEFAULT_RECOLLATERALIZE_LOSS_SLIPPAGE_BPS as aN, type DecreaseCarryPositionParams as aO, type DecreaseCarryPositionTxPlanParams as aP, type DecreaseCarryRepaySteering as aQ, type DepositUnlentCollateralParams as aR, type DepositUnlentCollateralTxParams as aS, type ExternalPositionConfig as aT, type FeeConfig as aU, GENERAL_LOOKUP_TABLES as aV, type GroupedCpiExecutionPlan as aW, type IncreaseCarryPositionParams as aX, type IncreaseCarryPositionTxParams as aY, type IndexedCarryPosition as aZ, InterestDistribution as a_, type SetTokenCircuitBreakerIxArgs as aa, type SetTokenCircuitBreakerTxArgs as ab, type SetYieldingBankCircuitBreakerIxArgs as ac, type SetYieldingBankCircuitBreakerTxArgs as ad, type UpdateLendingPositionConfigIxArgs as ae, type UpdateTokenConfigurationIxArgs as af, type UpdateTokenMetadataIxArgs as ag, type UpdateYieldingBankConfigIxArgs as ah, type TransactionPlan as ai, BurnTokenBuilder as aj, MintTokenBuilder as ak, PdaClient as al, type SwapClient as am, LendingPlatformClientRegistry as an, type SupportedLendingPlatformClients as ao, type SendTransactionOptionsWithPostSuccess as ap, type OutstandingIncentive as aq, KaminoClient as ar, type DecreaseCarryPositionBuilderParams as as, type IndexedLendingPosition as at, type RebalanceSwapSpec as au, type RedemptionEpochSnapshot as av, AMOUNT_ALL_SENTINEL as aw, type AnchorInterestDistribution as ax, type AnchorLendingType as ay, type AssetAllocationConfig as az, LongYieldCarryBuilderBase as b, LYC_CB_KEYPAIR_FP as b0, LYC_MANAGER_KEYPAIR_FP as b1, LYC_PROGRAM_IDS as b2, LYC_TOKEN_METADATA as b3, LendingType as b4, type LongYieldCarryTransactionPlanDebug as b5, type LycTokenMetadataEntry as b6, MANAGER as b7, MAX_HEAP_FRAME_BYTES as b8, type MintAmounts as b9, type UpdateLendingPositionConfigParams as bA, type UpdateTokenConfigurationParams as bB, type UpdateTokenMetadataParams as bC, type UpdateYieldingBankConfigParams as bD, type UserHolding as bE, enumToInterestDistribution as bF, enumToLendingType as bG, interestDistributionToEnum as bH, lendingTypeToEnum as bI, type BurnTokenIxArgs as bJ, type BurnTokenTxArgs as bK, IDL as bL, type MintTokenIxArgs as bM, type MintTokenTxArgs as bN, type SendTransactionOptions as bO, signSendAndConfirmTransaction as bP, type MintTokenTxParams as ba, type OracleConfigDetails as bb, PROGRAM_ID as bc, PROTOCOL_ADMIN as bd, PROTOCOL_FEE_WALLET as be, type PlannedInstructionBase as bf, type ProcessAsyncBurnTxParams as bg, REBALANCE_TOKEN_RATE_LIMIT_SECS as bh, REDEMPTION_EPOCH_STATUS_FUNDING as bi, REDEMPTION_EPOCH_STATUS_OPEN as bj, REDEMPTION_EPOCH_STATUS_PROCESSING as bk, type RebalanceTokenParams as bl, type RebalanceTokenTxParams as bm, type RebalanceYieldingBankParams as bn, type RebalanceYieldingBankTxParams as bo, type RecollateralizeLossParams as bp, type RecollateralizeLossTxParams as bq, type RefreshTokensTxParams as br, type SetRedemptionEpochStatusParams as bs, TOKEN_LOOKUP_TABLES as bt, TOKEN_STALENESS_THRESHOLD_SECS as bu, type TokenAccountData as bv, type TokenCarryPositionData as bw, type TokenLpPositionAccountOverrides as bx, type TopUpUnlentReservesParams as by, type TopUpUnlentReservesTxParams as bz, type CreditUnlentToRedemptionEpochIxArgs as c, type LongYieldCarryTransactionPlan as d, type ProcessAsyncBurnIxArgs as e, type ProcessAsyncBurnTxArgs as f, type SetRedemptionEpochStatusIxArgs as g, type TopUpUnlentReservesTxArgs as h, type LongYieldCarryBuilderContext as i, LYCToken as j, type ClaimIncentivesIxArgs as k, type ClaimIncentivesTxArgs as l, LongYieldCarrySingleInstructionBuilderService as m, type CollectFeesIxArgs as n, type CollectInterestIxArgs as o, type CollectInterestTxArgs as p, type CreateCpiPlanIxArgs as q, type CreateTokenIxArgs as r, type CreateTokenLendingPositionIxArgs as s, type CreateTokenLendingPositionTxArgs as t, type CreateYieldingBankAllocationIxArgs as u, type CreateYieldingBankIxArgs as v, LendingPlatform$1 as w, LYCYieldingBank as x, type TokenLendingPositionData as y, LendingPlatformClientBase as z };