@kestrelfi/lyc-sdk 1.0.1 → 1.0.3

package/dist/sdks/long-yield-carry/src/utils/lookupTables.js

@@ -1,216 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLookupTableForToken = getLookupTableForToken;
-exports.mergeLycLookupTables = mergeLycLookupTables;
-exports.updateTokenLutsIfNeeded = updateTokenLutsIfNeeded;
-exports.updateTokenLutIfNeeded = updateTokenLutIfNeeded;
-exports.updateGeneralLutIfNeeded = updateGeneralLutIfNeeded;
-const address_lookup_table_1 = require("@solana-program/address-lookup-table");
-const compute_budget_1 = require("@solana-program/compute-budget");
-const system_1 = require("@solana-program/system");
-const token_1 = require("@solana-program/token");
-const token_2022_1 = require("@solana-program/token-2022");
-const common_1 = require("common");
-const oracle_1 = require("oracle");
-const perena_helpers_1 = require("perena-helpers");
-const general_1 = require("../constants/general");
-const constants_1 = require("../constants");
-/**
- * Oracle account when {@link oracle} can resolve Pyth, Switchboard, or a custom feed.
- * Not exported — module-local helper (TypeScript has no `private` on file-level functions).
- */
-function tryOracleAddress(mint) {
-    try {
-        return oracle_1.oracle.getOracleData(mint).oracle;
-    }
-    catch {
-        return undefined;
-    }
-}
-/** Registry stablecoins + YBAs — used for yielding-bank ATA derivation. */
-const DEBT_AND_YBA_MINT_INFOS = [...common_1.mints.stablecoins(), ...common_1.mints.yieldBearingAssets()];
-/** Registry Standard + LST mints — risk / collateral-style assets (oracle-only on general LUT). */
-const RISK_ASSET_MINT_INFOS = [
-    ...common_1.mints.filterAssetsByType("Standard"),
-    ...common_1.mints.filterAssetsByType("LST"),
-];
-/**
- * Stablecoin + YBA mints with registry oracles for the general LUT.
- * Risk assets (Standard + LST registry entries): oracle only — mints stay on each token's LUT via on-chain collateral.
- * Not exported — module-local helper.
- */
-function getMintRegistryAccountsForGeneralLut() {
-    const out = [];
-    for (const m of DEBT_AND_YBA_MINT_INFOS) {
-        out.push(m.address);
-        const o = tryOracleAddress(m.address);
-        if (o) {
-            out.push(o);
-        }
-    }
-    for (const m of RISK_ASSET_MINT_INFOS) {
-        const o = tryOracleAddress(m.address);
-        if (o) {
-            out.push(o);
-        }
-    }
-    return out;
-}
-/**
- * Every YieldingBank PDA plus, for each bank, the ATA for each registry stablecoin and YBA mint.
- * Not exported — module-local helper.
- */
-async function getYieldingBankAccountsForGeneralLut(client) {
-    const banks = await client.account.fetchAllYieldingBanks();
-    const out = [];
-    for (const b of banks) {
-        out.push(b.address);
-        for (const m of DEBT_AND_YBA_MINT_INFOS) {
-            out.push(await (0, common_1.getAtaAddress)(m.address, b.address, m.tokenProgram));
-        }
-    }
-    return out;
-}
-/**
- * Get the specific lookup table for the given Token PDA (if it exists).
- *
- * `TOKEN_LOOKUP_TABLES` is keyed by Token PDA address.
- */
-function getLookupTableForToken(tokenPda) {
-    if (tokenPda in constants_1.TOKEN_LOOKUP_TABLES) {
-        return constants_1.TOKEN_LOOKUP_TABLES[tokenPda];
-    }
-}
-/**
- * Assembles lookup table addresses for LYC transaction plans: the deployment
- * general LUT (when not `local`), any registered per-token LUT for the given
- * token PDAs, then any CPI/swap tables. Entries are omitted when missing or
- * equal to the default (unused) public key; duplicates are removed in first-seen
- * order.
- */
-function mergeLycLookupTables(environment, tokenPda, existingLookupTables) {
-    const all = [];
-    if (environment !== "local") {
-        all.push(general_1.GENERAL_LOOKUP_TABLES[environment]);
-    }
-    if (tokenPda !== undefined) {
-        for (const t of Array.isArray(tokenPda) ? tokenPda : [tokenPda]) {
-            all.push(getLookupTableForToken(t));
-        }
-    }
-    if (existingLookupTables) {
-        all.push(...existingLookupTables);
-    }
-    const valid = all.filter((a) => a !== undefined && a !== common_1.DEFAULT_PUBLIC_KEY);
-    return [...new Set(valid)];
-}
-/**
- * Refresh per-token lookup tables for every Token account owned by the program.
- *
- * @param client - Initialized client (provides RPC-backed account fetch and Kamino helpers).
- */
-async function updateTokenLutsIfNeeded(signer, rpc, client) {
-    const tokens = await client.account.fetchAllTokens();
-    for (const t of tokens) {
-        await updateTokenLutIfNeeded(signer, rpc, client, t);
-    }
-}
-/**
- * Extend the per-token lookup table with addresses needed for that token's
- * instructions: mints, token/YB ATAs, registry debt-mint ATAs for the token PDA, lending protocol accounts, Kamino
- * obligation ATAs when applicable. Lending reserve accounts live on the
- * lending-platform LUT; price oracles for registry-listed debt/YBAs and risk
- * assets live on the general LUT.
- *
- * Collateral mint is read from on-chain token state (it is not a PDA).
- *
- * @param client - Used for Kamino reserve metadata and reserve interaction ATAs.
- * @param token - Fetched token model (`LYCToken`); avoids an extra fetch.
- */
-async function updateTokenLutIfNeeded(signer, rpc, client, token) {
-    const kaminoClient = client.getLendingPlatformClientByPlatform(common_1.LendingPlatform.Kamino);
-    const allAccounts = [];
-    const tokenPda = token.address;
-    const yMint = token.mint;
-    const collateralMint = token.collateralMint;
-    const collateralTp = (0, common_1.resolveTokenProgram)(token.data.collateral.tokenProgram);
-    const yTokenTp = (0, common_1.resolveTokenProgram)(token.data.config.tokenProgram);
-    allAccounts.push(tokenPda, yMint, collateralMint);
-    allAccounts.push(await (0, common_1.getAtaAddress)(collateralMint, tokenPda, collateralTp), await (0, common_1.getAtaAddress)(yMint, tokenPda, yTokenTp));
-    for (const m of common_1.mints.stablecoins()) {
-        allAccounts.push(await (0, common_1.getAtaAddress)(m.address, tokenPda, m.tokenProgram));
-    }
-    for (const position of token.data.lendingPositions) {
-        const platform = (0, common_1.lendingPlatformToEnum)(position.platform);
-        if (platform === common_1.LendingPlatform.None) {
-            continue;
-        }
-        allAccounts.push((0, common_1.fromWeb3Pk)(position.protocolUserAcc));
-        const debtMint = (0, common_1.fromWeb3Pk)(position.accounting.debt.mint);
-        const debtTp = (0, common_1.resolveTokenProgram)(position.accounting.debt.tokenProgram);
-        allAccounts.push(await (0, common_1.getAtaAddress)(debtMint, tokenPda, debtTp));
-        if (platform === common_1.LendingPlatform.Kamino) {
-            const pool = (0, common_1.fromWeb3Pk)(position.pool);
-            const userAcc = (0, common_1.fromWeb3Pk)(position.protocolUserAcc);
-            for (const reserve of [
-                (0, common_1.fromWeb3Pk)(position.collateralReserve),
-                (0, common_1.fromWeb3Pk)(position.debtReserve),
-            ]) {
-                const details = await kaminoClient.accounts.reserveInteractionDetails(tokenPda, pool, reserve, userAcc);
-                allAccounts.push(details.userLiquidityTa.address, details.userCollateralTa.address, userAcc);
-                const userFarmAddresses = await kaminoClient.accounts.getUserFarmAddresses(pool, reserve, userAcc);
-                allAccounts.push(...userFarmAddresses);
-            }
-        }
-    }
-    console.log("Updating token LUT for token:", tokenPda);
-    common_1.lutManager.clearCache();
-    await common_1.lutManager.updateLookupTable(signer, rpc, allAccounts, getLookupTableForToken(tokenPda));
-}
-/**
- * Extend the shared general lookup table: program IDs, well-known SPL programs,
- * stablecoin and YBA mints (plus registry oracles), Standard + LST oracle accounts,
- * Perena program id, every on-chain YieldingBank PDA, each bank’s ATAs for
- * all registry debt mints (stablecoins) and yield-bearing assets, the canonical
- * Jito tip accounts (referenced by every Jito-bundle tip ix), the ComputeBudget
- * program (referenced by every CU-limit ix), and the deployment's role wallets:
- * manager, protocol admin, circuit-breaker controller, and protocol fee wallet.
- *
- * Risk asset (Standard + LST) mints are omitted here; they appear on each token LUT
- * as collateral.
- *
- * Uses {@link GENERAL_LOOKUP_TABLES} for {@link LongYieldCarryClient.environment}
- * (`test` | `prod` only) and only that tier’s program ID.
- *
- * @throws If `client.environment` is `local` — there is no pinned general LUT for local.
- */
-async function updateGeneralLutIfNeeded(signer, rpc, client) {
-    const deployedEnv = client.environment;
-    if (deployedEnv === "local") {
-        throw new Error("updateGeneralLutIfNeeded requires LongYieldCarryClient built with test or prod; local has no GENERAL_LOOKUP_TABLES entry.");
-    }
-    const registryAccounts = getMintRegistryAccountsForGeneralLut();
-    const yieldingBankAccounts = await getYieldingBankAccountsForGeneralLut(client);
-    const perenaAccounts = await (0, perena_helpers_1.getGeneralLookupTableAccountsForPerena)(new perena_helpers_1.PerenaClient((0, common_1.getRpcUrl)(deployedEnv)));
-    const allAccounts = [
-        general_1.PROGRAM_ID[deployedEnv],
-        system_1.SYSTEM_PROGRAM_ADDRESS,
-        token_1.TOKEN_PROGRAM_ADDRESS,
-        token_1.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
-        token_2022_1.TOKEN_2022_PROGRAM_ADDRESS,
-        compute_budget_1.COMPUTE_BUDGET_PROGRAM_ADDRESS,
-        common_1.DEFAULT_PUBLIC_KEY,
-        address_lookup_table_1.ADDRESS_LOOKUP_TABLE_PROGRAM_ADDRESS,
-        perena_helpers_1.PERENA_PROGRAM_ID,
-        general_1.MANAGER[deployedEnv],
-        general_1.PROTOCOL_ADMIN[deployedEnv],
-        general_1.CIRCUIT_BREAKER_CONTROLLER[deployedEnv],
-        general_1.PROTOCOL_FEE_WALLET[deployedEnv],
-        ...common_1.JITO_TIP_ACCOUNTS,
-        ...registryAccounts,
-        ...perenaAccounts,
-        ...yieldingBankAccounts,
-    ];
-    common_1.lutManager.clearCache();
-    return common_1.lutManager.updateLookupTable(signer, rpc, (0, common_1.dedupeOrderedAddresses)(allAccounts), general_1.GENERAL_LOOKUP_TABLES[deployedEnv]);
-}

