@kestrelfi/lyc-sdk 1.0.1

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

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./env");
+const common_1 = require("common");
+const oracle_1 = require("oracle");
+const client_1 = require("../src/client/client");
+const general_1 = require("../src/constants/general");
+const data_1 = require("../src/utils/data");
+const localUtils_1 = require("./localUtils");
+/**
+ * Registers a new yielding bank for a base mint via `create_yielding_bank`.
+ *
+ * Usage (use `tsx` via pnpm below):
+ *   From this package: `pnpm run create-yielding-bank -- …`
+ *   From repo root:   `pnpm run lyc:create-yielding-bank -- …`
+ *
+ * Base mint defaults to USDC. Default redemption mint symbol defaults to USD* (mint registry).
+ * Admin keypair: {@link LYC_ADMIN_KEYPAIR_FP}[env].
+ */
+async function main() {
+    const { env, rest } = (0, localUtils_1.parseCliEnvironmentAndRest)("create-yielding-bank");
+    const { rest: args, keypairPath: keypairFlagPath } = (0, localUtils_1.extractKeypairFlag)(rest);
+    const baseSymbol = (args[0] ?? "USDC").toUpperCase();
+    const baseMint = common_1.mints.get(baseSymbol);
+    if (!baseMint) {
+        console.error(`Unknown base mint symbol "${baseSymbol}". Known symbols use the common mint registry.`);
+        process.exit(1);
+    }
+    const redemptionSymbol = (args[1] ?? "USD*").toUpperCase();
+    const redemptionMint = common_1.mints.get(redemptionSymbol);
+    if (!redemptionMint) {
+        console.error(`Unknown default redemption mint symbol "${redemptionSymbol}". Known symbols use the common mint registry.`);
+        process.exit(1);
+    }
+    const { signer: adminSigner, web3Keypair } = await (0, common_1.loadLocalKeypairWithWeb3)(keypairFlagPath ?? general_1.LYC_ADMIN_KEYPAIR_FP[env]);
+    const provider = (0, common_1.createDefaultAnchorProvider)(env, web3Keypair);
+    const client = new client_1.LongYieldCarryClient(provider, env);
+    const id = await (0, data_1.findFreeYieldingBankId)(client, baseMint.address);
+    const oracleData = oracle_1.oracle.getOracleData(baseSymbol);
+    const params = {
+        id,
+        oracleConfig: {
+            oracle: oracleData.oracle,
+            oracleType: (0, common_1.enumToOracleType)(oracleData.oracleType),
+        },
+        defaultRedemptionMint: redemptionMint.address,
+    };
+    const plan = await client.tx.createYieldingBank.getTx({
+        baseMint: baseMint.address,
+        params,
+        baseMintTokenProgram: baseMint.tokenProgram,
+    });
+    await client.sendTransaction(adminSigner, plan);
+    const [yieldingBankPda] = await client.pda.deriveYieldingBankPda(baseMint.address, id);
+    console.log("create_yielding_bank succeeded.");
+    console.log("  environment:", env);
+    console.log("  admin (must match on-chain):", general_1.PROTOCOL_ADMIN[env]);
+    console.log("  base mint:", baseMint.address, `(${baseSymbol})`);
+    console.log("  default redemption mint:", redemptionMint.address, `(${redemptionSymbol})`);
+    console.log("  yielding bank PDA:", yieldingBankPda);
+    console.log("  bank id (u8):", id);
+    console.log("  If you use lookup tables, run: pnpm run update-general-lut -- test|prod (and update-token-luts if needed)");
+}
+main()
+    .then(() => console.log("Finished"))
+    .catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

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

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

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

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./env");
+const common_1 = require("common");
+const client_1 = require("../src/client/client");
+const general_1 = require("../src/constants/general");
+const errors_1 = require("../src/errors");
+const lycLendingPositionManager_1 = require("../src/services/carry/lycLendingPositionManager");
+const lycData_1 = require("../src/utils/lycData");
+const localUtils_1 = require("./localUtils");
+const USAGE = `Decrease carry positions for eligible lending positions.
+
+Usage:
+  pnpm run decrease-carry -- [test|prod] [TOKEN_PDA|COLLATERAL_SYMBOL] [SLIPPAGE_BPS] [KEYPAIR_JSON]
+
+  TOKEN omitted: scan all tokens and report DCP-eligible positions without sending transactions.
+  TOKEN provided: refresh that token path, then execute DCP for eligible positions only.
+
+Examples:
+  pnpm run decrease-carry -- test
+  pnpm run decrease-carry -- test SOL
+  pnpm run decrease-carry -- test SOL 40 --keypair ~/.config/solana/operator.json`;
+async function main() {
+    const { env, rest } = (0, localUtils_1.parseCliEnvironmentAndRest)("decrease-carry");
+    const { rest: args, keypairPath: keypairFlagPath } = (0, localUtils_1.extractKeypairFlag)(rest);
+    const parsed = parseDecreaseCarryArgs(args, keypairFlagPath, env);
+    const { signer, web3Keypair } = await (0, common_1.loadLocalKeypairWithWeb3)(parsed.keypairPath);
+    const provider = (0, common_1.createDefaultAnchorProvider)(env, web3Keypair);
+    const client = new client_1.LongYieldCarryClient(provider, env);
+    console.log("Decrease carry position operator");
+    console.log("  environment:", env);
+    console.log("  signer:", signer.address);
+    console.log("  slippage:", parsed.swapSlippageBps ?? 40, "bps");
+    if (parsed.tokenArg === undefined) {
+        await scanAllTokens(client);
+        return;
+    }
+    const { tokenPda, collateralSymbol } = await (0, localUtils_1.resolveTokenPda)(client, parsed.tokenArg);
+    console.log("  token:", tokenPda, collateralSymbol ? `(${collateralSymbol})` : "");
+    await refreshTokenPath(client, signer, tokenPda);
+    client.clearAllCache();
+    const token = await client.account.fetchToken(tokenPda, { fresh: true });
+    await executeEligibleDcps(client, signer, token, parsed.swapSlippageBps);
+}
+function parseDecreaseCarryArgs(args, keypairFlagPath, env) {
+    if (args.length > 3) {
+        console.error(USAGE);
+        process.exit(1);
+    }
+    let swapSlippageBps;
+    let keypairPath = keypairFlagPath ?? general_1.LYC_MANAGER_KEYPAIR_FP[env];
+    if (args.length === 0) {
+        return { keypairPath };
+    }
+    const first = args[0];
+    if ((0, localUtils_1.isLikelyKeypairPath)(first)) {
+        if (args.length > 1) {
+            console.error(USAGE);
+            process.exit(1);
+        }
+        return { keypairPath: keypairFlagPath ?? first };
+    }
+    const tokenArg = first;
+    const second = args[1];
+    if (second !== undefined) {
+        if ((0, localUtils_1.isLikelyKeypairPath)(second)) {
+            keypairPath = keypairFlagPath ?? second;
+        }
+        else {
+            swapSlippageBps = parseSlippageBps(second);
+        }
+    }
+    const third = args[2];
+    if (third !== undefined) {
+        if (second !== undefined && (0, localUtils_1.isLikelyKeypairPath)(second)) {
+            console.error(USAGE);
+            process.exit(1);
+        }
+        keypairPath = keypairFlagPath ?? third;
+    }
+    return { tokenArg, swapSlippageBps, keypairPath };
+}
+function parseSlippageBps(raw) {
+    const value = parseInt(raw, 10);
+    if (!Number.isInteger(value) || value <= 0) {
+        console.error("SLIPPAGE_BPS must be a positive integer.");
+        process.exit(1);
+    }
+    return value;
+}
+async function scanAllTokens(client) {
+    const tokens = await client.account.fetchAllTokens({ fresh: true });
+    console.log(`\nScanning ${tokens.length} token(s) for DCP eligibility...`);
+    let eligibleTokens = 0;
+    let eligiblePositions = 0;
+    for (const [index, token] of tokens.entries()) {
+        const candidates = await collectEligibleDcpCandidates(client, token);
+        if (candidates.length === 0) {
+            console.log(`[${index + 1}/${tokens.length}] ${token.label} - no DCP needed`);
+            continue;
+        }
+        eligibleTokens++;
+        eligiblePositions += candidates.length;
+        console.log(`[${index + 1}/${tokens.length}] ${token.label} (${token.address}) needs DCP on ` +
+            `${candidates.length} position(s):`);
+        for (const candidate of candidates) {
+            logCandidate("  ", candidate);
+        }
+    }
+    console.log(`\nScan summary: ${eligibleTokens} token(s), ${eligiblePositions} position(s) need DCP`);
+}
+async function executeEligibleDcps(client, signer, token, swapSlippageBps) {
+    const candidates = await collectEligibleDcpCandidates(client, token);
+    if (candidates.length === 0) {
+        console.log(`\n${token.label} has no DCP-eligible lending positions. Skipping.`);
+        return;
+    }
+    let succeeded = 0;
+    let skipped = 0;
+    let failures = 0;
+    console.log(`\nExecuting DCP for ${candidates.length} eligible position(s)...`);
+    for (const candidate of candidates) {
+        const label = `${token.label} LP[${candidate.lendingPositionIndex}]`;
+        const freshCandidate = await refreshCandidate(client, token.address, candidate.lendingPositionIndex);
+        if (freshCandidate === undefined) {
+            skipped++;
+            console.log(`${label} - skipped: no longer DCP-eligible`);
+            continue;
+        }
+        logCandidate("", freshCandidate);
+        if (freshCandidate.yieldingBank === undefined) {
+            skipped++;
+            console.log(`${label} - skipped: ${freshCandidate.bankSelectionError ?? "no yielding bank"}`);
+            continue;
+        }
+        try {
+            const plan = await client.tx.decreaseCarryPosition.getTx({
+                signer: signer.address,
+                token: token.address,
+                params: {
+                    lendingPositionIndex: freshCandidate.lendingPositionIndex,
+                    yieldingBank: freshCandidate.yieldingBank,
+                    swapSlippageBps,
+                    permissionlessOperation: true,
+                },
+            });
+            const sig = await client.sendTransaction(signer, plan);
+            console.log(`${label} - decreased carry position (${sig})`);
+            succeeded++;
+            client.clearAllCache();
+        }
+        catch (err) {
+            if (err instanceof errors_1.NoOpTransactionError) {
+                skipped++;
+                console.log(`${label} - skipped: ${err.message}`);
+                continue;
+            }
+            failures++;
+            console.error(`${label} - failed: ${err.message}`);
+        }
+    }
+    console.log(`\nSummary: ${succeeded} succeeded, ${skipped} skipped, ${failures} failed`);
+    if (failures > 0) {
+        process.exit(1);
+    }
+}
+async function refreshCandidate(client, tokenAddress, lendingPositionIndex) {
+    const freshToken = await client.account.fetchToken(tokenAddress, { fresh: true });
+    const freshCandidates = await collectEligibleDcpCandidates(client, freshToken);
+    return freshCandidates.find((candidate) => candidate.lendingPositionIndex === lendingPositionIndex);
+}
+async function collectEligibleDcpCandidates(client, token) {
+    if (token.activeCarryPositions.length === 0) {
+        return [];
+    }
+    const candidates = [];
+    for (const { index, data: position } of token.usedLendingPositions) {
+        if (client.lendingPlatformClients.getPlatformForPosition(position) !== common_1.LendingPlatform.Kamino) {
+            continue;
+        }
+        const lpClient = client.getLendingPlatformClient(position);
+        const manager = await lycLendingPositionManager_1.LycLendingPositionManager.create(lpClient.data, position);
+        const shouldDecrease = await manager.shouldDecreaseCarryPosition();
+        if (!shouldDecrease) {
+            continue;
+        }
+        const debtChangeUiAmount = await manager.calcDebtChangeAmount();
+        const repayUiAmount = Math.abs(debtChangeUiAmount);
+        if (!(repayUiAmount > 0)) {
+            continue;
+        }
+        const rates = await manager.getUtilizationRatesBps();
+        const candidate = {
+            lendingPositionIndex: index,
+            position,
+            repayUiAmount,
+            utilizationRateBps: rates?.realtime,
+        };
+        try {
+            const { yieldingBank } = await (0, lycData_1.findBestYieldingBankForBurn)(client.account, token, position, repayUiAmount);
+            candidate.yieldingBank = yieldingBank;
+        }
+        catch (err) {
+            candidate.bankSelectionError = err.message;
+        }
+        candidates.push(candidate);
+    }
+    return candidates;
+}
+async function refreshTokenPath(client, signer, token) {
+    console.log("\nRefreshing token and yielding bank state...");
+    const refreshPlan = await client.tx.refreshTokens.getTx({
+        signer: signer.address,
+        params: {
+            tokens: [token],
+            alwaysRefreshYieldingBanks: true,
+        },
+    });
+    const sig = await client.sendTransaction(signer, refreshPlan);
+    console.log(`refresh succeeded (${sig})`);
+}
+function logCandidate(prefix, candidate) {
+    const debtMint = (0, common_1.fromWeb3Pk)(candidate.position.accounting.debt.mint);
+    const debtLabel = common_1.mints.get(debtMint)?.symbol ?? shortAddress(debtMint);
+    const utilization = candidate.utilizationRateBps === undefined
+        ? "unknown"
+        : `${formatBps(candidate.utilizationRateBps)}`;
+    const upperBound = candidate.position.config.targetUtilizationRateBps +
+        candidate.position.config.maxDeviationAboveTargetUtilBps;
+    const bank = candidate.yieldingBank ??
+        (candidate.bankSelectionError ? `unresolved (${candidate.bankSelectionError})` : "unresolved");
+    console.log(`${prefix}LP[${candidate.lendingPositionIndex}] debt=${debtLabel} ` +
+        `repay~${candidate.repayUiAmount.toFixed(6)} util=${utilization} ` +
+        `upper=${formatBps(upperBound)} yieldingBank=${bank}`);
+}
+function formatBps(bps) {
+    return `${(bps / 100).toFixed(2)}%`;
+}
+function shortAddress(value) {
+    return `${value.slice(0, 6)}...`;
+}
+main()
+    .then(() => console.log("Finished"))
+    .catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

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

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

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

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./env");
+const common_1 = require("common");
+const client_1 = require("../src/client/client");
+const lendingPosition_1 = require("../src/services/lendingPosition");
+const general_1 = require("../src/constants/general");
+const localUtils_1 = require("./localUtils");
+const USAGE = `Usage:
+
+  pnpm run deposit-unlent -- [test|prod] <TOKEN_PDA|COLLATERAL_SYMBOL> [DEBT_SYMBOL] [KEYPAIR_JSON]
+
+  Example: pnpm run deposit-unlent -- test SOL
+  Example: pnpm run deposit-unlent -- test SOL USDT
+
+  DEBT_SYMBOL: explicit debt mint, or omit to auto-select the optimal position.
+  KEYPAIR_JSON defaults to the manager keypair for the environment.`;
+/**
+ * Deposits all unlent collateral from a Token PDA into a lending position.
+ *
+ * When DEBT_SYMBOL is omitted, uses LendingPositionService to find the optimal
+ * position based on pair-adjusted APY. When provided explicitly, deposits into
+ * the position matching that debt mint.
+ */
+async function main() {
+    const { env, rest } = (0, localUtils_1.parseCliEnvironmentAndRest)("deposit-unlent");
+    const { rest: args, keypairPath: keypairFlagPath } = (0, localUtils_1.extractKeypairFlag)(rest);
+    const tokenArg = args[0];
+    if (tokenArg === undefined) {
+        console.error(USAGE);
+        process.exit(1);
+    }
+    const explicitDebtSymbol = args[1]?.toUpperCase();
+    const keypairPath = keypairFlagPath ?? args[2] ?? general_1.LYC_MANAGER_KEYPAIR_FP[env];
+    const { signer: managerSigner, web3Keypair } = await (0, common_1.loadLocalKeypairWithWeb3)(keypairPath);
+    const provider = (0, common_1.createDefaultAnchorProvider)(env, web3Keypair);
+    const client = new client_1.LongYieldCarryClient(provider, env);
+    const { tokenPda, collateralSymbol } = await (0, localUtils_1.resolveTokenPda)(client, tokenArg);
+    const tokenData = await client.account.fetchToken(tokenPda, { fresh: true });
+    console.log(`Token PDA: ${tokenPda} (collateral: ${collateralSymbol ?? "unknown"})`);
+    if (explicitDebtSymbol) {
+        const debtMintInfo = common_1.mints.get(explicitDebtSymbol);
+        if (!debtMintInfo) {
+            console.error(`Unknown debt mint symbol "${explicitDebtSymbol}". Known symbols use the common mint registry.`);
+            process.exit(1);
+        }
+        const lendingPositionIndex = tokenData.findLendingPositionByDebtMint(debtMintInfo.address);
+        if (lendingPositionIndex === -1) {
+            console.error(`No lending position found with debt ${explicitDebtSymbol}. ` +
+                `Create one first with: pnpm run create-lp -- ${env} ${tokenArg} <lowVol|highVol> ${explicitDebtSymbol}`);
+            process.exit(1);
+        }
+        console.log(`Using explicit LP[${lendingPositionIndex}] (debt: ${explicitDebtSymbol})`);
+        const refreshPlan = await client.tx.refreshTokens.getTx({
+            signer: managerSigner.address,
+            params: { tokens: [tokenPda] },
+        });
+        await client.sendTransaction(managerSigner, refreshPlan);
+        client.account.dataCache.clearAllCache();
+        const depositPlan = await client.tx.depositUnlentCollateral.getTx({
+            manager: managerSigner.address,
+            token: tokenPda,
+            params: { lendingPositionIndex, depositAll: true },
+        });
+        const sig = await client.sendTransaction(managerSigner, depositPlan);
+        console.log("deposit_unlent_collateral succeeded.");
+        console.log("  debt:", explicitDebtSymbol);
+        console.log("  lending position index:", lendingPositionIndex);
+        console.log("  signature:", sig);
+    }
+    else {
+        console.log("No debt symbol specified — finding optimal position...");
+        const lpService = new lendingPosition_1.LendingPositionService(client);
+        const result = await lpService.depositToOptimalPosition(managerSigner, tokenData, console.log);
+        console.log("deposit_unlent_collateral succeeded.");
+        console.log("  debt:", result.debtSymbol);
+        console.log("  lending position index:", result.lendingPositionIndex);
+        console.log("  signature:", result.signature);
+    }
+    console.log("  environment:", env);
+    console.log("  manager:", managerSigner.address);
+    console.log("  token PDA:", tokenPda);
+    console.log("  collateral:", collateralSymbol ?? tokenData.collateralMint);
+}
+main()
+    .then(() => console.log("Finished"))
+    .catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

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

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

