@kestrelfi/lyc-sdk 1.0.1

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

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertCollectInterestPlanHasPositiveRedemptions = assertCollectInterestPlanHasPositiveRedemptions;
+exports.buildCollectInterestPlan = buildCollectInterestPlan;
+const core_1 = require("@anchor-lang/core");
+const web3_js_1 = require("@solana/web3.js");
+const common_1 = require("common");
+const errors_1 = require("../../errors");
+const tokenFeeMath_1 = require("../../utils/tokenFeeMath");
+/**
+ * Ensures the planner produced at least one positive redemption leg. Without this,
+ * routing would fail or build an empty CPI list even though share math passed.
+ */
+function assertCollectInterestPlanHasPositiveRedemptions(plan) {
+    const hasPositive = plan.holdingsToRedeem.some((h) => h.amount.gt(new core_1.BN(0)));
+    if (!hasPositive) {
+        throw new errors_1.NoInterestToCollectError("No redeemable yielding bank assets — nothing to collect");
+    }
+}
+/**
+ * Derive deterministic collect-interest values from fresh token and bank state.
+ * This intentionally excludes route / venue selection.
+ *
+ * @param account - Account client used to fetch fresh token and yielding-bank state.
+ * @param token - Token PDA whose carry position should collect accrued interest.
+ * @param params - Yielding bank to redeem from.
+ * @returns Deterministic collect-interest plan without swap routing attached.
+ *
+ * @throws {NoInterestToCollectError} When carry/debt math rules out collection.
+ *
+ * Before swap routing, run `assertCollectInterestPlanHasPositiveRedemptions` on the
+ * returned plan (the `getCollectInterestTx` transaction builder does this) so rounding
+ * cannot yield an empty redemption list.
+ */
+async function buildCollectInterestPlan(account, token, params) {
+    const [tokenData, bank] = await Promise.all([
+        account.fetchToken(token),
+        account.fetchYieldingBank(params.yieldingBank),
+    ]);
+    const carryIndex = tokenData.data.debtCarry.findIndex((carry) => !carry.yieldingBaseMint.equals(web3_js_1.PublicKey.default) &&
+        (0, common_1.fromWeb3Pk)(carry.yieldingBaseMint) === bank.baseMint &&
+        carry.yieldingBankId === bank.id &&
+        (0, common_1.toBigInt)(carry.shares) > BigInt(0));
+    if (carryIndex === -1) {
+        throw new errors_1.NoInterestToCollectError(`No active carry position found for yielding bank ${params.yieldingBank}`);
+    }
+    const carry = tokenData.data.debtCarry[carryIndex];
+    const totalCarryTvl = tokenData.totalCarryTvlUsd;
+    const totalDebtUsd = tokenData.totalLendingDebtTvlUsd;
+    const totalShares = (0, common_1.toBigInt)(bank.data.accounting.totalShares);
+    const tvlBefore = (0, common_1.toBigInt)(bank.data.accounting.tvl);
+    const carryShares = (0, common_1.toBigInt)(carry.shares);
+    if (!tokenData.hasInterestToCollect()) {
+        throw new errors_1.NoInterestToCollectError("Token is inactive, carry surplus is absent, or surplus exceeds the 1 bp collection limit");
+    }
+    if (totalShares <= BigInt(0)) {
+        throw new errors_1.NoInterestToCollectError("Yielding bank has no outstanding shares");
+    }
+    if (tvlBefore <= BigInt(0)) {
+        throw new errors_1.NoInterestToCollectError("Yielding bank has zero TVL — nothing to collect");
+    }
+    // Only redeem from the default redemption mint — the on-chain instruction
+    // enforces this by validating the yb_redemption_token_account ATA.
+    const redemptionMint = bank.defaultRedemptionMint;
+    const redemptionHolding = bank.findAssetHolding(redemptionMint);
+    if (!redemptionHolding) {
+        throw new errors_1.NoInterestToCollectError(`Default redemption mint ${redemptionMint} has no active asset holding on the yielding bank`);
+    }
+    const redemptionOracle = (0, common_1.fromWeb3Pk)(redemptionHolding.oracle);
+    const redemptionTokenProgram = (0, common_1.resolveTokenProgram)(redemptionHolding.tokenProgram);
+    // Use the redemption holding's cached on-chain price rather than a freshly
+    // fetched live price. The handler re-reads the same on-chain oracle account
+    // we cached from the previous refresh_yielding_bank, so using the cached
+    // value here lets the SDK predict the handler's `redemption_sold_tvl`
+    // exactly. (An independently-fetched Hermes/live price drifts by a few
+    // fixed-point units from the on-chain account, which previously caused
+    // strict-equality test assertions and the share_price invariant check to
+    // fail on rebalanced banks.)
+    const redemptionPrice = (0, common_1.toBigInt)(redemptionHolding.price);
+    const redemptionDecimals = redemptionHolding.decimals;
+    const redemptionHoldingAmount = (0, common_1.toBigInt)(redemptionHolding.amount);
+    if (redemptionPrice <= BigInt(0)) {
+        throw new errors_1.NoInterestToCollectError(`Redemption mint ${redemptionMint} has no cached price — refresh the yielding bank first`);
+    }
+    // Collectable yield is the full carry surplus above debt — must match the on-chain cap.
+    const netYieldUsd = (0, tokenFeeMath_1.collectableNetYieldUsd)(totalCarryTvl, totalDebtUsd);
+    if (params.minYieldUsd !== undefined && params.minYieldUsd > 0) {
+        const minYield8Dec = (0, common_1.toBigInt)((0, common_1.fromUiAmount)(params.minYieldUsd, 8));
+        if (netYieldUsd < minYield8Dec) {
+            throw new errors_1.NoInterestToCollectError(`Net yield $${(Number(netYieldUsd) / 1e8).toFixed(4)} is below minimum $${params.minYieldUsd}`);
+        }
+    }
+    // Target shares to burn: capped at this carry position's balance because a
+    // single call cannot drain more than this bank's own carry (the handler
+    // enforces the same cap against `carry.shares`).
+    //
+    // Use the same `totalShares / tvl` ratio as the handler's final derivation
+    // to keep a single truncation across all share-math steps.
+    const unboundedSharesToBurn = (netYieldUsd * totalShares) / tvlBefore;
+    const targetSharesToBurn = unboundedSharesToBurn < carryShares ? unboundedSharesToBurn : carryShares;
+    if (targetSharesToBurn <= BigInt(0)) {
+        throw new errors_1.NoInterestToCollectError("Computed shares to burn is zero — yield too small to collect");
+    }
+    // USD value we want the swap to liquidate from the redemption mint. Convert
+    // to raw token units at the cached redemption price to size the swap input.
+    const targetRedemptionTvlUsd = (targetSharesToBurn * tvlBefore) / totalShares;
+    const redemptionAmount = (0, common_1.tvlUsdToBaseUnits)(targetRedemptionTvlUsd, redemptionPrice, redemptionDecimals);
+    if (redemptionAmount > redemptionHoldingAmount) {
+        throw new errors_1.NoInterestToCollectError(`Redemption mint ${redemptionMint} holding (${redemptionHoldingAmount}) is insufficient ` +
+            `to cover yield redemption (${redemptionAmount}) — rebalance the yielding bank first`);
+    }
+    // Predict the handler's phase 6 derivation exactly (same integer-truncation
+    // order): first recompute the *actual* USD value the handler will see from
+    // the sized `redemptionAmount`, then apply the invariant formula
+    // `shares_to_burn = redemption_sold_tvl × total_shares_before / tvl_before`.
+    // The handler uses `total_shares / tvl` rather than `bank_scale /
+    // share_price` to avoid double truncation — mirror that here.
+    const sharesBurnedValueUsd = (0, common_1.calculateTvlUsd)(redemptionAmount, redemptionPrice, redemptionDecimals);
+    const sharesToBurn = (sharesBurnedValueUsd * totalShares) / tvlBefore;
+    if (sharesToBurn <= BigInt(0)) {
+        throw new errors_1.NoInterestToCollectError("Predicted shares to burn is zero — redemption amount rounds down below one share");
+    }
+    const holdingsToRedeem = [];
+    if (redemptionAmount > BigInt(0)) {
+        holdingsToRedeem.push({
+            mint: redemptionMint,
+            amount: (0, common_1.bnFromBigInt)(redemptionAmount),
+            isBaseAsset: redemptionMint === bank.baseMint,
+        });
+    }
+    return {
+        token,
+        yieldingBank: params.yieldingBank,
+        baseMint: bank.baseMint,
+        redemption: {
+            mint: redemptionMint,
+            tokenProgram: redemptionTokenProgram,
+            oracle: redemptionOracle,
+        },
+        collateral: {
+            mint: (0, common_1.fromWeb3Pk)(tokenData.data.collateral.mint),
+            tokenProgram: (0, common_1.resolveTokenProgram)(tokenData.data.collateral.tokenProgram),
+            oracle: (0, common_1.fromWeb3Pk)(tokenData.data.collateral.oracle),
+        },
+        carryIndex,
+        sharesToBurn: (0, common_1.bnFromBigInt)(sharesToBurn),
+        sharesBurnedValueUsd: (0, common_1.bnFromBigInt)(sharesBurnedValueUsd),
+        holdingsToRedeem,
+    };
+}

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