package/dist/sdks/long-yield-carry/src/utils/lycData.d.ts

@@ -1,66 +0,0 @@
-/**
- * Pure helpers over decoded long_yield_carry account data (`Token`, `YieldingBank`, etc.):
- * selection logic, liquidity / holding analysis, and other algorithms that do not belong on
- * `AccountClient` or transaction composers.
- */
-import type { Address } from "@solana/kit";
-import { BN } from "@anchor-lang/core";
-import type { AccountClient } from "../client/account";
-import type { LYCToken, TokenLendingPositionData } from "../models/lycToken";
-import type { BurnAmounts } from "../client/types/general";
-import type { LendingPlatformClientBase, LendingPlatformData } from "lending-platforms";
-/** Any object that can resolve a lending-platform client for a given position. */
-export interface LendingPlatformResolver {
-    getForPosition(position: TokenLendingPositionData): LendingPlatformClientBase<LendingPlatformData>;
-}
-export declare function getBurnCollateralWithdrawalAmount(tokenData: LYCToken, burnAmount: BN | number): bigint;
-export declare function getBurnCollateralWithdrawalUiAmount(tokenData: LYCToken, burnAmount: BN | number, includeOneUnitTolerance?: boolean): number;
-export declare function computeBurnAmountsForFrontendEstimate(_account: AccountClient, tokenData: LYCToken, burnAmount: BN | number, _resolver: LendingPlatformResolver): Promise<BurnAmounts>;
-/**
- * True when at least one active lending position can supply the collateral implied by `burnAmount`
- * for a liquidity-managed burn (same eligibility filter as {@link findPositionToUnwindForBurn}).
- */
-export declare function hasLendingPositionCoveringBurn(tokenData: LYCToken, burnAmount: BN | number, resolver: LendingPlatformResolver): Promise<boolean>;
-/**
- * True when the best burn-candidate lending position can absorb a collateral
- * withdrawal for `burnAmount` without pushing the LTV utilization rate above
- * the position's upper deviation band — meaning no `decrease_carry_position`
- * (debt repayment) is required.
- *
- * Should only be called after {@link hasLendingPositionCoveringBurn} returns
- * `true`; uses the same candidate selection logic as
- * {@link findPositionToUnwindForBurn}.
- */
-export declare function isWithdrawOnlyBurnFeasible(tokenData: LYCToken, burnAmount: BN | number, resolver: LendingPlatformResolver): Promise<boolean>;
-/**
- * Chooses which `lendingPositions` slot to unwind for a burn liquidity-managed tx.
- *
- * Considers only active positions with a supported platform and collateral mint
- * matching the token. Filters to positions that can cover `collateralWithdrawalUiAmount`
- * (same strict less-than full-supply rule as pre-withdraw repay sizing). Among those,
- * picks the position with the most deposited collateral (tie → lower index) so the
- * burn unwind comes out of the deepest slot and small positions are left intact.
- *
- * @param getLendingPlatformClient - Resolves the Kamino (etc.) client for a position;
- *   kept injectable so callers are not tied to transaction wiring.
- */
-export declare function findPositionToUnwindForBurn(tokenData: LYCToken, collateralWithdrawalUiAmount: number, resolver: LendingPlatformResolver): Promise<{
-    lendingPositionIndex: number;
-    position: TokenLendingPositionData;
-}>;
-/**
- * Picks the yielding bank to fund repay/swap during a burn liquidity-managed tx.
- *
- * Enumerates banks derived from active `debtCarry` entries on the token, fetches
- * each account via `account.fetchYieldingBanks`, then:
- * 1. Prefer a bank whose **debt mint** holding is at least `requiredDebtUiAmount` (debt token UI)
- *    and is largest among those sufficient balances (headroom for the unwind repay).
- * 2. Otherwise prefer the bank whose **default redemption mint** holding has the largest
- *    balance in UI units (`toUiAmount` with the holding's on-chain `decimals`).
- *
- * Permissionless burn planning does not pass `sourceMint`; the default-redemption fallback
- * assumes that path is viable for the chosen bank's holdings.
- */
-export declare function findBestYieldingBankForBurn(account: AccountClient, tokenData: LYCToken, position: TokenLendingPositionData, requiredDebtUiAmount: number): Promise<{
-    yieldingBank: Address;
-}>;