package/dist/sdks/long-yield-carry/scripts/emergency/deleverageAll.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("../env");
+const common_1 = require("common");
+const client_1 = require("../../src/client/client");
+const general_1 = require("../../src/constants/general");
+const localUtils_1 = require("../localUtils");
+const USAGE = `Fully deleverage by repaying all debt via decrease_carry_position (targetUtilizationRateBps: 0).
+
+Requires the **manager** keypair because explicit target utilization is manager-gated.
+
+Usage:
+  pnpm run deleverage-all -- [test|prod] [TOKEN] [LP_INDEX|DEBT_SYMBOL] [KEYPAIR_JSON]
+  From repo root: pnpm run lyc:deleverage-all -- [test|prod] [TOKEN] [LP_INDEX|DEBT_SYMBOL] [KEYPAIR_JSON]
+
+  TOKEN omitted: deleverage all positions on all tokens.
+  TOKEN provided: deleverage all positions on that token (PDA or collateral symbol, e.g. SOL).
+  TOKEN + LP_INDEX or DEBT_SYMBOL: deleverage only that lending position.
+
+Examples:
+  pnpm run deleverage-all -- test
+  pnpm run deleverage-all -- test SOL
+  pnpm run deleverage-all -- test SOL USDC
+  pnpm run deleverage-all -- test SOL 0 --keypair ~/.config/solana/tp-lyc-manager-test.json
+
+Keypair defaults to ~/.config/solana/tp-lyc-manager-{env}.json`;
+async function main() {
+    const { env, rest } = (0, localUtils_1.parseCliEnvironmentAndRest)("deleverage-all");
+    const { rest: args, keypairPath: keypairFlagPath } = (0, localUtils_1.extractKeypairFlag)(rest);
+    const parsed = parseDeleverageArgs(args, keypairFlagPath, env);
+    const { signer, web3Keypair } = await (0, common_1.loadLocalKeypairWithWeb3)(parsed.keypairPath);
+    const provider = (0, common_1.createDefaultAnchorProvider)(env, web3Keypair);
+    const client = new client_1.LongYieldCarryClient(provider, env);
+    console.log("Deleveraging (zeroing out debt)...");
+    console.log("  environment:", env);
+    console.log("  signer:", signer.address);
+    let tokens;
+    let lendingPositionIndex;
+    if (parsed.tokenArg === undefined) {
+        tokens = await client.account.fetchAllTokens();
+        console.log("  scope: all tokens");
+        console.log("  tokens:", tokens.length);
+    }
+    else {
+        const { tokenPda, collateralSymbol } = await (0, localUtils_1.resolveTokenPda)(client, parsed.tokenArg);
+        tokens = [await client.account.fetchToken(tokenPda, { fresh: true })];
+        console.log("  scope: single token", tokenPda, collateralSymbol ? `(${collateralSymbol})` : "");
+        if (parsed.positionIdentifier !== undefined) {
+            lendingPositionIndex = (0, localUtils_1.resolveLendingPositionIndex)(tokens[0], parsed.positionIdentifier, tokenPda);
+            console.log("  lending position index:", lendingPositionIndex);
+        }
+    }
+    const totals = { failures: 0, skipped: 0, succeeded: 0 };
+    for (const [i, token] of tokens.entries()) {
+        const prefix = `[token ${i + 1}/${tokens.length}]`;
+        const counts = await deleverageToken(client, signer, token, {
+            lendingPositionIndex,
+            prefix,
+        });
+        totals.failures += counts.failures;
+        totals.skipped += counts.skipped;
+        totals.succeeded += counts.succeeded;
+        // Clear cached data after processing each token so subsequent tokens see
+        // fresh yielding bank balances (earlier unwinds may have drained liquidity).
+        client.clearAllCache();
+    }
+    console.log(`\nSummary: ${totals.succeeded} succeeded, ${totals.skipped} skipped, ${totals.failures} failed`);
+    if (totals.failures > 0) {
+        process.exit(1);
+    }
+}
+function parseDeleverageArgs(args, keypairFlagPath, env) {
+    if (args.length > 3) {
+        console.error(USAGE);
+        process.exit(1);
+    }
+    let keypairPath = keypairFlagPath ?? general_1.LYC_MANAGER_KEYPAIR_FP[env];
+    if (args.length === 0) {
+        return { keypairPath };
+    }
+    const first = args[0];
+    if ((0, localUtils_1.isLikelyKeypairPath)(first)) {
+        if (args.length > 1) {
+            console.error(USAGE);
+            process.exit(1);
+        }
+        return { keypairPath: keypairFlagPath ?? first };
+    }
+    const tokenArg = first;
+    let positionIdentifier;
+    const second = args[1];
+    if (second !== undefined) {
+        if ((0, localUtils_1.isLikelyKeypairPath)(second)) {
+            keypairPath = keypairFlagPath ?? second;
+        }
+        else {
+            positionIdentifier = second;
+        }
+    }
+    const third = args[2];
+    if (third !== undefined) {
+        if (second !== undefined && (0, localUtils_1.isLikelyKeypairPath)(second)) {
+            console.error(USAGE);
+            process.exit(1);
+        }
+        keypairPath = keypairFlagPath ?? third;
+    }
+    return { tokenArg, positionIdentifier, keypairPath };
+}
+async function deleverageToken(client, signer, token, options) {
+    const { lendingPositionIndex, prefix } = options;
+    const counts = { failures: 0, skipped: 0, succeeded: 0 };
+    const activeCarry = token.activeCarryPositions;
+    if (activeCarry.length === 0) {
+        console.log(`${prefix} ${token.address} — no active carry positions, skipping`);
+        counts.skipped++;
+        return counts;
+    }
+    const yieldingBanks = await resolveYieldingBanks(token, client);
+    const lendingPositions = token.activeLendingPositions.filter((lp) => lendingPositionIndex === undefined || lp.index === lendingPositionIndex);
+    if (lendingPositionIndex !== undefined && lendingPositions.length === 0) {
+        console.error(`${prefix} LP[${lendingPositionIndex}] — not an active lending position on ${token.address}`);
+        counts.failures++;
+        return counts;
+    }
+    for (const lp of lendingPositions) {
+        const debtAmount = (0, common_1.toBigInt)(lp.data.accounting.debt.amount);
+        if (debtAmount === BigInt(0)) {
+            console.log(`${prefix} LP[${lp.index}] — no outstanding debt, skipping`);
+            continue;
+        }
+        const debtMint = (0, common_1.fromWeb3Pk)(lp.data.accounting.debt.mint);
+        const debtLabel = common_1.mints.get(debtMint)?.symbol ?? debtMint;
+        const debtUi = (0, common_1.toUiAmount)(debtAmount, lp.data.accounting.debt.decimals);
+        console.log(`${prefix} LP[${lp.index}] debt=${debtLabel} — outstanding debt: ${debtUi} (raw: ${debtAmount})`);
+        if (yieldingBanks.length === 0) {
+            counts.failures++;
+            console.error(`${prefix} LP[${lp.index}] ✗ no yielding banks available — cannot deleverage`);
+            continue;
+        }
+        // Try each available yielding bank until one succeeds (the first may lack
+        // sufficient liquidity for the debt mint; a different bank may hold it).
+        let deleveraged = false;
+        for (const yieldingBank of yieldingBanks) {
+            try {
+                console.log(`${prefix} LP[${lp.index}] — refreshing before deleverage...`);
+                const refreshPlan = await client.tx.refreshTokens.getTx({
+                    signer: signer.address,
+                    params: { tokens: [token.address], alwaysRefreshYieldingBanks: true },
+                });
+                await client.sendTransaction(signer, refreshPlan);
+                client.clearAllCache();
+                const plan = await client.tx.decreaseCarryPosition.getTx({
+                    signer: signer.address,
+                    token: token.address,
+                    params: {
+                        lendingPositionIndex: lp.index,
+                        yieldingBank,
+                        repaySteering: {
+                            mode: "explicitTargetUtilization",
+                            targetUtilizationRateBps: 0,
+                        },
+                    },
+                });
+                const sig = await client.sendTransaction(signer, plan);
+                console.log(`${prefix} LP[${lp.index}] ✓ deleveraged via YB ${yieldingBank} (${sig})`);
+                deleveraged = true;
+                counts.succeeded++;
+                break;
+            }
+            catch (err) {
+                console.warn(`${prefix} LP[${lp.index}] — failed with YB ${yieldingBank}, trying next...`, err instanceof Error ? err.message : err);
+            }
+        }
+        if (!deleveraged) {
+            counts.failures++;
+            console.error(`${prefix} LP[${lp.index}] ✗ FAILED — exhausted all yielding banks for ${token.address}`);
+        }
+    }
+    return counts;
+}
+/**
+ * Derives unique yielding bank PDAs from a token's active carry positions.
+ */
+async function resolveYieldingBanks(token, client) {
+    const seen = new Set();
+    const banks = [];
+    for (const carry of token.activeCarryPositions) {
+        const bankPda = await token.deriveYieldingBankAddressForDebtCarryIndex(carry.index, client.pda);
+        if (!seen.has(bankPda)) {
+            seen.add(bankPda);
+            banks.push(bankPda);
+        }
+    }
+    return banks;
+}
+main()
+    .then(() => console.log("Finished"))
+    .catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

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

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