@@ -0,0 +1,12 @@
+import type { Address } from "@solana/kit";
+import { type SwapClient } from "common";
+import type { AccountClient } from "../account";
+import type { DecreaseCarryPositionBuilderParams, DecreaseCarryPositionPlan } from "../types";
+/**
+ * Build the execution plan for `decrease_carry_position`.
+ *
+ * LYC-specific concerns (permissionless operation handling, steering-based target
+ * resolution) live here. Sizing, repay CPI construction, and swap assembly are
+ * delegated to the generic {@link LeverageService} from `lending-platforms`.
+ */
+export declare function buildDecreaseCarryPositionPlan(account: AccountClient, swap: SwapClient, signer: Address, token: Address, params: DecreaseCarryPositionBuilderParams): Promise<DecreaseCarryPositionPlan>;

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

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildDecreaseCarryPositionPlan = buildDecreaseCarryPositionPlan;
+const common_1 = require("common");
+const lending_platforms_1 = require("lending-platforms");
+const carry_1 = require("../../services/carry");
+/**
+ * Build the execution plan for `decrease_carry_position`.
+ *
+ * LYC-specific concerns (permissionless operation handling, steering-based target
+ * resolution) live here. Sizing, repay CPI construction, and swap assembly are
+ * delegated to the generic {@link LeverageService} from `lending-platforms`.
+ */
+async function buildDecreaseCarryPositionPlan(account, swap, signer, token, params) {
+    const tokenData = await account.fetchToken(token);
+    const position = tokenData.data.lendingPositions[params.lendingPositionIndex];
+    const debtMint = (0, common_1.fromWeb3Pk)(position.accounting.debt.mint);
+    const initialAccounts = await account.getCarryTradeAccounts(token, params.yieldingBank, params.lendingPositionIndex);
+    if (params.permissionlessOperation && params.sourceMint !== undefined) {
+        throw new Error("DecreaseCarryPositionBuilderParams: sourceMint must not be set when permissionlessOperation is true");
+    }
+    params.lendingIx.clearCacheEntry(params.lendingIx.data.userAccountCatKey, (0, common_1.fromWeb3Pk)(position.protocolUserAcc));
+    const manager = await carry_1.LycLendingPositionManager.create(params.lendingIx.data, position, params.environment);
+    const { targetUtilizationBps, passTargetUtilizationOnChain } = await resolveRepaySteeringUtilization(manager, position, params.repaySteering);
+    const bank = await account.fetchYieldingBank(params.yieldingBank);
+    const { swapContext, sourceAssetHoldingIndex, needsSwapPath } = resolveSwapContext(swap, signer, params, bank, debtMint);
+    const { supplyReserve, debtReserve } = manager.reservesManager;
+    const positionState = await manager.getLendingPositionAmounts();
+    const txId = params.txId ?? `decrease-carry-${Date.now()}-${position.protocolUserAcc.toBase58()}`;
+    const isFullDeleverage = params.repaySteering?.mode === "explicitTargetUtilization" &&
+        params.repaySteering.targetUtilizationRateBps === 0;
+    const repayBaseUnitsOverride = isFullDeleverage
+        ? await resolveFullDeleverageRepayBaseUnits(params.lendingIx.data, position, debtReserve, manager)
+        : undefined;
+    const leverageResult = await lending_platforms_1.LeverageService.buildDecreaseLeverage({
+        lendingIx: params.lendingIx,
+        supplyReserve,
+        debtReserve,
+        user: token,
+        payer: signer,
+        pool: (0, common_1.fromWeb3Pk)(position.pool),
+        userAccount: (0, common_1.fromWeb3Pk)(position.protocolUserAcc),
+        txId,
+        environment: params.environment,
+    }, {
+        currentSupplyUiAmount: positionState.supplyUiAmount,
+        currentDebtUiAmount: positionState.debtUiAmount,
+        targetUtilizationRateBps: targetUtilizationBps,
+        swapContext,
+        repayBaseUnitsOverride,
+    });
+    return {
+        lendingPositionIndex: params.lendingPositionIndex,
+        repayAmount: leverageResult.repayBaseUnits,
+        preInstructions: leverageResult.preInstructions,
+        initialAccounts,
+        cpiDataGroups: leverageResult.cpiDataGroups,
+        ...(leverageResult.prerequisiteCpis.length
+            ? { tokenPrerequisiteCpis: leverageResult.prerequisiteCpis }
+            : {}),
+        ...(passTargetUtilizationOnChain ? { targetUtilizationRateBps: targetUtilizationBps } : {}),
+        yieldingBank: params.yieldingBank,
+        ...(needsSwapPath && sourceAssetHoldingIndex != null ? { sourceAssetHoldingIndex } : {}),
+    };
+}
+/**
+ * Sizes a full repay from the refreshed Kamino obligation borrow (+ buffer), not
+ * stale token accounting, so the SPL transfer and repay CPI stay in sync.
+ */
+async function resolveFullDeleverageRepayBaseUnits(lpData, position, debtReserve, manager) {
+    const pool = (0, common_1.fromWeb3Pk)(position.pool);
+    const userAccount = (0, common_1.fromWeb3Pk)(position.protocolUserAcc);
+    const obligation = await lpData.maybeFetchUserPositionInPool(pool, userAccount);
+    const borrow = obligation?.borrows.find((entry) => entry.reserve === debtReserve.address);
+    const fallbackUi = (await manager.getLendingPositionAmounts()).debtUiAmount;
+    const fallbackBaseUnits = (0, common_1.fromUiAmount)(fallbackUi, debtReserve.mint.mintDecimals);
+    if (!borrow) {
+        return fallbackBaseUnits;
+    }
+    // Kamino obligation debt can exceed stale token accounting by accrued interest
+    // (often 1 base unit on tiny positions). Size the SPL transfer and repay CPI
+    // from the refreshed obligation borrow, not the token snapshot alone.
+    return borrow.amount.gt(fallbackBaseUnits) ? borrow.amount : fallbackBaseUnits;
+}
+/**
+ * Resolves the utilization target (bps) for leverage sizing and whether that same
+ * bps should appear on-chain as `targetUtilizationRateBps` for manager post-repay checks.
+ */
+async function resolveRepaySteeringUtilization(manager, position, steering) {
+    if (!steering) {
+        return {
+            targetUtilizationBps: position.config.targetUtilizationRateBps,
+            passTargetUtilizationOnChain: false,
+        };
+    }
+    switch (steering.mode) {
+        case "collateralWithdrawal": {
+            const postWithdrawalTargetUtilizationRateBps = steering.postWithdrawalTargetUtilizationRateBps ?? position.config.targetUtilizationRateBps;
+            const targetUtilizationBps = await manager.calcPreWithdrawalTargetUtilizationRateBps(steering.collateralWithdrawalUiAmount, postWithdrawalTargetUtilizationRateBps);
+            return {
+                targetUtilizationBps,
+                passTargetUtilizationOnChain: steering.allowBelowTargetOnChain === true,
+            };
+        }
+        case "explicitTargetUtilization":
+            return {
+                targetUtilizationBps: steering.targetUtilizationRateBps,
+                passTargetUtilizationOnChain: true,
+            };
+        default: {
+            throw new Error(`Unexpected repaySteering: ${JSON.stringify(steering)}`);
+        }
+    }
+}
+/**
+ * Swap context when the yielding bank's source asset differs from the debt mint.
+ */
+function resolveSwapContext(swap, signer, params, bank, debtMint) {
+    const sourceMint = params.sourceMint ?? bank.defaultRedemptionMint;
+    const sourceAssetHoldingIndex = bank.findAssetHoldingIndex(sourceMint);
+    const needsSwapPath = sourceAssetHoldingIndex != null && sourceMint !== debtMint;
+    if (!needsSwapPath) {
+        return { swapContext: undefined, sourceAssetHoldingIndex, needsSwapPath };
+    }
+    const sourceHolding = bank.findAssetHolding(sourceMint);
+    return {
+        swapContext: {
+            swap,
+            sourceMint,
+            debtMint,
+            sourceBalanceBaseUnits: sourceHolding ? BigInt(sourceHolding.amount.toString()) : 0n,
+            swapTarget: params.yieldingBank,
+            payer: signer,
+            slippageBps: params.swapSlippageBps,
+            excludeDexes: params.swapExcludeDexes,
+        },
+        sourceAssetHoldingIndex,
+        needsSwapPath,
+    };
+}

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

