@kestrelfi/lyc-sdk 1.0.1

package/.env.example

@@ -0,0 +1,11 @@
+# Copy to .env and fill in real values.
+# Loaded by SDK scripts (create-token, mint-token, etc.) via localUtils.ts.
+
+# =============================================================================
+# RPC (at least one required for test/prod environments)
+# =============================================================================
+# Resolution order: IRONFORGE_API_KEY > RPC_URL > HELIUS_API_KEY.
+
+# RPC_URL=https://your-rpc-endpoint.com
+IRONFORGE_API_KEY=your_ironforge_api_key
+HELIUS_API_KEY=your_helius_api_key

package/README.md

@@ -0,0 +1,207 @@
+# Long Yield Carry TypeScript SDK
+
+Client for the **long_yield_carry** Anchor program: PDA derivation, account decoding, instruction builders, and high-level transaction plans. The main entry point is **`LongYieldCarryClient`** (the “LYC client”).
+
+## Installation and import
+
+In this monorepo, depend on the workspace package and use the `long-yield-carry` path alias (see root `tsconfig.json`):
+
+```ts
+import { LongYieldCarryClient } from "@kestrelfi/lyc-sdk";
+import { BN } from "@anchor-lang/core";
+import { address, type Address } from "@solana/kit";
+```
+
+## Constructing the client
+
+You need an Anchor `AnchorProvider` (connection + wallet). The second argument selects the deployment environment and thus the program ID and RPC URL used by the SDK:
+
+```ts
+import { AnchorProvider } from "@anchor-lang/core";
+import { LongYieldCarryClient } from "@kestrelfi/lyc-sdk";
+
+const client = new LongYieldCarryClient(provider, "local");
+// or "test" | "prod"
+```
+
+Optional third argument: `LongYieldCarryClientOptions` — e.g. `swapClient` or a `lendingPlatformClients` override for tests or custom routing.
+
+### What hangs off the client
+
+| Property                                         | Role                                                                 |
+| ------------------------------------------------ | -------------------------------------------------------------------- |
+| `client.pda`                                     | Derive Token and YieldingBank PDAs                                   |
+| `client.account`                                 | Fetch and cache on-chain accounts (`LYCToken`, `LYCYieldingBank`)    |
+| `client.ix`                                      | Build single Kit `Instruction`s                                      |
+| `client.tx`                                      | Build composed transaction plans (ATAs, wraps, refreshes, CPI pools) |
+| `client.rpc`                                     | Shared RPC used by send helpers                                      |
+| `client.swap`                                    | Aggregate swap client (used by manager flows and some planners)      |
+| `client.getLendingPlatformClient(...)`           | Resolve the lending client for an on-chain lending position          |
+| `client.getLendingPlatformClientByPlatform(...)` | Resolve a lending client when only the platform enum is known        |
+| `client.sendTransaction(...)`                    | Sign, send, confirm, and apply plan cache invalidations              |
+
+---
+
+## Minting yTokens (`mint_token`)
+
+### Recommended: `client.tx.mintToken.getTx(...)`
+
+Use this for end-user flows. It prepends, when needed:
+
+- **SOL collateral:** create the user’s wSOL ATA (if missing), transfer lamports from the signer, `sync_native`.
+- **yToken:** idempotent ATA creation for the user’s receipt account.
+
+Then it appends `mint_token`. The signer must be the wallet that owns the collateral and will receive minted yTokens.
+
+```ts
+import { BN } from "@anchor-lang/core";
+import { address } from "@solana/kit";
+
+const signer = address(walletAddress);
+const tokenPda = address("…"); // Token PDA
+
+const mintPlan = await client.tx.mintToken.getTx({
+  signer,
+  token: tokenPda,
+  params: {
+    depositAmount: new BN(1_000_000_000), // base units, e.g. lamports
+  },
+});
+await client.sendTransaction(walletSigner, mintPlan);
+```
+
+## Burning yTokens (`burn_token`)
+
+### Recommended: `client.tx.burnToken.getTx(...)`
+
+`burn_token` redeems from unlent collateral when balances suffice at execution time.
+Without `asyncFallback`, the SDK sends `BurnTokenParams.sync`; insufficient unlent
+balance surfaces as `InsufficientUnlentCollateral`. Pass `asyncFallback` (epoch/request
+PDAs + `BurnTokenParams.async`) when the same transaction should create or extend an
+async redemption queue instead.
+
+```ts
+const burnPlan = await client.tx.burnToken.getTx({
+  signer,
+  token: tokenPda,
+  params: {
+    burnAmount: new BN(500_000_000),
+  },
+});
+await client.sendTransaction(walletSigner, burnPlan);
+```
+
+When collateral is native SOL (WSOL), the plan appends a close-account after
+`burn_token` so proceeds settle as SOL.
+
+```ts
+const plainBurn = await client.tx.burnToken.getTx({
+  signer,
+  token: tokenPda,
+  params: {
+    burnAmount: new BN(500_000_000),
+    // Optional: include a fallback so the same burn_token instruction creates
+    // an async request if reserves are short by the time the tx lands.
+    asyncFallback: {
+      epochId: new BN(7),
+      // Omit requestSequence to let the builder read the next epoch sequence.
+      requestSequence: new BN(0),
+    },
+  },
+});
+```
+
+## Async Burns
+
+Async burns group one or more FIFO requests into a redemption epoch. Users still call `burnToken`; there is no separate user-facing create/request instruction:
+
+```ts
+await client.tx.burnToken.getTx({
+  signer,
+  token: tokenPda,
+  params: {
+    burnAmount: new BN(500_000_000),
+    asyncFallback: {
+      epochId: new BN(7),
+      requestSequence: new BN(0),
+    },
+  },
+});
+```
+
+Managers fund closed epochs by running `decreaseCarryPosition` with
+`redemptionEpoch` when DCP loss should be charged to that epoch, then
+`topUpUnlentReserves` to withdraw freed collateral. `processAsyncBurn` processes
+requests in exact sequence order and rejects out-of-order requests.
+
+## Reading on-chain state
+
+### Token accounts → `LYCToken`
+
+```ts
+const token = await client.account.fetchToken(tokenPda);
+// token.address — Token PDA
+// token.data — raw IDL shape
+// token.mint, token.collateralMint, token.decimals
+// token.price, token.totalSupply, token.tvlUsd — UI helpers
+```
+
+Batch and discovery:
+
+- `client.account.fetchTokens([pda1, pda2])` — multiple PDAs.
+- `client.account.fetchAllTokens()` — all Token accounts owned by the program.
+
+Use `{ fresh: true }` to bypass the short-lived in-memory cache when you must see writes immediately:
+
+```ts
+await client.account.fetchToken(tokenPda, { fresh: true });
+```
+
+### Yielding bank accounts → `LYCYieldingBank`
+
+```ts
+const bank = await client.account.fetchYieldingBank(yieldingBankPda);
+// bank.address, bank.data
+// bank.baseMint, bank.defaultRedemptionMint, bank.id, bank.decimals // share decimals, canonical 8
+// bank.sharePrice, bank.minSharePrice, bank.totalShares — UI helpers
+```
+
+Also: `fetchYieldingBanks([...])`, `fetchAllYieldingBanks()`.
+
+### User holdings → `UserHolding[]`
+
+Fetch every LYC yToken a wallet holds, with balances and optional USD notionals when you pass a collateral USD `priceMap`.
+
+```ts
+const holdings = await client.account.fetchUserHoldings(walletAddress, {
+  priceMap: { [collateralMint]: usdPrice },
+});
+// holdings[i].token        — LYCToken model (price, label, decimals, …)
+// holdings[i].balance      — bigint, base units of the yToken
+// holdings[i].uiBalance    — decimal-adjusted number
+// holdings[i].valueUsd     — uiBalance × token.price × priceMap[collateralMint], if priced
+// holdings[i].tokenAccount — user ATA for the yToken mint
+```
+
+Without a usable entry in `priceMap` for the collateral mint, `valueUsd` is omitted (no inference from stale on-chain TVL). Zero-balance holdings are filtered out by default; pass `{ includeEmpty: true }` to include them.
+
+### PDAs (when you know mint + id)
+
+```ts
+const [tokenPda] = await client.pda.deriveTokenPda(yTokenMint, tokenId);
+const [bankPda] = await client.pda.deriveYieldingBankPda(baseMint, yieldingBankId);
+```
+
+Seeds match the program: `TOKEN` + mint + `id`; `YIELDING_BANK` + base mint + `id`.
+
+---
+
+## Sending transactions
+
+`client.sendTransaction(payer, planOrInstructions, options?)` accepts either a `LongYieldCarryTransactionPlan` (`instructions`, `lookupTables`, optional `postSuccessCacheInvalidations`) or a bare `Instruction[]`. When you pass a plan, post-success hooks clear SDK caches for affected Tokens / YieldingBanks plus any Kamino-related invalidations. Use the payer’s **Kit** `TransactionSigner` expected by `common`’s `signSendAndConfirmTransaction`.
+
+## Anchor error codes
+
+The bundled IDL still lists `InvalidTvlBiasBps`: TVL bias configuration was removed on-chain, but the Anchor error variant is retained so numeric error discriminants do not shift versus older program builds. Match errors using IDL-derived names and regenerate TypeScript bindings when you upgrade the deployed program — do not rely on hard-coded Anchor error integers.
+
+---

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

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

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

