@kestrelfi/lyc-sdk 1.0.1

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

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePresets = exports.isVolatilityRegime = exports.VOLATILITY_REGIMES = exports.ASSET_PRESETS = void 0;
+exports.parseCliEnvironmentAndRest = parseCliEnvironmentAndRest;
+exports.parseCliEnvironment = parseCliEnvironment;
+exports.isLikelyKeypairPath = isLikelyKeypairPath;
+exports.extractKeypairFlag = extractKeypairFlag;
+exports.isValidPubkeyString = isValidPubkeyString;
+exports.resolveTokenPda = resolveTokenPda;
+exports.resolveLendingPositionIndex = resolveLendingPositionIndex;
+require("./env");
+const kit_1 = require("@solana/kit");
+const web3_js_1 = require("@solana/web3.js");
+const common_1 = require("common");
+const carryTradePresets_1 = require("../src/constants/configs/carryTradePresets");
+Object.defineProperty(exports, "ASSET_PRESETS", { enumerable: true, get: function () { return carryTradePresets_1.ASSET_PRESETS; } });
+Object.defineProperty(exports, "VOLATILITY_REGIMES", { enumerable: true, get: function () { return carryTradePresets_1.VOLATILITY_REGIMES; } });
+Object.defineProperty(exports, "isVolatilityRegime", { enumerable: true, get: function () { return carryTradePresets_1.isVolatilityRegime; } });
+Object.defineProperty(exports, "resolvePresets", { enumerable: true, get: function () { return carryTradePresets_1.resolvePresets; } });
+function deployedEnvOrExit(packageScriptName, env) {
+    if (env === "local") {
+        console.error(`Usage: pnpm run ${packageScriptName} -- test|prod\n` +
+            `(ENVIRONMENT is "local" or you passed "local"; this entrypoint only targets deployed test/prod.)`);
+        process.exit(1);
+    }
+    return env;
+}
+/**
+ * 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`)
+ */
+function parseCliEnvironmentAndRest(packageScriptName) {
+    const args = process.argv.slice(2).filter((a) => a !== "--");
+    const arg = args[0];
+    if (arg === "test" || arg === "prod") {
+        return { env: arg, rest: args.slice(1) };
+    }
+    if (arg === "local") {
+        console.error(`Usage: pnpm run ${packageScriptName} -- [test|prod] [extra-args...]\n` +
+            `("local" is not supported; use integration tests for local validator workflows.)`);
+        process.exit(1);
+    }
+    return { env: deployedEnvOrExit(packageScriptName, common_1.ENVIRONMENT), rest: args };
+}
+/**
+ * Same as {@link parseCliEnvironmentAndRest} but ignores positional args after the environment.
+ */
+function parseCliEnvironment(packageScriptName) {
+    return parseCliEnvironmentAndRest(packageScriptName).env;
+}
+// =============================================================================
+// CLI argument helpers
+// =============================================================================
+/** True when `s` looks like a filesystem path to a keypair (vs a token PDA/symbol). */
+function isLikelyKeypairPath(s) {
+    const t = s.trim();
+    return t.endsWith(".json") || t.includes("/") || t.startsWith("~");
+}
+function extractKeypairFlag(rest) {
+    const filtered = [];
+    let keypairPath;
+    for (let i = 0; i < rest.length; i += 1) {
+        const arg = rest[i];
+        if (arg === "--keypair" || arg === "-k") {
+            keypairPath = rest[i + 1];
+            if (!keypairPath || keypairPath.startsWith("--")) {
+                console.error(`${arg} requires a path argument.`);
+                process.exit(1);
+            }
+            i += 1;
+        }
+        else if (arg.startsWith("--keypair=")) {
+            keypairPath = arg.slice("--keypair=".length);
+            if (!keypairPath) {
+                console.error("--keypair requires a path argument.");
+                process.exit(1);
+            }
+        }
+        else {
+            filtered.push(arg);
+        }
+    }
+    return { rest: filtered, keypairPath };
+}
+// =============================================================================
+// Token PDA resolution
+// =============================================================================
+/**
+ * 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}.
+ */
+function isValidPubkeyString(s) {
+    try {
+        new web3_js_1.PublicKey(s);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 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.
+ */
+async function resolveTokenPda(client, arg) {
+    const trimmed = arg.trim();
+    if (isValidPubkeyString(trimmed)) {
+        const tokenPda = (0, kit_1.address)(trimmed);
+        const lyct = await client.account.fetchToken(tokenPda);
+        return {
+            tokenPda,
+            collateralSymbol: common_1.mints.get(lyct.collateralMint)?.symbol,
+            collateralDecimals: lyct.data.collateral.decimals,
+        };
+    }
+    const parsedSymbol = parseCollateralSymbolSelector(trimmed);
+    const symbol = parsedSymbol.symbol;
+    const tokenId = parsedSymbol.tokenId;
+    const collateralInfo = common_1.mints.get(symbol);
+    if (!collateralInfo) {
+        console.error(`Unknown mint identifier "${symbol}". Use a registry symbol (e.g. SOL, SOL:0) or pass the Token PDA base58 address.`);
+        process.exit(1);
+    }
+    const tokens = await client.account.fetchAllTokens();
+    const want = collateralInfo.address;
+    const matches = tokens.filter((t) => t.collateralMint === want && (tokenId === undefined || t.id === tokenId));
+    if (matches.length === 0) {
+        const idSuffix = tokenId === undefined ? "" : ` and token id ${tokenId}`;
+        console.error(`No Token account found with collateral mint ${want} (${symbol})${idSuffix}.`);
+        process.exit(1);
+    }
+    if (matches.length > 1) {
+        console.error(`Multiple Tokens use collateral ${symbol} (${want}). Pass SYMBOL:ID or the Token PDA explicitly:\n` +
+            matches.map((t) => `  ${symbol}:${t.id}  ${t.address}`).join("\n"));
+        process.exit(1);
+    }
+    const t = matches[0];
+    return {
+        tokenPda: t.address,
+        collateralSymbol: symbol,
+        collateralDecimals: t.data.collateral.decimals,
+    };
+}
+function parseCollateralSymbolSelector(arg) {
+    const match = arg.match(/^([A-Za-z0-9]+)(?::|#)(\d+)$/);
+    if (!match) {
+        return { symbol: arg.toUpperCase() };
+    }
+    const tokenId = Number(match[2]);
+    if (!Number.isInteger(tokenId) || tokenId < 0 || tokenId > 255) {
+        console.error(`Invalid token id "${match[2]}" in "${arg}". Token id must be a u8 (0-255).`);
+        process.exit(1);
+    }
+    return { symbol: match[1].toUpperCase(), tokenId };
+}
+/**
+ * Resolves a lending position by numeric index or debt mint symbol.
+ * Exits the process with a usage error when the position is invalid.
+ */
+function resolveLendingPositionIndex(token, positionIdentifier, tokenPda) {
+    const parsedIndex = parseInt(positionIdentifier, 10);
+    if (Number.isFinite(parsedIndex) && parsedIndex >= 0) {
+        const positions = token.data.lendingPositions;
+        if (parsedIndex >= positions.length || "none" in positions[parsedIndex].platform) {
+            console.error(`Lending position ${parsedIndex} is inactive or out of bounds ` +
+                `(token has ${positions.length} slots).`);
+            process.exit(1);
+        }
+        return parsedIndex;
+    }
+    const debtSymbol = positionIdentifier.toUpperCase();
+    const debtMintInfo = common_1.mints.get(debtSymbol);
+    if (!debtMintInfo) {
+        console.error(`Unknown debt mint symbol "${debtSymbol}". Known symbols use the common mint registry.`);
+        process.exit(1);
+    }
+    const lendingPositionIndex = token.findLendingPositionByDebtMint(debtMintInfo.address);
+    if (lendingPositionIndex === -1) {
+        console.error(`No active lending position found with debt ${debtSymbol} (${debtMintInfo.address}) on token ${tokenPda}.`);
+        process.exit(1);
+    }
+    return lendingPositionIndex;
+}

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

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

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

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./env");
+const core_1 = require("@anchor-lang/core");
+const common_1 = require("common");
+const client_1 = require("../src/client/client");
+const localUtils_1 = require("./localUtils");
+/**
+ * Parse deposit CLI argument:
+ * - **Integer string** (digits only): amount in collateral base units (e.g. lamports).
+ * - **Decimal string** (contains `.`): human amount in token units (e.g. `0.5` SOL); converted with {@link fromUiAmount} (rounds to nearest base unit).
+ */
+function parseDepositAmount(amountStr, collateralDecimals) {
+    const trimmed = amountStr.trim();
+    if (trimmed === "" || trimmed === ".") {
+        throw new Error("empty amount");
+    }
+    if (/^\d+$/.test(trimmed)) {
+        return new core_1.BN(trimmed, 10);
+    }
+    const normalized = trimmed.startsWith(".") ? `0${trimmed}` : trimmed;
+    if (!/^\d+(\.\d+)?$/.test(normalized)) {
+        throw new Error("invalid decimal amount");
+    }
+    const ui = parseFloat(normalized);
+    if (!Number.isFinite(ui) || ui < 0) {
+        throw new Error("invalid decimal amount");
+    }
+    return (0, common_1.fromUiAmount)(ui, collateralDecimals);
+}
+/**
+ * Deposits collateral and mints yTokens via `refresh_token_state` (and yielding-bank
+ * refreshes as needed) then `mint_token`. For SOL collateral, `tx.mintToken.getTx` wraps
+ * `DEPOSIT_RAW` from the signer's SOL into WSOL in the same transaction; for other
+ * collaterals the user's collateral ATA must already hold `DEPOSIT_RAW`.
+ *
+ * Usage:
+ *   From this package: `pnpm run mint-token -- test|prod <TOKEN_PDA|COLLATERAL_SYMBOL> [AMOUNT] [KEYPAIR_JSON]`
+ *   From repo root:   `pnpm lyc:mint-token -- test|prod …`
+ *
+ * `AMOUNT`: integer string = base units (e.g. lamports); decimal string = token units
+ * (e.g. `0.5` for half a SOL). Omit to deposit the entire collateral ATA balance ("all").
+ * Default signer keypair: {@link TP_ID_KEYPAIR_FP} from `common`; override with the optional path.
+ */
+async function main() {
+    const { env, rest } = (0, localUtils_1.parseCliEnvironmentAndRest)("mint-token");
+    const { rest: args, keypairPath: keypairFlagPath } = (0, localUtils_1.extractKeypairFlag)(rest);
+    const tokenArg = args[0];
+    const depositRawStr = args[1];
+    const keypairPath = keypairFlagPath ?? args[2] ?? common_1.TP_ID_KEYPAIR_FP;
+    if (tokenArg === undefined) {
+        console.error("Usage: pnpm run mint-token -- [test|prod] <TOKEN_PDA|COLLATERAL_SYMBOL> [AMOUNT] [KEYPAIR_JSON]");
+        process.exit(1);
+    }
+    const { signer: userSigner, 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, collateralDecimals } = await (0, localUtils_1.resolveTokenPda)(client, tokenArg);
+    let depositAmount;
+    if (depositRawStr === undefined || depositRawStr === "all") {
+        depositAmount = "all";
+    }
+    else {
+        try {
+            depositAmount = parseDepositAmount(depositRawStr, collateralDecimals);
+        }
+        catch {
+            console.error(`Invalid deposit amount "${depositRawStr}" (use integer base units, a decimal token amount e.g. 0.5, or "all").`);
+            process.exit(1);
+        }
+        if (depositAmount.lte(new core_1.BN(0))) {
+            console.error("Deposit amount must be positive.");
+            process.exit(1);
+        }
+    }
+    const refreshPlan = await client.tx.refreshTokens.getTx({
+        signer: userSigner.address,
+        params: {
+            tokens: [tokenPda],
+        },
+    });
+    await client.sendTransaction(userSigner, refreshPlan);
+    const mintParams = { depositAmount };
+    const mintPlan = await client.tx.mintToken.getTx({
+        signer: userSigner.address,
+        token: tokenPda,
+        params: mintParams,
+    });
+    const sig = await client.sendTransaction(userSigner, mintPlan);
+    console.log("mint_token succeeded.");
+    console.log("  environment:", env);
+    console.log("  signer:", userSigner.address);
+    console.log("  token PDA:", tokenPda);
+    console.log("  underlying collateral:", collateralSymbol);
+    console.log("  deposit:", depositAmount === "all" ? "all" : depositAmount.toString());
+    console.log("  signature:", sig);
+}
+main()
+    .then(() => console.log("Finished"))
+    .catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

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

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

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

@@ -0,0 +1,76 @@
+"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 redemption_1 = require("../src/services/redemption");
+const localUtils_1 = require("./localUtils");
+/**
+ * Finds all pending redemption epochs and processes them through the full
+ * lifecycle: close → fund (DCP + withdraw) → process all requests.
+ *
+ * Usage:
+ *   pnpm run process-async-burns -- test|prod [--keypair MANAGER_KEYPAIR_JSON]
+ *
+ * Keypair defaults to ~/.config/solana/tp-lyc-manager-{env}.json
+ */
+async function main() {
+    const { env, rest } = (0, localUtils_1.parseCliEnvironmentAndRest)("process-async-burns");
+    const { keypairPath: keypairFlagPath } = (0, localUtils_1.extractKeypairFlag)(rest);
+    const keypairPath = keypairFlagPath ?? 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 redemption = new redemption_1.RedemptionService(client);
+    console.log("=== Process Async Burns ===");
+    console.log("  environment:", env);
+    console.log("  rpc:", (0, common_1.redactRpcUrlForLog)(provider.connection.rpcEndpoint));
+    console.log("  manager:", managerSigner.address);
+    console.log();
+    const epochs = await redemption.getAllEpochs();
+    if (epochs.length === 0) {
+        console.log("No pending redemption epochs found.");
+        return;
+    }
+    console.log(`Found ${epochs.length} redemption epoch(s).\n`);
+    let processed = 0;
+    let failed = 0;
+    for (const epoch of epochs) {
+        const token = await client.account.fetchToken(epoch.tokenPda, { fresh: true });
+        const decimals = token.data.collateral.decimals;
+        const statusLabel = epoch.status === 0 ? "Open" : epoch.status === 1 ? "Funding" : "Processing";
+        console.log(`── Epoch ${epoch.pda} ──`);
+        console.log(`  Token:    ${epoch.tokenPda}`);
+        console.log(`  Epoch ID: ${epoch.epochId}`);
+        console.log(`  Status:   ${statusLabel} (${epoch.status})`);
+        console.log(`  Requests: ${epoch.processedRequestCount}/${epoch.requestCount} processed`);
+        console.log(`  Funded:   ${epoch.fundedCollateral} / ${epoch.grossCollateralClaim}`);
+        console.log(`  Loss:     ${epoch.realizedUnwindLoss}`);
+        console.log(`  Claim:    ${(0, common_1.toUiAmount)(epoch.grossCollateralClaim, decimals)} ${token.label}`);
+        try {
+            const success = await redemption.processEpoch(managerSigner, epoch, (msg) => console.log(`  ${msg}`));
+            if (success) {
+                console.log("  ✓ Epoch fully processed and closed.\n");
+                processed++;
+            }
+            else {
+                console.error("  ✗ Epoch could not be fully funded.\n");
+                failed++;
+            }
+        }
+        catch (err) {
+            console.error(`  ✗ Failed:`, err instanceof Error ? err.message : err, "\n");
+            failed++;
+        }
+    }
+    console.log(`Summary: ${processed} processed, ${failed} failed`);
+    if (failed > 0)
+        process.exit(1);
+}
+main()
+    .then(() => console.log("Finished"))
+    .catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

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

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

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

@@ -0,0 +1,210 @@
+"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 allocation_1 = require("../src/services/allocation");
+const tokenRebalanceService_1 = require("../src/services/rebalance/token/tokenRebalanceService");
+const localUtils_1 = require("./localUtils");
+const USAGE = `Rebalance collateral from one lending position to another (same token), matching the operator.
+
+Usage:
+  pnpm run rebalance-token -- [test|prod] <TOKEN> [options] [MANAGER_KEYPAIR.json]
+
+  TOKEN: Token PDA (base58) or collateral symbol (e.g. SOL) like other LYC scripts.
+
+Modes (default: --from-allocation):
+  --from-allocation   Load all tokens with active LPs, run AllocationService, then execute
+                      row(s) for this token only (same group context as production).
+  --manual            Skip allocation; use --lp and --to instead.
+
+Options:
+  --all-rows          With --from-allocation: run every reallocation row for this token
+                      (default: first row only).
+  --lp=N              Manual: source lending position index (required with --manual).
+  --to=SYMBOL         Manual: destination debt mint symbol (e.g. USDS).
+  --move-debt-pct=N   Manual: percent of current debt to move off the source mint (default 100).
+  --dry-run           Build transaction(s), print ix counts and bin-packing result; no send.
+  --sequential        Send split bins as normal sequential txs instead of a Jito bundle.
+                      Useful for debugging because tx[1] simulation sees tx[0]'s CPI plan.
+  --verbose-allocation Log AllocationService diagnostics (APY matrix, etc.).
+
+Examples:
+  pnpm run rebalance-token -- test SOL --dry-run
+  pnpm run rebalance-token -- test 2BGS… --from-allocation --all-rows
+  pnpm run rebalance-token -- test SOL --manual --lp=0 --to=USDS --dry-run`;
+function mintLabel(mint) {
+    return common_1.mints.get(mint)?.symbol ?? `${mint.slice(0, 6)}…`;
+}
+function logActiveLendingPositions(token) {
+    console.log(`\nOn-chain lending positions — ${token.label} (${token.address}):`);
+    for (const { index, data } of token.activeLendingPositions) {
+        const dm = (0, common_1.fromWeb3Pk)(data.accounting.debt.mint);
+        const amt = (0, common_1.toUiAmount)(data.accounting.debt.amount, data.accounting.debt.decimals);
+        const pool = (0, common_1.fromWeb3Pk)(data.pool);
+        const kaminoUser = (0, common_1.fromWeb3Pk)(data.protocolUserAcc);
+        const platform = JSON.stringify(data.platform);
+        console.log(`  LP[${index}] platform=${platform} debtMint=${mintLabel(dm)} debtUi=${amt.toFixed(6)} ` +
+            `pool=${pool} kaminoUser=${kaminoUser}`);
+    }
+    console.log("");
+}
+function parseKeyValueFlags(argv) {
+    const positional = [];
+    const flags = new Set();
+    const kv = new Map();
+    for (const raw of argv) {
+        if (raw.startsWith("--")) {
+            const body = raw.slice(2);
+            const eq = body.indexOf("=");
+            if (eq >= 0) {
+                kv.set(body.slice(0, eq).split("-").join("_"), body.slice(eq + 1));
+            }
+            else {
+                flags.add(body.split("-").join("_"));
+            }
+        }
+        else if ((0, localUtils_1.isLikelyKeypairPath)(raw)) {
+            kv.set("keypair", raw);
+        }
+        else {
+            positional.push(raw);
+        }
+    }
+    return { positional, flags, kv };
+}
+async function tryBinPackDryRun(client, payer, plan) {
+    const { value: blockhash } = await client.rpc
+        .getLatestBlockhash({ commitment: "confirmed" })
+        .send();
+    try {
+        const { bins } = await (0, common_1.splitIntoTransactionBins)(client.rpc, payer, plan.instructions, {
+            lookupTables: plan.lookupTables,
+            blockhash,
+            reservedBytes: common_1.BUNDLE_INJECTED_IX_RESERVED_BYTES,
+            segmentLengths: plan.segmentLengths,
+            freshBinSegments: plan.freshBinSegments,
+        });
+        console.log(`[dry-run] Bin packing OK: ${bins.length} transaction(s) (effective limit ` +
+            `1232 − ${common_1.BUNDLE_INJECTED_IX_RESERVED_BYTES} reserved bytes).`);
+        bins.forEach((bin, i) => {
+            console.log(`  bin[${i}]: ${bin.length} instruction(s)`);
+        });
+    }
+    catch (err) {
+        console.error("[dry-run] Bin packing failed:", err instanceof Error ? err.message : err);
+    }
+}
+async function executeReallocation(client, managerSigner, tokenAddress, realloc, options) {
+    const service = new tokenRebalanceService_1.TokenRebalanceService(client);
+    const result = await service.fetchAndBuildPlan(tokenAddress, realloc);
+    if (result.outcome === "skipped") {
+        console.log(`Skip token ${tokenAddress.slice(0, 8)}…: ${result.reason}`);
+        return;
+    }
+    const { plan, label } = result;
+    console.log(`${label}: rebalanceToken plan — lp=${realloc.lendingPositionIndex} ` +
+        `(${plan.instructions.length} top-level ix, segmentLengths=${JSON.stringify(plan.segmentLengths ?? [])})`);
+    if (options.dryRun) {
+        await tryBinPackDryRun(client, managerSigner, plan);
+        return;
+    }
+    const sig = await client.sendTransaction(managerSigner, plan, {
+        sendOversizedAsSequentialTransactions: options.sequential,
+    });
+    console.log(`Sent rebalanceToken. Signature: ${sig}`);
+}
+async function main() {
+    const { env, rest } = (0, localUtils_1.parseCliEnvironmentAndRest)("rebalance-token");
+    const { rest: args, keypairPath: keypairFlagPath } = (0, localUtils_1.extractKeypairFlag)(rest);
+    const { positional, flags, kv } = parseKeyValueFlags(args);
+    if (positional.length < 1) {
+        console.error(USAGE);
+        process.exit(1);
+    }
+    const tokenArg = positional[0];
+    const keypairPath = keypairFlagPath ?? kv.get("keypair") ?? general_1.LYC_MANAGER_KEYPAIR_FP[env];
+    const dryRun = flags.has("dry_run");
+    const sequential = flags.has("sequential");
+    const verboseAllocation = flags.has("verbose_allocation");
+    const fromAllocation = !flags.has("manual");
+    const allRows = flags.has("all_rows");
+    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 } = await (0, localUtils_1.resolveTokenPda)(client, tokenArg);
+    const tokenFresh = await client.account.fetchToken(tokenPda, { fresh: true });
+    logActiveLendingPositions(tokenFresh);
+    if (tokenFresh.activeLendingPositions.length === 0) {
+        console.error("Token has no active lending positions.");
+        process.exit(1);
+    }
+    let reallocations;
+    if (fromAllocation) {
+        const { tokens, yieldingBanks } = await client.account.fetchAllTokensAndYieldingBanks();
+        const activeTokens = tokens.filter((t) => t.activeLendingPositions.length > 0);
+        const kaminoData = client.lendingPlatformClients.getByPlatform(common_1.LendingPlatform.Kamino).data;
+        const allocationService = new allocation_1.AllocationService(kaminoData, {
+            logger: verboseAllocation ? (m) => console.log(m) : () => undefined,
+            yieldingBanks,
+        });
+        console.log(`Computing optimal allocations across ${activeTokens.length} token(s) with active LPs…`);
+        const all = await allocationService.computeOptimalAllocations(activeTokens);
+        const rows = all.filter((r) => r.token === tokenPda);
+        if (rows.length === 0) {
+            console.log("No reallocation rows for this token (already optimal or filtered out).");
+            return;
+        }
+        console.log(`Selected ${rows.length} row(s) for this token${allRows ? "" : " (will run first only unless --all-rows)"}.`);
+        reallocations = allRows ? rows : rows.slice(0, 1);
+    }
+    else {
+        const lpIndexRaw = kv.get("lp");
+        const toSymbol = kv.get("to");
+        if (lpIndexRaw === undefined || toSymbol === undefined) {
+            console.error("--manual requires --lp=N and --to=SYMBOL");
+            process.exit(1);
+        }
+        const lpIndex = parseInt(lpIndexRaw, 10);
+        const lp = tokenFresh.activeLendingPositions.find((p) => p.index === lpIndex);
+        if (!lp) {
+            console.error(`No active lending position at index ${lpIndex}`);
+            process.exit(1);
+        }
+        const targetMintInfo = common_1.mints.get(toSymbol);
+        if (!targetMintInfo) {
+            console.error(`Unknown mint symbol: ${toSymbol}`);
+            process.exit(1);
+        }
+        const targetMint = targetMintInfo.address;
+        const currentDebtMint = (0, common_1.fromWeb3Pk)(lp.data.accounting.debt.mint);
+        reallocations = [
+            {
+                token: tokenPda,
+                lendingPositionIndex: lpIndex,
+                currentDebtMint,
+                currentDebtAmountUi: 0,
+                currentBorrowApy: 0,
+                currentSupplyIncentiveApy: 0,
+                projectedBorrowApy: 0,
+                targets: [{ mint: targetMint, amountUi: 0, weightBps: 10000 }],
+                fallbackTargets: [],
+            },
+        ];
+        console.log(`Manual rebalance for token ${tokenPda.slice(0, 8)}… lp=${lpIndex} → ${toSymbol}`);
+    }
+    for (const realloc of reallocations) {
+        console.log(`\n── Token ${realloc.token.slice(0, 8)}… lp=${realloc.lendingPositionIndex}`);
+        await executeReallocation(client, managerSigner, realloc.token, realloc, {
+            dryRun,
+            sequential,
+        });
+    }
+}
+main()
+    .then(() => console.log("\nDone."))
+    .catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

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

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