@@ -0,0 +1,13 @@
+import type { Address } from "@solana/kit";
+import type { SwapClient } from "common";
+import type { CollectInterestExecutionPlan, CollectInterestPlan, CollectInterestRouteBuilderParams } from "../types";
+/**
+ * Convert a deterministic collect-interest plan into ordered CPI data.
+ * Venue selection and slippage policy live here.
+ *
+ * @param swapClient - Swap client used for all intermediate and final swaps.
+ * @param plan - Deterministic collect-interest plan returned by the planner layer.
+ * @param params - Optional routing policy such as output mint and slippage.
+ * @returns Executable collect-interest plan with ordered CPI data.
+ */
+export declare function buildCollectInterestRoutePlan(swapClient: SwapClient, plan: CollectInterestPlan, params?: CollectInterestRouteBuilderParams, payer?: Address): Promise<CollectInterestExecutionPlan>;

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCollectInterestRoutePlan = buildCollectInterestRoutePlan;
+const core_1 = require("@anchor-lang/core");
+const common_1 = require("common");
+const errors_1 = require("../../errors");
+/**
+ * Convert a deterministic collect-interest plan into ordered CPI data.
+ * Venue selection and slippage policy live here.
+ *
+ * @param swapClient - Swap client used for all intermediate and final swaps.
+ * @param plan - Deterministic collect-interest plan returned by the planner layer.
+ * @param params - Optional routing policy such as output mint and slippage.
+ * @returns Executable collect-interest plan with ordered CPI data.
+ */
+async function buildCollectInterestRoutePlan(swapClient, plan, params = {}, payer) {
+    const outputMint = params.outputMint ?? plan.collateral.mint;
+    const slippageBps = params.slippageBps ?? 100;
+    const cpiData = [];
+    const holding = plan.holdingsToRedeem[0];
+    if (!holding || holding.amount.lte(new core_1.BN(0))) {
+        throw new errors_1.NoInterestToCollectError("Expected positive redeemable yielding bank assets");
+    }
+    // Single swap: redemption mint → output mint (collateral or caller override).
+    const quote = await swapClient.getQuote({
+        inputMint: holding.mint,
+        outputMint,
+        amount: (0, common_1.toSafeNumber)(holding.amount, "collect_interest swap amount"),
+        slippageBps,
+    });
+    const swapCpi = await swapClient.getSwapCpiData(quote, plan.yieldingBank, payer ? { payer } : undefined);
+    cpiData.push(swapCpi);
+    return {
+        ...plan,
+        preInstructions: swapCpi.preInstructions ?? [],
+        initialAccounts: [],
+        cpiData,
+    };
+}

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

