@kestrelfi/lyc-sdk 1.0.1

package/dist/sdks/long-yield-carry/scripts/inspect/format.js

@@ -0,0 +1,363 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatHeader = formatHeader;
+exports.formatFooter = formatFooter;
+exports.formatYieldingBankSnapshot = formatYieldingBankSnapshot;
+exports.formatTokenSnapshot = formatTokenSnapshot;
+exports.formatFeeWallet = formatFeeWallet;
+const common_1 = require("common");
+const DIVIDER = "─".repeat(72);
+const SECTION_DIVIDER = "  " + "·".repeat(68);
+const HEADER_DIVIDER = "=".repeat(72);
+const LABEL_WIDTH = 24;
+const DIM = "\x1b[2m";
+const BOLD = "\x1b[1m";
+const GREEN = "\x1b[32m";
+const RED = "\x1b[31m";
+const RESET = "\x1b[0m";
+function addr(a) {
+    return a.toString();
+}
+function bps(raw) {
+    return `${(raw / 100).toFixed(2)}%`;
+}
+function statusBadge(isActive) {
+    return isActive ? `${GREEN}${BOLD}ACTIVE${RESET}` : `${RED}${BOLD}CIRCUIT BREAKER${RESET}`;
+}
+function staleness(lastRefreshedTs) {
+    const ts = Number((0, common_1.toBigInt)(lastRefreshedTs));
+    if (ts === 0)
+        return "never";
+    const ageSecs = Math.floor(Date.now() / 1000) - ts;
+    if (ageSecs < 60)
+        return `${ageSecs}s ago`;
+    if (ageSecs < 3600)
+        return `${Math.floor(ageSecs / 60)}m ago`;
+    return `${Math.floor(ageSecs / 3600)}h ${Math.floor((ageSecs % 3600) / 60)}m ago`;
+}
+function firstMintLabel(ts) {
+    if (ts === 0n)
+        return "never";
+    return new Date(Number(ts) * 1000).toISOString() + `  ${dim(staleness(ts))}`;
+}
+function durationEstimate(seconds) {
+    if (seconds <= 0)
+        return "next refresh";
+    if (seconds < 3600)
+        return `~${Math.ceil(seconds / 60)}m`;
+    if (seconds < 86400)
+        return `~${(seconds / 3600).toFixed(1)}h`;
+    if (seconds < 365 * 86400)
+        return `~${(seconds / 86400).toFixed(1)} days`;
+    return `~${(seconds / (365 * 86400)).toFixed(1)} years`;
+}
+function feeAbsorptionEtaLabel(fees) {
+    switch (fees.absorptionStatus) {
+        case "estimated":
+            return fees.absorptionEtaSeconds == null
+                ? "unavailable"
+                : durationEstimate(fees.absorptionEtaSeconds);
+        case "no_fees":
+            return "none outstanding";
+        case "parked":
+            return "parked (drip disabled)";
+        case "apy_saturated":
+            return "no APY headroom at current rate";
+        default:
+            return "unavailable";
+    }
+}
+function timelockLabel(isTimelocked) {
+    if (isTimelocked) {
+        return "timelock: locked";
+    }
+    return "timelock: unlocked";
+}
+function platformLabel(platform) {
+    switch (platform) {
+        case common_1.LendingPlatform.Kamino:
+            return "Kamino";
+        case common_1.LendingPlatform.Marginfi:
+            return "Marginfi";
+        default:
+            return "None";
+    }
+}
+/** Dim secondary detail text so it doesn't compete with the primary numbers. */
+function dim(text) {
+    return `${DIM}${text}${RESET}`;
+}
+function bold(text) {
+    return `${BOLD}${text}${RESET}`;
+}
+function field(label, value, indent = 2) {
+    return `${" ".repeat(indent)}${`${label}:`.padEnd(LABEL_WIDTH)} ${value}`;
+}
+function section(label) {
+    return `  ${bold(label)}`;
+}
+function usdPriceUi(value) {
+    return ("$" + value.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 6 }));
+}
+function usdUi(value) {
+    return ("$" + value.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 }));
+}
+function formatTokenAmountUi(value, decimals) {
+    const ui = Number(value) / 10 ** decimals;
+    return ui.toLocaleString("en-US", { maximumFractionDigits: decimals });
+}
+function formatTriggerMove(trigger, currentUtilizationRateBps, triggerKind) {
+    if (!trigger) {
+        return "unavailable";
+    }
+    const modeLabel = trigger.priceMode === "ema" ? "EMA" : "RT";
+    if (currentUtilizationRateBps != null) {
+        const isAlreadyOutOfBounds = triggerKind === "increase"
+            ? currentUtilizationRateBps <= trigger.targetUtilizationRateBps
+            : currentUtilizationRateBps >= trigger.targetUtilizationRateBps;
+        if (isAlreadyOutOfBounds) {
+            return `awaiting ${triggerKind}  ${dim(`| ${modeLabel}`)}`;
+        }
+    }
+    const direction = trigger.priceChangePct < 0 ? "fall" : "rise";
+    const move = Math.abs(trigger.priceChangePct).toFixed(2) + "%";
+    const description = trigger.priceChangePct === 0
+        ? `at ${usdPriceUi(trigger.triggerCollateralPrice)} now`
+        : `${direction} ${move} to ${usdPriceUi(trigger.triggerCollateralPrice)}`;
+    return `${description}  ${dim(`| ${modeLabel}`)}`;
+}
+// ---------------------------------------------------------------------------
+// Header
+// ---------------------------------------------------------------------------
+function formatHeader(env, tokenCount, bankCount) {
+    return [
+        "",
+        HEADER_DIVIDER,
+        `  ${bold("LYC Inspect")}`,
+        field("Environment", env),
+        field("Snapshot", new Date().toISOString()),
+        field("Coverage", `${tokenCount} token(s) | ${bankCount} yielding bank(s)`),
+        HEADER_DIVIDER,
+    ].join("\n");
+}
+function formatFooter(totalTvlUsd) {
+    return ["", HEADER_DIVIDER, field("Total TVL", usdUi(totalTvlUsd)), HEADER_DIVIDER].join("\n");
+}
+// ---------------------------------------------------------------------------
+// Yielding Bank
+// ---------------------------------------------------------------------------
+function formatYieldingBankSnapshot(bank, allTokens) {
+    const lines = [""];
+    lines.push(`${bold("Yielding Bank")}  ${bank.baseSymbol}  ${statusBadge(bank.isActive)}`);
+    lines.push(DIVIDER);
+    lines.push(field("Address", addr(bank.address)));
+    lines.push(field("Curator", addr(bank.curator)));
+    lines.push(field("Base mint", bank.baseSymbol));
+    // -- Core accounting --
+    lines.push(field("TVL", usdUi(bank.tvlUsd)));
+    lines.push(field("Share decimals", bank.decimals.toString()));
+    lines.push(field("Share price", usdPriceUi(bank.sharePrice)));
+    lines.push(field("Total shares", bank.totalShares.toLocaleString("en-US")));
+    if (allTokens) {
+        const accountedRaw = allTokens
+            .flatMap((t) => t.carryPositions)
+            .filter((cp) => cp.yieldingBankAddress === bank.address)
+            .reduce((sum, cp) => sum + cp.sharesRaw, 0n);
+        const accountedUi = Number(accountedRaw) / 10 ** bank.decimals;
+        const diff = accountedUi - bank.totalShares;
+        const diffStr = diff === 0
+            ? `${GREEN}${BOLD}✓ exact${RESET}`
+            : `${RED}${BOLD}MISMATCH ${diff > 0 ? "+" : ""}${diff.toLocaleString("en-US")}${RESET}`;
+        lines.push(field("Shares accounted", `${accountedUi.toLocaleString("en-US")}  ${dim(`(${accountedRaw.toString()} raw)`)}  ${diffStr}`));
+    }
+    lines.push(field("Last refresh", staleness(bank.lastRefreshedTs)));
+    lines.push(field("Last rebalance", staleness(bank.lastRebalancedTs)));
+    lines.push(field("Timelock", timelockLabel(bank.isTimelocked)));
+    // -- Redemption mint --
+    if (bank.defaultRedemptionMint && bank.defaultRedemptionSymbol) {
+        lines.push(field("Redemption mint", `${bank.defaultRedemptionSymbol}  ${dim(`| ${addr(bank.defaultRedemptionMint)}`)}`));
+    }
+    // -- Asset holdings --
+    lines.push(SECTION_DIVIDER);
+    lines.push(section("Holdings"));
+    for (const holding of bank.holdings) {
+        lines.push(field(`[${holding.kind}] ${holding.symbol}`, `${holding.amountUi.toLocaleString("en-US", { maximumFractionDigits: holding.decimals })} ${holding.symbol}`, 4));
+        lines.push(field("Details", dim(`price: ${usdPriceUi(holding.priceUi)} | ${timelockLabel(holding.isTimelocked)}`), 4));
+    }
+    // -- External yielding positions --
+    for (const ext of bank.externalYieldingPositions) {
+        lines.push(SECTION_DIVIDER);
+        lines.push(section(`External ${platformLabel(ext.platform)}`));
+        lines.push(field("TVL", usdUi(ext.tvlUsd), 4));
+        lines.push(field("Pool", dim(addr(ext.pool)), 4));
+        lines.push(field("Timelock", dim(timelockLabel(ext.isTimelocked)), 4));
+    }
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// Token
+// ---------------------------------------------------------------------------
+function formatTokenSnapshot(token, enrichedBanks) {
+    const lines = [""];
+    const collSymbol = token.collateral.symbol;
+    const collDecimals = token.collateral.decimals;
+    lines.push(`${bold("Token")}  ${collSymbol}  ${statusBadge(token.isActive)}`);
+    lines.push(DIVIDER);
+    lines.push(field("Address", addr(token.address)));
+    lines.push(field("Curator", addr(token.curator)));
+    // -- Mint & config --
+    lines.push(field("Mint", `${addr(token.mint)}  ${dim(`| decimals: ${token.decimals}`)}`));
+    // -- Accounting --
+    lines.push(field("Price", `${token.price.toFixed(6)} ${collSymbol}`));
+    lines.push(field("Total supply", token.totalSupply.toLocaleString("en-US")));
+    lines.push(field("TVL", usdUi(token.tvlUsd)));
+    lines.push(field("Last refresh", staleness(token.lastRefreshedTs)));
+    lines.push(field("First mint", firstMintLabel(token.firstMintTs)));
+    // -- Collateral --
+    lines.push(SECTION_DIVIDER);
+    lines.push(section("Collateral"));
+    lines.push(field("Unlent", `${token.collateral.unlentAmountUi.toLocaleString("en-US", {
+        maximumFractionDigits: collDecimals,
+    })} ${collSymbol}`, 4));
+    lines.push(field("Pending unwind residual", `${token.collateral.pendingUnwindResidualUi.toLocaleString("en-US", {
+        maximumFractionDigits: collDecimals,
+    })} ${collSymbol}`, 4));
+    lines.push(field("Oracle price", `RT ${usdPriceUi(token.collateral.oraclePriceRealtimeUi)} | EMA ${usdPriceUi(token.collateral.oraclePriceEmaUi)}  ${dim(`| on-chain ${usdPriceUi(token.collateral.oraclePriceOnChainUi)}`)}`, 4));
+    lines.push(field("Collateral oracle", dim(addr(token.collateral.oracle)), 4));
+    lines.push(field("Secondary oracle", token.collateral.secondaryOracle ? dim(addr(token.collateral.secondaryOracle)) : "none", 4));
+    lines.push(field("Price refresh", staleness(token.collateral.lastRefreshedTs), 4));
+    // -- Lending positions --
+    for (const lp of token.lendingPositions) {
+        if (lp.collateralAmountUi === 0 && lp.debtAmountUi === 0)
+            continue;
+        const liveUtilizationRateBps = lp.inspectMetrics?.utilizationRateBps.realtime ?? lp.onChainUtilizationRateBps;
+        const emaUtilizationRateBps = lp.inspectMetrics?.utilizationRateBps.ema;
+        const positionHeadline = [
+            `Lending[${lp.index}]`,
+            `platform: ${platformLabel(lp.platform)}`,
+            `${lp.collateralSymbol}/${lp.debtSymbol}`,
+            lp.withdrawPending ? "WARN WITHDRAW PENDING" : undefined,
+        ]
+            .filter((part) => part !== undefined)
+            .join(" | ");
+        lines.push(SECTION_DIVIDER);
+        lines.push(section(positionHeadline));
+        const collateralUsd = lp.collateralAmountUi * token.collateral.oraclePriceRealtimeUi;
+        lines.push(field("Collateral", `${lp.collateralAmountUi.toLocaleString("en-US", {
+            maximumFractionDigits: lp.collateralDecimals,
+        })} ${lp.collateralSymbol}  ${dim(`(${usdUi(collateralUsd)})`)}`, 4));
+        lines.push(field("Debt", `${lp.debtAmountUi.toLocaleString("en-US", {
+            maximumFractionDigits: lp.debtDecimals,
+        })} ${lp.debtSymbol}  ${dim(`(${usdUi(lp.debtTvlUsd)})`)}`, 4));
+        lines.push(field("Debt price", usdPriceUi(lp.debtPriceUi), 4));
+        lines.push(field("Utilization", `${bps(liveUtilizationRateBps)} RT` +
+            (emaUtilizationRateBps != null ? ` | ${bps(emaUtilizationRateBps)} EMA` : "") +
+            ` | ${bps(lp.onChainUtilizationRateBps)} on-chain`, 4));
+        lines.push(field("Target band", dim(`target ${bps(lp.targetUtilizationRateBps)} | ` +
+            `-${bps(lp.maxDeviationBelowTargetUtilBps)} / +${bps(lp.maxDeviationAboveTargetUtilBps)}`), 4));
+        const increaseTriggerLine = formatTriggerMove(lp.inspectMetrics?.triggerBand.lower, emaUtilizationRateBps, "increase");
+        if (increaseTriggerLine) {
+            lines.push(field("Increase trigger", increaseTriggerLine, 4));
+        }
+        const decreaseTriggerLine = formatTriggerMove(lp.inspectMetrics?.triggerBand.upper, liveUtilizationRateBps, "decrease");
+        if (decreaseTriggerLine) {
+            lines.push(field("Decrease trigger", decreaseTriggerLine, 4));
+        }
+        lines.push(field("Last rebalance", staleness(lp.lastRebalancedTs), 4));
+        lines.push(field("Pool", dim(addr(lp.pool)), 4));
+        lines.push(field("User account", dim(addr(lp.userAccount)), 4));
+    }
+    // -- Carry positions --
+    for (const carry of token.carryPositions) {
+        if (carry.sharesRaw === 0n && carry.tvlUsd === 0)
+            continue;
+        lines.push(SECTION_DIVIDER);
+        const sharesUi = carry.sharesUi != null && carry.shareDecimals != null
+            ? carry.sharesUi.toLocaleString("en-US", { maximumFractionDigits: carry.shareDecimals })
+            : carry.sharesRaw.toString();
+        lines.push(section(`Carry #${carry.index} | bank ${carry.yieldingBankId} | ${carry.baseSymbol}`));
+        if (carry.yieldingBankAddress) {
+            lines.push(field("Bank address", dim(addr(carry.yieldingBankAddress)), 4));
+        }
+        lines.push(field("Shares", `${sharesUi}  ${dim(`(${carry.sharesRaw.toString()} raw)`)}`, 4));
+        lines.push(field("TVL", usdUi(carry.tvlUsd), 4));
+    }
+    if (token.carryPositions.length > 0) {
+        lines.push(SECTION_DIVIDER);
+        lines.push(section("Carry summary"));
+        lines.push(field("Total carry TVL", usdUi(token.carrySummary.totalCarryTvlUsd), 4));
+        lines.push(field("Total debt USD", usdUi(token.carrySummary.totalDebtUsd), 4));
+        lines.push(field("Net yield", usdUi(token.carrySummary.netYieldUsd), 4));
+        lines.push(field("Interest to collect", token.hasInterestToCollect
+            ? `${GREEN}yes${RESET}  ${dim(`(${usdUi(token.carrySummary.netYieldUsd)} collectable)`)}`
+            : dim("no"), 4));
+        for (const lp of token.lendingPositions) {
+            if (lp.debtAmountUi === 0)
+                continue;
+            lines.push(field(`Debt price [${lp.index}] ${lp.debtSymbol}`, usdPriceUi(lp.debtPriceUi), 4));
+        }
+        if (enrichedBanks) {
+            for (const carry of token.carryPositions) {
+                if (!carry.yieldingBankAddress)
+                    continue;
+                const bank = enrichedBanks.find((b) => b.address === carry.yieldingBankAddress);
+                if (!bank || bank.holdings.length === 0)
+                    continue;
+                const largest = bank.holdings.reduce((best, h) => (h.amountUi * h.priceUi > best.amountUi * best.priceUi ? h : best), bank.holdings[0]);
+                lines.push(field(`Bank[${carry.yieldingBankId}] top holding`, `${largest.symbol}  ${dim(`price: ${usdPriceUi(largest.priceUi)}`)}`, 4));
+            }
+        }
+    }
+    // -- Fees --
+    lines.push(SECTION_DIVIDER);
+    lines.push(section("Fees"));
+    lines.push(field("Minting", bps(token.fees.mintingFeeBps), 4));
+    lines.push(field("Burning", bps(token.fees.burningFeeBps), 4));
+    lines.push(field("Performance", bps(token.fees.performanceFeeBps), 4));
+    lines.push(field("Protocol mint/burn pct", bps(token.fees.protocolMintBurnPctBps), 4));
+    lines.push(field("Curator mint/burn pct", bps(token.fees.curatorMintBurnPctBps), 4));
+    lines.push(field("Holder mint/burn pct", bps(token.fees.holderMintBurnPctBps), 4));
+    lines.push(field("Curator perf pct", bps(token.fees.curatorPerfPctBps), 4));
+    lines.push(field("Fee drip max APY", bps(token.fees.feeDripMaxApyBps), 4));
+    lines.push(field("Current fee-window APY", token.fees.currentApyBps == null ? "unavailable" : bps(token.fees.currentApyBps), 4));
+    lines.push(field("Fee drip duration", `${(Number(token.fees.feeDripDurationSecs) / 86400).toLocaleString("en-US", {
+        maximumFractionDigits: 2,
+    })} days`, 4));
+    lines.push(field("Unabsorbed fee buffer", `${token.fees.undrippedFeeCollateralUi.toLocaleString("en-US", {
+        maximumFractionDigits: collDecimals,
+    })} ${collSymbol}  ${dim(`(${token.fees.undrippedFeeCollateralRaw.toString()} raw)`)}`, 4));
+    lines.push(field("Fee drip end", token.fees.dripEndTs === 0n
+        ? "none"
+        : new Date(Number(token.fees.dripEndTs) * 1000).toISOString(), 4));
+    lines.push(field("Fee absorption ETA", feeAbsorptionEtaLabel(token.fees), 4));
+    if (token.fees.pendingProtocolFeesRaw > 0n) {
+        lines.push(field("Pending protocol fees", `${token.fees.pendingProtocolFeesUi.toLocaleString("en-US")} yTokens`, 4));
+    }
+    if (token.fees.pendingCuratorFeesRaw > 0n) {
+        lines.push(field("Pending curator fees", `${token.fees.pendingCuratorFeesUi.toLocaleString("en-US")} yTokens`, 4));
+    }
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// Fee Wallet
+// ---------------------------------------------------------------------------
+function formatFeeWallet(wallet, balances) {
+    const lines = [""];
+    const nonZeroBalances = balances
+        .filter((balance) => balance.balance > 0n)
+        .sort((a, b) => a.symbol.localeCompare(b.symbol));
+    lines.push(bold("Fee Wallet"));
+    lines.push(DIVIDER);
+    lines.push(field("Address", addr(wallet)));
+    if (nonZeroBalances.length === 0) {
+        lines.push(field("Balances", "none"));
+    }
+    else {
+        lines.push(SECTION_DIVIDER);
+        lines.push(section("Balances"));
+        for (const balance of nonZeroBalances) {
+            lines.push(field(balance.symbol, `${formatTokenAmountUi(balance.balance, balance.decimals)} ${balance.symbol}`, 4));
+        }
+    }
+    return lines.join("\n");
+}

package/dist/sdks/long-yield-carry/scripts/inspect.d.ts

@@ -0,0 +1 @@
+import "./env";

package/dist/sdks/long-yield-carry/scripts/inspect.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./env");
+const web3_js_1 = require("@solana/web3.js");
+const token_1 = require("@solana-program/token");
+const kit_1 = require("@solana/kit");
+const common_1 = require("common");
+const client_1 = require("../src/client/client");
+const general_1 = require("../src/constants/general");
+const enrichment_1 = require("../src/utils/enrichment");
+const localUtils_1 = require("./localUtils");
+const format_1 = require("./inspect/format");
+/**
+ * CLI inspect tool — prints a human-readable summary of all on-chain LYC state.
+ *
+ * Usage:
+ *   pnpm run inspect -- test|prod [TOKEN_PDA|COLLATERAL_SYMBOL]
+ *
+ * From root:
+ *   pnpm lyc:inspect -- test [SOL]
+ *
+ * If a token argument is provided, only that token (and its associated yielding
+ * banks) are shown. Otherwise all tokens and banks are printed.
+ */
+async function main() {
+    const { env, rest } = (0, localUtils_1.parseCliEnvironmentAndRest)("inspect");
+    if (rest.length > 1) {
+        console.error("Usage: pnpm run inspect -- [test|prod] [TOKEN_PDA|COLLATERAL_SYMBOL]");
+        process.exit(1);
+    }
+    const provider = (0, common_1.createDefaultAnchorProvider)(env, web3_js_1.Keypair.generate());
+    const client = new client_1.LongYieldCarryClient(provider, env);
+    const rpc = (0, kit_1.createSolanaRpc)(provider.connection.rpcEndpoint);
+    let tokens;
+    let banks;
+    const tokenArg = rest[0];
+    if (tokenArg !== undefined) {
+        const resolved = await (0, localUtils_1.resolveTokenPda)(client, tokenArg);
+        tokens = [await client.account.fetchToken(resolved.tokenPda)];
+        banks = await client.account.fetchAllYieldingBanks();
+    }
+    else {
+        ({ tokens, yieldingBanks: banks } = await client.account.fetchAllTokensAndYieldingBanks());
+    }
+    const enrichedTokens = await Promise.all(tokens.map((token) => (0, enrichment_1.buildTokenInspectSnapshot)(token, {
+        environment: env,
+        mintRegistry: common_1.mints,
+        yieldingBanks: banks,
+        kaminoData: client.getLendingPlatformClientByPlatform(common_1.LendingPlatform.Kamino).data,
+    })));
+    const banksToPrint = tokenArg === undefined
+        ? banks
+        : filterBanksForTokens(banks, enrichedTokens.flatMap((t) => t.carryPositions));
+    const enrichedBanks = banksToPrint.map((bank) => (0, enrichment_1.buildYieldingBankInspectSnapshot)(bank, { environment: env, mintRegistry: common_1.mints }));
+    console.log((0, format_1.formatHeader)(env, tokens.length, banksToPrint.length));
+    for (const bank of enrichedBanks) {
+        console.log((0, format_1.formatYieldingBankSnapshot)(bank, enrichedTokens));
+    }
+    for (const token of enrichedTokens) {
+        console.log((0, format_1.formatTokenSnapshot)(token, enrichedBanks));
+    }
+    // -- Fee wallet balances --
+    const feeWallet = general_1.PROTOCOL_FEE_WALLET[env];
+    const feeBalances = [];
+    for (const token of tokens) {
+        const collMint = token.collateralMint;
+        const collSymbol = common_1.mints.get(collMint)?.symbol ?? collMint.toString().slice(0, 8);
+        const collDecimals = token.data.collateral.decimals;
+        const ata = await (0, common_1.getAtaAddress)(collMint, feeWallet);
+        const account = await (0, token_1.fetchMaybeToken)(rpc, ata);
+        const balance = account.exists ? account.data.amount : 0n;
+        feeBalances.push({ symbol: collSymbol, decimals: collDecimals, balance });
+        const yTokenAta = await (0, common_1.getAtaAddress)(token.mint, feeWallet);
+        const yTokenAccount = await (0, token_1.fetchMaybeToken)(rpc, yTokenAta);
+        const yTokenBalance = yTokenAccount.exists ? yTokenAccount.data.amount : 0n;
+        if (yTokenBalance > 0n) {
+            feeBalances.push({
+                symbol: `y${collSymbol}`,
+                decimals: token.decimals,
+                balance: yTokenBalance,
+            });
+        }
+    }
+    console.log((0, format_1.formatFeeWallet)(feeWallet, feeBalances));
+    const totalTvlUsd = enrichedTokens.reduce((sum, token) => sum + token.tvlUsd, 0);
+    console.log((0, format_1.formatFooter)(totalTvlUsd));
+}
+function filterBanksForTokens(banks, carryPositions) {
+    const bankAddresses = new Set(carryPositions
+        .map((carryPosition) => carryPosition.yieldingBankAddress)
+        .filter((address) => address !== undefined));
+    return banks.filter((bank) => bankAddresses.has(bank.address));
+}
+main().catch((err) => {
+    console.error("");
+    console.error("========================================================================");
+    console.error("Inspect failed");
+    if (err instanceof Error) {
+        console.error(err.message);
+        if (err.stack) {
+            console.error(err.stack);
+        }
+    }
+    else {
+        console.error(String(err));
+    }
+    process.exit(1);
+});

package/dist/sdks/long-yield-carry/scripts/localUtils.d.ts

@@ -0,0 +1,53 @@
+import "./env";
+import { type Address } from "@solana/kit";
+import { type DeployedEnv } from "common";
+import { LongYieldCarryClient } from "../src/client/client";
+import type { LYCToken } from "../src/models/lycToken";
+import { ASSET_PRESETS, VOLATILITY_REGIMES, isVolatilityRegime, resolvePresets, type AssetPresetEntry, type CarryVolatilityPresets, type VolatilityRegime } from "../src/constants/configs/carryTradePresets";
+/**
+ * Reads `test` | `prod` from argv. Strips pnpm’s `--` separator
+ * (`pnpm run … -- prod` → argv contains `--` then `prod`).
+ *
+ * Does not accept `local`; use integration tests or other tooling for Surfpool/local validator.
+ *
+ * If the first argument is omitted, uses `ENVIRONMENT` from `common`
+ * (`process.env.ENVIRONMENT` ?? `"local"`) — must be `test` or `prod`, not `local`.
+ *
+ * @param packageScriptName - npm script name for the usage line (e.g. `update-token-luts`)
+ */
+export declare function parseCliEnvironmentAndRest(packageScriptName: string): {
+    env: DeployedEnv;
+    rest: string[];
+};
+/**
+ * Same as {@link parseCliEnvironmentAndRest} but ignores positional args after the environment.
+ */
+export declare function parseCliEnvironment(packageScriptName: string): DeployedEnv;
+/** True when `s` looks like a filesystem path to a keypair (vs a token PDA/symbol). */
+export declare function isLikelyKeypairPath(s: string): boolean;
+export declare function extractKeypairFlag(rest: string[]): {
+    rest: string[];
+    keypairPath?: string;
+};
+/**
+ * Returns true if `s` decodes as a valid Ed25519 public key (use as Token PDA input).
+ * Short symbols like `SOL` are rejected by {@link PublicKey}.
+ */
+export declare function isValidPubkeyString(s: string): boolean;
+export interface ResolvedToken {
+    tokenPda: Address;
+    collateralSymbol?: string;
+    collateralDecimals: number;
+}
+/**
+ * Resolve a CLI token argument: either a Token PDA address, or a collateral
+ * mint symbol (e.g. SOL or SOL:0) by scanning on-chain Token accounts for one
+ * whose `collateral.mint` matches.
+ */
+export declare function resolveTokenPda(client: LongYieldCarryClient, arg: string): Promise<ResolvedToken>;
+/**
+ * Resolves a lending position by numeric index or debt mint symbol.
+ * Exits the process with a usage error when the position is invalid.
+ */
+export declare function resolveLendingPositionIndex(token: LYCToken, positionIdentifier: string, tokenPda: Address): number;
+export { ASSET_PRESETS, VOLATILITY_REGIMES, isVolatilityRegime, resolvePresets, type AssetPresetEntry, type CarryVolatilityPresets, type VolatilityRegime, };