package/dist/sdks/long-yield-carry/src/utils/lycData.js

@@ -1,211 +0,0 @@
-"use strict";
-/**
- * Pure helpers over decoded long_yield_carry account data (`Token`, `YieldingBank`, etc.):
- * selection logic, liquidity / holding analysis, and other algorithms that do not belong on
- * `AccountClient` or transaction composers.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBurnCollateralWithdrawalAmount = getBurnCollateralWithdrawalAmount;
-exports.getBurnCollateralWithdrawalUiAmount = getBurnCollateralWithdrawalUiAmount;
-exports.computeBurnAmountsForFrontendEstimate = computeBurnAmountsForFrontendEstimate;
-exports.hasLendingPositionCoveringBurn = hasLendingPositionCoveringBurn;
-exports.isWithdrawOnlyBurnFeasible = isWithdrawOnlyBurnFeasible;
-exports.findPositionToUnwindForBurn = findPositionToUnwindForBurn;
-exports.findBestYieldingBankForBurn = findBestYieldingBankForBurn;
-const web3_js_1 = require("@solana/web3.js");
-const common_1 = require("common");
-const carry_1 = require("../services/carry");
-function getBurnCollateralWithdrawalAmount(tokenData, burnAmount) {
-    const { collateralToUser } = tokenData.computeBurnAmounts(burnAmount);
-    const unlentAmount = BigInt(tokenData.data.collateral.unlentAmount.toString());
-    const reserved = BigInt(tokenData.data.accounting.pendingAsyncRedemptionLiability.toString());
-    const available = unlentAmount > reserved ? unlentAmount - reserved : BigInt(0);
-    return collateralToUser > available ? collateralToUser - available : BigInt(0);
-}
-function getBurnCollateralWithdrawalUiAmount(tokenData, burnAmount, includeOneUnitTolerance = false) {
-    const withdrawalAmount = getBurnCollateralWithdrawalAmount(tokenData, burnAmount);
-    const adjustedWithdrawalAmount = includeOneUnitTolerance && withdrawalAmount > BigInt(0)
-        ? withdrawalAmount + BigInt(1)
-        : withdrawalAmount;
-    return (0, common_1.toUiAmount)(adjustedWithdrawalAmount, tokenData.data.collateral.decimals);
-}
-async function computeBurnAmountsForFrontendEstimate(_account, tokenData, burnAmount, _resolver) {
-    // TODO: For frontend redemption estimates, account for expected
-    // default-redemption swap slippage/fee.
-    return tokenData.computeBurnAmounts(burnAmount);
-}
-async function collectBurnUnwindCandidates(tokenData, collateralWithdrawalUiAmount, resolver) {
-    const candidates = [];
-    for (let i = 0; i < tokenData.data.lendingPositions.length; i++) {
-        const position = tokenData.data.lendingPositions[i];
-        if ((0, common_1.lendingPlatformToEnum)(position.platform) === common_1.LendingPlatform.None) {
-            continue;
-        }
-        const lpClient = resolver.getForPosition(position);
-        const manager = await carry_1.LycLendingPositionManager.create(lpClient.data, position);
-        const eligibility = await manager.getBurnUnwindEligibility(collateralWithdrawalUiAmount);
-        if (!eligibility) {
-            continue;
-        }
-        candidates.push({
-            lendingPositionIndex: i,
-            position,
-            collateralAmount: BigInt(position.accounting.collateral.toString()),
-        });
-    }
-    return candidates;
-}
-/**
- * True when at least one active lending position can supply the collateral implied by `burnAmount`
- * for a liquidity-managed burn (same eligibility filter as {@link findPositionToUnwindForBurn}).
- */
-async function hasLendingPositionCoveringBurn(tokenData, burnAmount, resolver) {
-    const collateralWithdrawalUiAmount = getBurnCollateralWithdrawalUiAmount(tokenData, burnAmount, true);
-    const candidates = await collectBurnUnwindCandidates(tokenData, collateralWithdrawalUiAmount, resolver);
-    return candidates.length > 0;
-}
-/**
- * True when the best burn-candidate lending position can absorb a collateral
- * withdrawal for `burnAmount` without pushing the LTV utilization rate above
- * the position's upper deviation band — meaning no `decrease_carry_position`
- * (debt repayment) is required.
- *
- * Should only be called after {@link hasLendingPositionCoveringBurn} returns
- * `true`; uses the same candidate selection logic as
- * {@link findPositionToUnwindForBurn}.
- */
-async function isWithdrawOnlyBurnFeasible(tokenData, burnAmount, resolver) {
-    const collateralWithdrawalUiAmount = getBurnCollateralWithdrawalUiAmount(tokenData, burnAmount, true);
-    let position;
-    try {
-        ({ position } = await findPositionToUnwindForBurn(tokenData, collateralWithdrawalUiAmount, resolver));
-    }
-    catch {
-        return false;
-    }
-    const lpClient = resolver.getForPosition(position);
-    const manager = await carry_1.LycLendingPositionManager.create(lpClient.data, position);
-    const postWithdrawalUtilBps = await manager.calcPostWithdrawalUtilizationRateBps(collateralWithdrawalUiAmount);
-    const upperBound = position.config.targetUtilizationRateBps + position.config.maxDeviationAboveTargetUtilBps;
-    return postWithdrawalUtilBps <= upperBound;
-}
-/**
- * Chooses which `lendingPositions` slot to unwind for a burn liquidity-managed tx.
- *
- * Considers only active positions with a supported platform and collateral mint
- * matching the token. Filters to positions that can cover `collateralWithdrawalUiAmount`
- * (same strict less-than full-supply rule as pre-withdraw repay sizing). Among those,
- * picks the position with the most deposited collateral (tie → lower index) so the
- * burn unwind comes out of the deepest slot and small positions are left intact.
- *
- * @param getLendingPlatformClient - Resolves the Kamino (etc.) client for a position;
- *   kept injectable so callers are not tied to transaction wiring.
- */
-async function findPositionToUnwindForBurn(tokenData, collateralWithdrawalUiAmount, resolver) {
-    const candidates = await collectBurnUnwindCandidates(tokenData, collateralWithdrawalUiAmount, resolver);
-    if (!candidates.length) {
-        // Fallback: the withdrawal would fully drain the position (supply <=
-        // withdrawal amount), so the eligibility filter excluded it. Pick the
-        // largest active position instead — the SDK will pass the "all" sentinel.
-        const fallback = findLargestActiveLendingPosition(tokenData);
-        if (fallback) {
-            return fallback;
-        }
-        throw new Error("No lending position can cover this burn collateral withdrawal with the token collateral mint (or platform is unsupported)");
-    }
-    candidates.sort((a, b) => {
-        if (a.collateralAmount === b.collateralAmount) {
-            return a.lendingPositionIndex - b.lendingPositionIndex;
-        }
-        return b.collateralAmount > a.collateralAmount ? 1 : -1;
-    });
-    const best = candidates[0];
-    return { lendingPositionIndex: best.lendingPositionIndex, position: best.position };
-}
-/**
- * Finds the largest active (non-None platform) lending position by collateral
- * amount. Used as a fallback when the standard eligibility filter excludes all
- * positions (e.g. when the withdrawal fully drains the position).
- */
-function findLargestActiveLendingPosition(tokenData) {
-    let best = null;
-    let bestCollateral = BigInt(0);
-    for (let i = 0; i < tokenData.data.lendingPositions.length; i++) {
-        const position = tokenData.data.lendingPositions[i];
-        if ((0, common_1.lendingPlatformToEnum)(position.platform) === common_1.LendingPlatform.None) {
-            continue;
-        }
-        const collateral = BigInt(position.accounting.collateral.toString());
-        if (collateral > bestCollateral) {
-            bestCollateral = collateral;
-            best = { lendingPositionIndex: i, position };
-        }
-    }
-    return best;
-}
-/**
- * Picks the yielding bank to fund repay/swap during a burn liquidity-managed tx.
- *
- * Enumerates banks derived from active `debtCarry` entries on the token, fetches
- * each account via `account.fetchYieldingBanks`, then:
- * 1. Prefer a bank whose **debt mint** holding is at least `requiredDebtUiAmount` (debt token UI)
- *    and is largest among those sufficient balances (headroom for the unwind repay).
- * 2. Otherwise prefer the bank whose **default redemption mint** holding has the largest
- *    balance in UI units (`toUiAmount` with the holding's on-chain `decimals`).
- *
- * Permissionless burn planning does not pass `sourceMint`; the default-redemption fallback
- * assumes that path is viable for the chosen bank's holdings.
- */
-async function findBestYieldingBankForBurn(account, tokenData, position, requiredDebtUiAmount) {
-    const bankAddresses = [];
-    const seen = new Set();
-    for (let i = 0; i < tokenData.data.debtCarry.length; i++) {
-        const carry = tokenData.data.debtCarry[i];
-        if (carry.yieldingBaseMint.equals(web3_js_1.PublicKey.default)) {
-            continue;
-        }
-        const bankPda = await tokenData.deriveYieldingBankAddressForDebtCarryIndex(i, account.pda);
-        const key = String(bankPda);
-        if (seen.has(key)) {
-            continue;
-        }
-        seen.add(key);
-        bankAddresses.push(bankPda);
-    }
-    if (bankAddresses.length === 0) {
-        throw new Error("Token has no active yielding carry positions; cannot select a yielding bank for burn liquidity management");
-    }
-    const banks = await account.fetchYieldingBanks(bankAddresses);
-    const debtMint = (0, common_1.fromWeb3Pk)(position.accounting.debt.mint);
-    const sufficientDebt = [];
-    for (const bank of banks) {
-        const holding = bank.findAssetHolding(debtMint);
-        if (!holding) {
-            continue;
-        }
-        const debtHeldUi = (0, common_1.toUiAmount)(holding.amount, holding.decimals);
-        if (debtHeldUi >= requiredDebtUiAmount) {
-            sufficientDebt.push({ bank, debtHeldUi });
-        }
-    }
-    if (sufficientDebt.length > 0) {
-        const best = (0, common_1.maxByNumber)(sufficientDebt, (x) => x.debtHeldUi);
-        return { yieldingBank: best.bank.address };
-    }
-    const defaultMintUi = [];
-    for (const bank of banks) {
-        const holding = bank.findAssetHolding(bank.defaultRedemptionMint);
-        if (!holding) {
-            continue;
-        }
-        defaultMintUi.push({
-            bank,
-            defaultMintUiAmount: (0, common_1.toUiAmount)(holding.amount, holding.decimals),
-        });
-    }
-    if (defaultMintUi.length > 0) {
-        const best = (0, common_1.maxByNumber)(defaultMintUi, (x) => x.defaultMintUiAmount);
-        return { yieldingBank: best.bank.address };
-    }
-    throw new Error("No yielding bank linked to this token has sufficient debt liquidity for unwind or an active default redemption holding");
-}