@@ -0,0 +1,41 @@
+import type { TransactionPlan as BaseTransactionPlan } from "common";
+import type { LongYieldCarryBuilderContext } from "./types/builders";
+import { BurnTokenBuilder, ClaimIncentivesBuilder, CollectFeesBuilder, CollectInterestBuilder, CreditUnlentToRedemptionEpochBuilder, CreateCpiPlanBuilder, CreateTokenBuilder, CreateTokenLendingPositionBuilder, CreateYieldingBankAllocationBuilder, CreateYieldingBankBuilder, DecreaseCarryPositionBuilder, DepositUnlentCollateralBuilder, IncreaseCarryPositionBuilder, MintTokenBuilder, RebalanceTokenBuilder, RebalanceYieldingBankBuilder, RecollateralizeLossBuilder, RefreshTokenStateBuilder, RefreshTokensBuilder, RefreshYieldingBankBuilder, ProcessAsyncBurnBuilder, ResetTokenBurnRateLimitBuilder, SetRedemptionEpochStatusBuilder, SetTokenCircuitBreakerBuilder, SetYieldingBankCircuitBreakerBuilder, UpdateLendingPositionConfigBuilder, UpdateTokenConfigurationBuilder, UpdateTokenMetadataBuilder, UpdateYieldingBankConfigBuilder, TopUpUnlentReservesBuilder } from "./builders";
+import type { LongYieldCarryTransactionPlan } from "./types";
+export * from "./builders";
+export declare class TransactionClient {
+    readonly context: LongYieldCarryBuilderContext;
+    readonly burnToken: BurnTokenBuilder;
+    readonly claimIncentives: ClaimIncentivesBuilder;
+    readonly collectFees: CollectFeesBuilder;
+    readonly collectInterest: CollectInterestBuilder;
+    readonly creditUnlentToRedemptionEpoch: CreditUnlentToRedemptionEpochBuilder;
+    readonly createCpiPlan: CreateCpiPlanBuilder;
+    readonly createToken: CreateTokenBuilder;
+    readonly createTokenLendingPosition: CreateTokenLendingPositionBuilder;
+    readonly createYieldingBank: CreateYieldingBankBuilder;
+    readonly createYieldingBankAllocation: CreateYieldingBankAllocationBuilder;
+    readonly decreaseCarryPosition: DecreaseCarryPositionBuilder;
+    readonly depositUnlentCollateral: DepositUnlentCollateralBuilder;
+    readonly increaseCarryPosition: IncreaseCarryPositionBuilder;
+    readonly mintToken: MintTokenBuilder;
+    readonly rebalanceToken: RebalanceTokenBuilder;
+    readonly rebalanceYieldingBank: RebalanceYieldingBankBuilder;
+    readonly recollateralizeLoss: RecollateralizeLossBuilder;
+    readonly refreshTokenState: RefreshTokenStateBuilder;
+    readonly refreshTokens: RefreshTokensBuilder;
+    readonly refreshYieldingBank: RefreshYieldingBankBuilder;
+    readonly processAsyncBurn: ProcessAsyncBurnBuilder;
+    readonly resetTokenBurnRateLimit: ResetTokenBurnRateLimitBuilder;
+    readonly setRedemptionEpochStatus: SetRedemptionEpochStatusBuilder;
+    readonly setTokenCircuitBreaker: SetTokenCircuitBreakerBuilder;
+    readonly setYieldingBankCircuitBreaker: SetYieldingBankCircuitBreakerBuilder;
+    readonly updateLendingPositionConfig: UpdateLendingPositionConfigBuilder;
+    readonly updateTokenConfiguration: UpdateTokenConfigurationBuilder;
+    readonly updateTokenMetadata: UpdateTokenMetadataBuilder;
+    readonly updateYieldingBankConfig: UpdateYieldingBankConfigBuilder;
+    readonly topUpUnlentReserves: TopUpUnlentReservesBuilder;
+    constructor(context: LongYieldCarryBuilderContext);
+}
+export type TransactionBuilder = TransactionClient[keyof TransactionClient];
+export type CompositeTransactionPlan = BaseTransactionPlan | LongYieldCarryTransactionPlan;

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