@@ -0,0 +1,117 @@
+"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 general_1 = require("../src/constants/general");
+const redemption_1 = require("../src/services/redemption");
+const utils_1 = require("../src/utils");
+const localUtils_1 = require("./localUtils");
+/**
+ * Burns yTokens and, if the burn is redirected to the async path, processes the
+ * full async epoch lifecycle: wait → close → fund → process.
+ *
+ * Usage:
+ *   pnpm run async-burn -- test|prod <TOKEN_PDA|COLLATERAL_SYMBOL> [AMOUNT] [--keypair KEYPAIR_JSON]
+ *
+ * AMOUNT: integer string = yToken base units; decimal string = yToken units (e.g. 0.25).
+ * Omit to burn the entire yToken ATA balance ("all").
+ *
+ * --keypair: User keypair that holds yTokens and signs the initial burn.
+ *            Defaults to ~/.config/solana/tp-id.json.
+ * The manager keypair (tp-lyc-manager-{env}.json) is loaded separately and used
+ * for the subsequent funding and processing steps.
+ */
+async function main() {
+    const { env, rest } = (0, localUtils_1.parseCliEnvironmentAndRest)("async-burn");
+    const { rest: args, keypairPath: keypairFlagPath } = (0, localUtils_1.extractKeypairFlag)(rest);
+    const positional = args.filter((arg) => !arg.startsWith("--"));
+    const tokenArg = positional[0];
+    const burnRawStr = positional[1];
+    if (tokenArg === undefined) {
+        console.error("Usage: pnpm run async-burn -- [test|prod] <TOKEN_PDA|COLLATERAL_SYMBOL> [AMOUNT] [--keypair KEYPAIR_JSON]");
+        process.exit(1);
+    }
+    const userKeypairPath = keypairFlagPath ?? common_1.TP_ID_KEYPAIR_FP;
+    const { signer: userSigner } = await (0, common_1.loadLocalKeypairWithWeb3)(userKeypairPath);
+    const managerKeypairPath = general_1.LYC_MANAGER_KEYPAIR_FP[env];
+    const { signer: managerSigner, web3Keypair } = await (0, common_1.loadLocalKeypairWithWeb3)(managerKeypairPath);
+    const provider = (0, common_1.createDefaultAnchorProvider)(env, web3Keypair);
+    const client = new client_1.LongYieldCarryClient(provider, env);
+    const redemption = new redemption_1.RedemptionService(client);
+    const { tokenPda, collateralSymbol, collateralDecimals } = await (0, localUtils_1.resolveTokenPda)(client, tokenArg);
+    const burnAmount = parseBurnAmount(burnRawStr, collateralDecimals);
+    console.log("=== Async Burn ===");
+    console.log("  environment:", env);
+    console.log("  user:", userSigner.address);
+    console.log("  manager:", managerSigner.address);
+    console.log("  token PDA:", tokenPda);
+    console.log("  collateral:", collateralSymbol ?? "unknown");
+    console.log("  burn amount:", burnAmount === "all" ? "all" : burnAmount.toString());
+    console.log();
+    // ── Step 1: Execute burn (signed by the user who holds yTokens) ──
+    const epochId = (0, utils_1.currentEpochId)();
+    console.log("[1/4] Submitting burn_token...");
+    const burnPlan = await client.tx.burnToken.getTx({
+        signer: userSigner.address,
+        token: tokenPda,
+        params: { burnAmount, epochId },
+    });
+    const burnSig = await client.sendTransaction(userSigner, burnPlan);
+    console.log("  burn_token signature:", burnSig);
+    client.clearAllCache();
+    // ── Step 2: Check if an async epoch was created ──
+    const [epochPda] = await client.pda.deriveRedemptionEpochPda(tokenPda, BigInt(epochId.toString()));
+    let epoch;
+    try {
+        epoch = await redemption.getEpoch(epochPda);
+    }
+    catch {
+        console.log("\nBurn settled synchronously — no async epoch created.");
+        return;
+    }
+    console.log(`\n  Async epoch detected: ${epochPda}`);
+    console.log(`  Requests: ${epoch.requestCount}`);
+    console.log(`  Gross collateral claim: ${(0, common_1.toUiAmount)(epoch.grossCollateralClaim, collateralDecimals)} (${epoch.grossCollateralClaim} base)`);
+    console.log();
+    const log = (msg) => console.log(`  ${msg}`);
+    // ── Step 3: Wait for window + close + fund ──
+    console.log("[2/4] Waiting for epoch window...");
+    await redemption.waitForEpochWindow(epoch, log);
+    console.log("[3/4] Closing, funding, and transitioning epoch...");
+    const success = await redemption.processEpoch(managerSigner, epoch, log);
+    if (!success) {
+        console.error("  ERROR: Epoch could not be fully funded.");
+        process.exit(1);
+    }
+    console.log("\n[4/4] All async burn requests processed. Epoch closed.");
+}
+function parseBurnAmount(amountStr, tokenDecimals) {
+    if (amountStr === undefined || amountStr === "all")
+        return "all";
+    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)) {
+        console.error(`Invalid burn amount "${amountStr}".`);
+        process.exit(1);
+    }
+    const ui = parseFloat(normalized);
+    if (!Number.isFinite(ui) || ui < 0) {
+        console.error(`Invalid burn amount "${amountStr}".`);
+        process.exit(1);
+    }
+    return (0, common_1.fromUiAmount)(ui, tokenDecimals);
+}
+main()
+    .then(() => console.log("Finished"))
+    .catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

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

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

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