package/dist/sdks/long-yield-carry/src/utils/timelock.d.ts

@@ -1,19 +0,0 @@
-import { BN } from "@anchor-lang/core";
-import { type Environment } from "common";
-export type TimelockKind = "touch" | "cleanup";
-export interface TimelockStatus {
-    enabled: boolean;
-    isTimelocked: boolean;
-    timeCreated: bigint;
-    unlockAt?: bigint;
-    remainingSecs: bigint;
-}
-export interface TimelockOptions {
-    enableLocalTimelocks?: boolean;
-}
-export declare function timelocksEnabled(environment: Environment, options?: TimelockOptions): boolean;
-export declare function getTimelockStatus(environment: Environment, timeCreated: bigint | number | BN, kind: TimelockKind, options?: TimelockOptions): TimelockStatus;
-export type AllocationTimelockKind = TimelockKind;
-export type AllocationTimelockStatus = TimelockStatus;
-export declare const allocationTimelocksEnabled: typeof timelocksEnabled;
-export declare const getAllocationTimelockStatus: typeof getTimelockStatus;

package/dist/sdks/long-yield-carry/src/utils/timelock.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAllocationTimelockStatus = exports.allocationTimelocksEnabled = void 0;
-exports.timelocksEnabled = timelocksEnabled;
-exports.getTimelockStatus = getTimelockStatus;
-const common_1 = require("common");
-const TIMELOCK_COOLDOWN_SECS = {
-    touch: 12n * 60n * 60n,
-    cleanup: 24n * 60n * 60n,
-};
-function timelocksEnabled(environment, options = {}) {
-    return (environment === "prod" || (environment === "local" && options.enableLocalTimelocks === true));
-}
-function getTimelockStatus(environment, timeCreated, kind, options = {}) {
-    const createdAt = (0, common_1.toBigInt)(timeCreated);
-    const enabled = timelocksEnabled(environment, options);
-    if (!enabled || createdAt === 0n) {
-        return {
-            enabled,
-            isTimelocked: false,
-            timeCreated: createdAt,
-            remainingSecs: 0n,
-        };
-    }
-    const unlockAt = createdAt + TIMELOCK_COOLDOWN_SECS[kind];
-    const now = BigInt(Math.floor(Date.now() / 1000));
-    const remainingSecs = unlockAt > now ? unlockAt - now : 0n;
-    return {
-        enabled,
-        isTimelocked: remainingSecs > 0n,
-        timeCreated: createdAt,
-        unlockAt,
-        remainingSecs,
-    };
-}
-exports.allocationTimelocksEnabled = timelocksEnabled;
-exports.getAllocationTimelockStatus = getTimelockStatus;