@@ -0,0 +1,55 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionClient = void 0;
+const builders_1 = require("./builders");
+__exportStar(require("./builders"), exports);
+class TransactionClient {
+    constructor(context) {
+        this.context = context;
+        this.burnToken = new builders_1.BurnTokenBuilder(context);
+        this.claimIncentives = new builders_1.ClaimIncentivesBuilder(context);
+        this.collectFees = new builders_1.CollectFeesBuilder(context);
+        this.collectInterest = new builders_1.CollectInterestBuilder(context);
+        this.creditUnlentToRedemptionEpoch = new builders_1.CreditUnlentToRedemptionEpochBuilder(context);
+        this.createCpiPlan = new builders_1.CreateCpiPlanBuilder(context);
+        this.createToken = new builders_1.CreateTokenBuilder(context);
+        this.createTokenLendingPosition = new builders_1.CreateTokenLendingPositionBuilder(context);
+        this.createYieldingBank = new builders_1.CreateYieldingBankBuilder(context);
+        this.createYieldingBankAllocation = new builders_1.CreateYieldingBankAllocationBuilder(context);
+        this.decreaseCarryPosition = new builders_1.DecreaseCarryPositionBuilder(context);
+        this.depositUnlentCollateral = new builders_1.DepositUnlentCollateralBuilder(context);
+        this.increaseCarryPosition = new builders_1.IncreaseCarryPositionBuilder(context);
+        this.mintToken = new builders_1.MintTokenBuilder(context);
+        this.rebalanceToken = new builders_1.RebalanceTokenBuilder(context);
+        this.rebalanceYieldingBank = new builders_1.RebalanceYieldingBankBuilder(context);
+        this.recollateralizeLoss = new builders_1.RecollateralizeLossBuilder(context);
+        this.refreshTokenState = new builders_1.RefreshTokenStateBuilder(context);
+        this.refreshTokens = new builders_1.RefreshTokensBuilder(context);
+        this.refreshYieldingBank = new builders_1.RefreshYieldingBankBuilder(context);
+        this.processAsyncBurn = new builders_1.ProcessAsyncBurnBuilder(context);
+        this.resetTokenBurnRateLimit = new builders_1.ResetTokenBurnRateLimitBuilder(context);
+        this.setRedemptionEpochStatus = new builders_1.SetRedemptionEpochStatusBuilder(context);
+        this.setTokenCircuitBreaker = new builders_1.SetTokenCircuitBreakerBuilder(context);
+        this.setYieldingBankCircuitBreaker = new builders_1.SetYieldingBankCircuitBreakerBuilder(context);
+        this.updateLendingPositionConfig = new builders_1.UpdateLendingPositionConfigBuilder(context);
+        this.updateTokenConfiguration = new builders_1.UpdateTokenConfigurationBuilder(context);
+        this.updateTokenMetadata = new builders_1.UpdateTokenMetadataBuilder(context);
+        this.updateYieldingBankConfig = new builders_1.UpdateYieldingBankConfigBuilder(context);
+        this.topUpUnlentReserves = new builders_1.TopUpUnlentReservesBuilder(context);
+    }
+}
+exports.TransactionClient = TransactionClient;

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