@@ -0,0 +1,98 @@
+"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 burn CLI argument:
+ * - **Integer string** (digits only): amount in yToken base units (shares the token's mint decimals).
+ * - **Decimal string** (contains `.`): human amount in yToken units (e.g. `0.25`); converted with {@link fromUiAmount} (rounds to nearest base unit).
+ *
+ * yTokens share their collateral's decimals, so `tokenDecimals` here equals the token's `collateral.decimals`.
+ */
+function parseBurnAmount(amountStr, tokenDecimals) {
+    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, tokenDecimals);
+}
+/**
+ * Burns yTokens and withdraws collateral via `burn_token`. The chain rejects
+ * when unlent collateral is insufficient and no async fallback accounts are provided.
+ *
+ * Usage:
+ *   From this package: `pnpm run burn-token -- test|prod <TOKEN_PDA|COLLATERAL_SYMBOL> [AMOUNT] [--keypair KEYPAIR_JSON]`
+ *   From repo root:   `pnpm lyc:burn-token -- test|prod …`
+ *
+ * `AMOUNT`: integer string = yToken base units; decimal string = yToken units (e.g. `0.25`).
+ * Omit to burn the entire yToken ATA balance ("all").
+ * Default signer keypair: {@link TP_ID_KEYPAIR_FP} from `common`; override with `--keypair`.
+ */
+async function main() {
+    const { env, rest } = (0, localUtils_1.parseCliEnvironmentAndRest)("burn-token");
+    const { rest: args, keypairPath: keypairFlagPath } = (0, localUtils_1.extractKeypairFlag)(rest);
+    const positional = args.filter((arg) => !arg.startsWith("--"));
+    const tokenArg = positional[0];
+    const burnRawStr = positional[1];
+    const keypairPath = keypairFlagPath ?? positional[2] ?? common_1.TP_ID_KEYPAIR_FP;
+    if (tokenArg === undefined) {
+        console.error("Usage: pnpm run burn-token -- [test|prod] <TOKEN_PDA|COLLATERAL_SYMBOL> [AMOUNT] [--keypair 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 burnAmount;
+    if (burnRawStr === undefined || burnRawStr === "all") {
+        burnAmount = "all";
+    }
+    else {
+        try {
+            burnAmount = parseBurnAmount(burnRawStr, collateralDecimals);
+        }
+        catch {
+            console.error(`Invalid burn amount "${burnRawStr}" (use integer base units, a decimal token amount e.g. 0.25, or "all").`);
+            process.exit(1);
+        }
+        if (burnAmount.lte(new core_1.BN(0))) {
+            console.error("Burn amount must be positive.");
+            process.exit(1);
+        }
+    }
+    const burnPlan = await client.tx.burnToken.getTx({
+        signer: userSigner.address,
+        token: tokenPda,
+        params: {
+            burnAmount,
+        },
+    });
+    const sig = await client.sendTransaction(userSigner, burnPlan);
+    console.log("burn_token succeeded.");
+    console.log("  environment:", env);
+    console.log("  signer:", userSigner.address);
+    console.log("  token PDA:", tokenPda);
+    console.log("  underlying collateral:", collateralSymbol);
+    console.log("  burn:", burnAmount === "all" ? "all" : burnAmount.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/claimIncentives.d.ts

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

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

@@ -0,0 +1,108 @@
+"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 localUtils_1 = require("./localUtils");
+/**
+ * Runs `claim_incentives` for every outstanding incentive across the target
+ * token's active lending positions. One transaction per (lendingPositionIndex,
+ * incentiveMint) pair.
+ *
+ * Skips tokens with the circuit breaker on. `NoOpTransactionError` is treated
+ * as a successful skip.
+ *
+ * Usage:
+ *   From this package:
+ *     `pnpm run claim-incentives -- test|prod <TOKEN_PDA|SYMBOL> [KEYPAIR_JSON]`
+ *   From repo root:
+ *     `pnpm run lyc:claim-incentives -- test|prod <TOKEN_PDA|SYMBOL> [KEYPAIR_JSON]`
+ *
+ * Defaults to the manager keypair for the environment ({@link LYC_MANAGER_KEYPAIR_FP}).
+ */
+async function main() {
+    const { env, rest } = (0, localUtils_1.parseCliEnvironmentAndRest)("claim-incentives");
+    const { rest: args, keypairPath: keypairFlagPath } = (0, localUtils_1.extractKeypairFlag)(rest);
+    if (args.length < 1 || args.length > 2) {
+        console.error("Usage: pnpm run claim-incentives -- test|prod <TOKEN_PDA|SYMBOL> [KEYPAIR_JSON]");
+        process.exit(1);
+    }
+    const [first, second] = args;
+    let tokenIdentifier;
+    let keypairPath;
+    if (args.length === 1) {
+        tokenIdentifier = first;
+        keypairPath = keypairFlagPath ?? general_1.LYC_MANAGER_KEYPAIR_FP[env];
+    }
+    else if ((0, localUtils_1.isLikelyKeypairPath)(second)) {
+        tokenIdentifier = first;
+        keypairPath = keypairFlagPath ?? second;
+    }
+    else {
+        console.error("Second positional must look like a keypair path (e.g. *.json).");
+        process.exit(1);
+    }
+    const { signer, 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, tokenIdentifier);
+    const token = await client.account.fetchToken(tokenPda, { fresh: true });
+    console.log("Claiming incentives (long-yield-carry)...");
+    console.log("  environment:", env);
+    console.log("  manager:", signer.address);
+    console.log("  token:", tokenPda, collateralSymbol ? `(${collateralSymbol})` : "");
+    if (!token.isActive) {
+        console.log(`[skip] ${token.label} — circuit breaker active`);
+        return;
+    }
+    const incentivesByPosition = await client.getOutstandingIncentives(token, undefined, console.log);
+    if (incentivesByPosition.size === 0) {
+        console.log("No outstanding incentives across active lending positions.");
+        return;
+    }
+    let claimed = 0;
+    let skippedNoop = 0;
+    let failures = 0;
+    for (const [lendingPositionIndex, incentives] of incentivesByPosition) {
+        for (const incentive of incentives) {
+            const label = `${token.label} lp[${lendingPositionIndex}] mint=${incentive.mint.slice(0, 6)}…`;
+            try {
+                const plan = await client.tx.claimIncentives.getTx({
+                    token: token.address,
+                    params: {
+                        lendingPositionIndex,
+                        incentiveMint: incentive.mint,
+                        claimAccounts: incentive.claimAccounts,
+                    },
+                });
+                const sig = await client.sendTransaction(signer, plan);
+                console.log(`[ok] ${label} amount≈${incentive.uiAmount} (${sig})`);
+                claimed++;
+                client.clearAllCache();
+            }
+            catch (err) {
+                if (err instanceof errors_1.NoOpTransactionError) {
+                    console.log(`[noop] ${label} — ${err.message}`);
+                    skippedNoop++;
+                    continue;
+                }
+                failures++;
+                console.error(`[fail] ${label}: ${err.message}`);
+            }
+        }
+    }
+    console.log("\nSummary:");
+    console.log("  claimed:", claimed);
+    console.log("  skipped (no-op):", skippedNoop);
+    console.log("  failures:", failures);
+    if (failures > 0)
+        process.exit(1);
+}
+main()
+    .then(() => console.log("Finished"))
+    .catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

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

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

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

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./env");
+const core_1 = require("@anchor-lang/core");
+const kit_1 = require("@solana/kit");
+const common_1 = require("common");
+const client_1 = require("../src/client/client");
+const long_yield_carry_1 = require("../src/idl/long_yield_carry");
+const general_1 = require("../src/constants/general");
+const localUtils_1 = require("./localUtils");
+const LAMPORTS_PER_SOL = 1000000000;
+// CpiPlanAccount Anchor discriminator: sha256("account:CpiPlanAccount")[0..8]
+const CPI_PLAN_DISCRIMINATOR = Buffer.from([23, 23, 187, 18, 208, 103, 156, 246]);
+/**
+ * Finds all live CPI plan PDAs and closes them, reclaiming rent back to the manager.
+ *
+ * CPI plan accounts are normally auto-closed by `rebalance_token` on success.
+ * This script reclaims rent from any that were left open due to a failed or
+ * interrupted transaction.
+ *
+ * Usage:
+ *   pnpm run close-cpi-plans -- test|prod [KEYPAIR_JSON]
+ *   pnpm run lyc:close-cpi-plans -- test|prod [KEYPAIR_JSON]
+ */
+async function main() {
+    const { env, rest } = (0, localUtils_1.parseCliEnvironmentAndRest)("close-cpi-plans");
+    const { rest: args, keypairPath: keypairFlagPath } = (0, localUtils_1.extractKeypairFlag)(rest);
+    const keypairPath = keypairFlagPath ?? (args.length > 0 ? args[0] : general_1.LYC_MANAGER_KEYPAIR_FP[env]);
+    const { signer, web3Keypair } = await (0, common_1.loadLocalKeypairWithWeb3)(keypairPath);
+    const provider = (0, common_1.createDefaultAnchorProvider)(env, web3Keypair);
+    const client = new client_1.LongYieldCarryClient(provider, env);
+    const idl = { ...long_yield_carry_1.IDL, address: general_1.PROGRAM_ID[env] };
+    const program = new core_1.Program(idl, provider);
+    console.log("Closing orphaned CPI plan PDAs...");
+    console.log("  environment:", env);
+    console.log("  manager:", signer.address);
+    // Find all CpiPlanAccount accounts using the discriminator memcmp filter.
+    const rpcConnection = provider.connection;
+    const accounts = await rpcConnection.getProgramAccounts(program.programId, {
+        filters: [
+            {
+                memcmp: {
+                    offset: 0,
+                    bytes: CPI_PLAN_DISCRIMINATOR.toString("base64"),
+                    encoding: "base64",
+                },
+            },
+        ],
+    });
+    console.log(`  found ${accounts.length} CPI plan account(s)`);
+    if (accounts.length === 0) {
+        console.log("Nothing to close.");
+        return;
+    }
+    let closed = 0;
+    let failed = 0;
+    let totalReclaimed = 0n;
+    for (const { pubkey, account } of accounts) {
+        const cpiPlanAddress = (0, kit_1.address)(pubkey.toBase58());
+        const lamports = BigInt(account.lamports);
+        try {
+            const ix = await program.methods
+                .closeCpiPlan()
+                .accountsPartial({
+                manager: signer.address,
+                cpiPlan: cpiPlanAddress,
+            })
+                .instruction()
+                .then(common_1.toKitInstruction);
+            const sig = await client.sendTransaction(signer, [ix]);
+            closed += 1;
+            totalReclaimed += lamports;
+            console.log(`[ok]   ${cpiPlanAddress} — ${(Number(lamports) / LAMPORTS_PER_SOL).toFixed(9)} SOL reclaimed (${sig})`);
+        }
+        catch (err) {
+            failed += 1;
+            console.error(`[fail] ${cpiPlanAddress}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    console.log("\nSummary:");
+    console.log("  closed:", closed);
+    console.log("  total reclaimed:", `${(Number(totalReclaimed) / LAMPORTS_PER_SOL).toFixed(9)} SOL`);
+    console.log("  failures:", 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/collectInterest.d.ts

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