package/dist/sdks/long-yield-carry/src/utils/tokenFeeMath.d.ts

@@ -1,11 +0,0 @@
-/**
- * Collectable net yield in 8-decimal normalized USD: any carry surplus above
- * debt. Returns `0n` when carry TVL does not exceed debt TVL.
- *
- * Used by SDK planning and metrics to size collect-interest attempts.
- *
- * @param totalCarryTvlUsd Aggregate carry-position TVL (8-dec USD).
- * @param totalDebtUsd Aggregate lending-position debt TVL (8-dec USD).
- */
-export declare function collectableNetYieldUsd(totalCarryTvlUsd: bigint, totalDebtUsd: bigint): bigint;
-export declare function splitFeeProportionally(totalFee: bigint, protocolBps: bigint, curatorBps: bigint): [bigint, bigint];

package/dist/sdks/long-yield-carry/src/utils/tokenFeeMath.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.collectableNetYieldUsd = collectableNetYieldUsd;
-exports.splitFeeProportionally = splitFeeProportionally;
-/**
- * Collectable net yield in 8-decimal normalized USD: any carry surplus above
- * debt. Returns `0n` when carry TVL does not exceed debt TVL.
- *
- * Used by SDK planning and metrics to size collect-interest attempts.
- *
- * @param totalCarryTvlUsd Aggregate carry-position TVL (8-dec USD).
- * @param totalDebtUsd Aggregate lending-position debt TVL (8-dec USD).
- */
-function collectableNetYieldUsd(totalCarryTvlUsd, totalDebtUsd) {
-    return totalCarryTvlUsd > totalDebtUsd ? totalCarryTvlUsd - totalDebtUsd : 0n;
-}
-function splitFeeProportionally(totalFee, protocolBps, curatorBps) {
-    const splitBps = protocolBps + curatorBps;
-    if (splitBps === 0n)
-        return [totalFee, 0n];
-    const curatorFee = (totalFee * curatorBps) / splitBps;
-    const protocolFee = totalFee - curatorFee;
-    return [protocolFee, curatorFee];
-}