@@ -0,0 +1,18 @@
+import type { Program } from "@anchor-lang/core";
+import type { Rpc, SolanaRpcApi } from "@solana/kit";
+import type { Environment, SwapClient } from "common";
+import type { LongYieldCarry } from "../../idl/long_yield_carry";
+import type { AccountClient } from "../account";
+import type { LongYieldCarryExternalLiquidityResolver } from "../externalLiquidityResolver";
+import type { LendingPlatformClientRegistry } from "../lendingPlatformClients";
+import type { PdaClient } from "../pda";
+export interface LongYieldCarryBuilderContext {
+    rpc: Rpc<SolanaRpcApi>;
+    environment: Environment;
+    program: Program<LongYieldCarry>;
+    account: AccountClient;
+    pda: PdaClient;
+    swap: SwapClient;
+    externalLiquidityResolver: LongYieldCarryExternalLiquidityResolver;
+    lendingPlatformClients: LendingPlatformClientRegistry;
+}

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

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

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

@@ -0,0 +1,22 @@
+export type AnchorInterestDistribution = {
+    intoTokenPrice: {};
+} | {
+    intoWallets: {};
+};
+export declare enum InterestDistribution {
+    IntoTokenPrice = 0,
+    IntoWallets = 1
+}
+export declare function interestDistributionToEnum(v: AnchorInterestDistribution): InterestDistribution;
+export declare function enumToInterestDistribution(t: InterestDistribution): AnchorInterestDistribution;
+export type AnchorLendingType = {
+    lendingMarket: {};
+} | {
+    vault: {};
+};
+export declare enum LendingType {
+    LendingMarket = 0,
+    Vault = 1
+}
+export declare function lendingTypeToEnum(v: AnchorLendingType): LendingType;
+export declare function enumToLendingType(t: LendingType): AnchorLendingType;

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

@@ -0,0 +1,48 @@
+"use strict";
+// --- InterestDistribution ---
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LendingType = exports.InterestDistribution = void 0;
+exports.interestDistributionToEnum = interestDistributionToEnum;
+exports.enumToInterestDistribution = enumToInterestDistribution;
+exports.lendingTypeToEnum = lendingTypeToEnum;
+exports.enumToLendingType = enumToLendingType;
+var InterestDistribution;
+(function (InterestDistribution) {
+    InterestDistribution[InterestDistribution["IntoTokenPrice"] = 0] = "IntoTokenPrice";
+    InterestDistribution[InterestDistribution["IntoWallets"] = 1] = "IntoWallets";
+})(InterestDistribution || (exports.InterestDistribution = InterestDistribution = {}));
+function interestDistributionToEnum(v) {
+    if ("intoTokenPrice" in v)
+        return InterestDistribution.IntoTokenPrice;
+    if ("intoWallets" in v)
+        return InterestDistribution.IntoWallets;
+    throw new Error("Unknown InterestDistribution variant");
+}
+function enumToInterestDistribution(t) {
+    switch (t) {
+        case InterestDistribution.IntoTokenPrice:
+            return { intoTokenPrice: {} };
+        case InterestDistribution.IntoWallets:
+            return { intoWallets: {} };
+    }
+}
+var LendingType;
+(function (LendingType) {
+    LendingType[LendingType["LendingMarket"] = 0] = "LendingMarket";
+    LendingType[LendingType["Vault"] = 1] = "Vault";
+})(LendingType || (exports.LendingType = LendingType = {}));
+function lendingTypeToEnum(v) {
+    if ("lendingMarket" in v)
+        return LendingType.LendingMarket;
+    if ("vault" in v)
+        return LendingType.Vault;
+    throw new Error("Unknown LendingType variant");
+}
+function enumToLendingType(t) {
+    switch (t) {
+        case LendingType.LendingMarket:
+            return { lendingMarket: {} };
+        case LendingType.Vault:
+            return { vault: {} };
+    }
+}

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