package/dist/sdks/long-yield-carry/src/utils/transactions.d.ts

@@ -1,20 +0,0 @@
-import { type Address, type KeyPairSigner, type Signature } from "@solana/kit";
-import type { LongYieldCarryClient } from "../client/client";
-import type { LongYieldCarryTransactionPlan } from "../client/types";
-/**
- * Compose ordered phases into one bundle-ready plan without making an entire
- * phase indivisible. Existing atomic segments are preserved, and each phase
- * after the first is forced to start in a new transaction.
- */
-export declare function composePhasedTransactionPlan(phases: LongYieldCarryTransactionPlan[]): LongYieldCarryTransactionPlan;
-export declare function setTokenCircuitBreaker(client: LongYieldCarryClient, signer: KeyPairSigner, token: Address, active: boolean): Promise<Signature>;
-export declare function setYieldingBankCircuitBreaker(client: LongYieldCarryClient, signer: KeyPairSigner, yieldingBank: Address, active: boolean): Promise<Signature>;
-/**
- * Creates a new yToken SPL mint with mint authority = token PDA, using the next free token ID.
- */
-export declare function createYTokenMint(client: LongYieldCarryClient, payer: KeyPairSigner, decimals?: number, tokenProgram?: Address): Promise<{
-    mintSigner: KeyPairSigner;
-    tokenPda: Address;
-    tokenPdaBump: number;
-    id: number;
-}>;