@@ -0,0 +1,98 @@
+import { type BN } from "@anchor-lang/core";
+import { type Address } from "@solana/kit";
+import { type AnchorOracleType } from "common";
+import type { LYCToken } from "../../models/lycToken";
+/** Lightweight read-only snapshot of a `RedemptionEpoch` account. */
+export 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;
+}
+export 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.
+ */
+export interface PricedMint {
+    mint: Address;
+    tokenProgram: Address;
+    oracle: Address;
+}
+export 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;
+    /**
+     * Cap (in bps) on the annualized token-price growth contributed by the fee
+     * drip. `0` disables the cap (release limited only by the linear rate).
+     * Omit to default to 200 bps on test/prod or `0` on local.
+     */
+    feeDripMaxApyBps?: number;
+    /**
+     * Duration (in seconds) over which absorbed mint/burn fees release into the
+     * price. `0` parks fees until recollateralization consumes them.
+     * Omit to default to three days on test/prod or parked-buffer mode on local.
+     */
+    feeDripDurationSecs?: BN;
+}
+/** Base-unit breakdown of the accounting effects of a mint. */
+export interface MintAmounts {
+    tokensToUser: bigint;
+    protocolFee: bigint;
+    curatorFee: bigint;
+}
+/** Base-unit breakdown of the accounting effects of a burn. */
+export 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.
+ */
+export 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;
+}

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

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