@kestrelfi/lyc-sdk 1.0.1

package/scripts/asyncBurn.ts

@@ -0,0 +1,155 @@
+import "./env";
+import { BN } from "@anchor-lang/core";
+import { type Address } from "@solana/kit";
+import {
+  fromUiAmount,
+  loadLocalKeypairWithWeb3,
+  toBigInt,
+  toUiAmount,
+  TP_ID_KEYPAIR_FP,
+  createDefaultAnchorProvider,
+} from "common";
+import { LongYieldCarryClient } from "../src/client/client";
+import { LYC_MANAGER_KEYPAIR_FP } from "../src/constants/general";
+import { RedemptionService } from "../src/services/redemption";
+import { currentEpochId } from "../src/utils";
+import { extractKeypairFlag, parseCliEnvironmentAndRest, resolveTokenPda } from "./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 } = parseCliEnvironmentAndRest("async-burn");
+  const { rest: args, keypairPath: keypairFlagPath } = 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 ?? TP_ID_KEYPAIR_FP;
+  const { signer: userSigner } = await loadLocalKeypairWithWeb3(userKeypairPath);
+
+  const managerKeypairPath = LYC_MANAGER_KEYPAIR_FP[env];
+  const { signer: managerSigner, web3Keypair } = await loadLocalKeypairWithWeb3(managerKeypairPath);
+  const provider = createDefaultAnchorProvider(env, web3Keypair);
+  const client = new LongYieldCarryClient(provider, env);
+  const redemption = new RedemptionService(client);
+
+  const { tokenPda, collateralSymbol, collateralDecimals } = await 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 = 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: ${toUiAmount(epoch.grossCollateralClaim, collateralDecimals)} (${
+      epoch.grossCollateralClaim
+    } base)`
+  );
+  console.log();
+
+  const log = (msg: string) => 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: string | undefined, tokenDecimals: number): BN | "all" {
+  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 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 fromUiAmount(ui, tokenDecimals);
+}
+
+main()
+  .then(() => console.log("Finished"))
+  .catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });

package/scripts/burnToken.ts

@@ -0,0 +1,120 @@
+import "./env";
+import { BN } from "@anchor-lang/core";
+import {
+  fromUiAmount,
+  loadLocalKeypairWithWeb3,
+  TP_ID_KEYPAIR_FP,
+  createDefaultAnchorProvider,
+} from "common";
+import { LongYieldCarryClient } from "../src/client/client";
+import { extractKeypairFlag, parseCliEnvironmentAndRest, resolveTokenPda } from "./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: string, tokenDecimals: number): BN {
+  const trimmed = amountStr.trim();
+  if (trimmed === "" || trimmed === ".") {
+    throw new Error("empty amount");
+  }
+
+  if (/^\d+$/.test(trimmed)) {
+    return new 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 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 } = parseCliEnvironmentAndRest("burn-token");
+  const { rest: args, keypairPath: keypairFlagPath } = extractKeypairFlag(rest);
+
+  const positional = args.filter((arg) => !arg.startsWith("--"));
+
+  const tokenArg = positional[0];
+  const burnRawStr = positional[1];
+  const keypairPath = keypairFlagPath ?? positional[2] ?? 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 loadLocalKeypairWithWeb3(keypairPath);
+  const provider = createDefaultAnchorProvider(env, web3Keypair);
+  const client = new LongYieldCarryClient(provider, env);
+
+  const { tokenPda, collateralSymbol, collateralDecimals } = await resolveTokenPda(
+    client,
+    tokenArg
+  );
+
+  let burnAmount: BN | "all";
+  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 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/scripts/claimIncentives.ts

@@ -0,0 +1,125 @@
+import "./env";
+import { loadLocalKeypairWithWeb3, createDefaultAnchorProvider } from "common";
+import { LongYieldCarryClient } from "../src/client/client";
+import { LYC_MANAGER_KEYPAIR_FP } from "../src/constants/general";
+import { NoOpTransactionError } from "../src/errors";
+import {
+  extractKeypairFlag,
+  isLikelyKeypairPath,
+  parseCliEnvironmentAndRest,
+  resolveTokenPda,
+} from "./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(): Promise<void> {
+  const { env, rest } = parseCliEnvironmentAndRest("claim-incentives");
+  const { rest: args, keypairPath: keypairFlagPath } = 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: string;
+  let keypairPath: string;
+  if (args.length === 1) {
+    tokenIdentifier = first!;
+    keypairPath = keypairFlagPath ?? LYC_MANAGER_KEYPAIR_FP[env];
+  } else if (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 loadLocalKeypairWithWeb3(keypairPath);
+  const provider = createDefaultAnchorProvider(env, web3Keypair);
+  const client = new LongYieldCarryClient(provider, env);
+
+  const { tokenPda, collateralSymbol } = await 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 NoOpTransactionError) {
+          console.log(`[noop] ${label} — ${err.message}`);
+          skippedNoop++;
+          continue;
+        }
+        failures++;
+        console.error(`[fail] ${label}: ${(err as Error).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/scripts/closeCpiPlans.ts

@@ -0,0 +1,113 @@
+import "./env";
+import { Program } from "@anchor-lang/core";
+import { address, type Address } from "@solana/kit";
+import { loadLocalKeypairWithWeb3, createDefaultAnchorProvider, toKitInstruction } from "common";
+import { LongYieldCarryClient } from "../src/client/client";
+import { LongYieldCarry, IDL } from "../src/idl/long_yield_carry";
+import { LYC_MANAGER_KEYPAIR_FP, PROGRAM_ID } from "../src/constants/general";
+import { extractKeypairFlag, parseCliEnvironmentAndRest } from "./localUtils";
+
+const LAMPORTS_PER_SOL = 1_000_000_000;
+
+// 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(): Promise<void> {
+  const { env, rest } = parseCliEnvironmentAndRest("close-cpi-plans");
+  const { rest: args, keypairPath: keypairFlagPath } = extractKeypairFlag(rest);
+
+  const keypairPath = keypairFlagPath ?? (args.length > 0 ? args[0]! : LYC_MANAGER_KEYPAIR_FP[env]);
+
+  const { signer, web3Keypair } = await loadLocalKeypairWithWeb3(keypairPath);
+  const provider = createDefaultAnchorProvider(env, web3Keypair);
+  const client = new LongYieldCarryClient(provider, env);
+  const idl = { ...IDL, address: PROGRAM_ID[env] };
+  const program: Program<LongYieldCarry> = new Program(idl as LongYieldCarry, 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: Address = address(pubkey.toBase58());
+    const lamports = BigInt(account.lamports);
+
+    try {
+      const ix = await program.methods
+        .closeCpiPlan()
+        .accountsPartial({
+          manager: signer.address,
+          cpiPlan: cpiPlanAddress,
+        })
+        .instruction()
+        .then(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/scripts/collectInterest.ts

@@ -0,0 +1,194 @@
+import "./env";
+import { type Address, type TransactionSigner } from "@solana/kit";
+import { loadLocalKeypairWithWeb3, createDefaultAnchorProvider } from "common";
+import { LongYieldCarryClient } from "../src/client/client";
+import { LYC_MANAGER_KEYPAIR_FP } from "../src/constants/general";
+import { NoOpTransactionError } from "../src/errors";
+import type { LYCToken } from "../src/models/lycToken";
+import {
+  extractKeypairFlag,
+  isLikelyKeypairPath,
+  parseCliEnvironmentAndRest,
+  resolveTokenPda,
+} from "./localUtils";
+
+/**
+ * Runs `collect_interest` for on-chain tokens with active carry exposure
+ * (non-zero yielding bank shares). One transaction per carry slot.
+ *
+ * Skips tokens with the circuit breaker on. `NoOpTransactionError` (no yield
+ * to collect, solvency guard, etc.) is treated as a successful skip.
+ *
+ * Usage:
+ *   From this package:
+ *     `pnpm run collect-interest -- test|prod [TOKEN_PDA|SYMBOL] [KEYPAIR_JSON]`
+ *   From repo root:
+ *     `pnpm run lyc:collect-interest -- test|prod [TOKEN_PDA|SYMBOL] [KEYPAIR_JSON]`
+ *
+ * With no token argument, processes every Token account. With one optional
+ * positional before the keypair, resolves that token (PDA or collateral symbol
+ * as in other LYC scripts).
+ *
+ * A single extra positional is treated as a keypair path when it looks like a
+ * file path (`*.json`, contains `/`, or starts with `~`); otherwise it is a token
+ * identifier. Use two positionals for `TOKEN` + keypair explicitly.
+ *
+ * Defaults to the manager keypair for the environment ({@link LYC_MANAGER_KEYPAIR_FP}).
+ */
+async function main() {
+  const { env, rest } = parseCliEnvironmentAndRest("collect-interest");
+  const { rest: args, keypairPath: keypairFlagPath } = extractKeypairFlag(rest);
+
+  let tokenIdentifier: string | undefined;
+  let keypairPath: string;
+
+  if (args.length === 0) {
+    keypairPath = keypairFlagPath ?? LYC_MANAGER_KEYPAIR_FP[env];
+  } else if (args.length === 1) {
+    if (isLikelyKeypairPath(args[0]!)) {
+      keypairPath = keypairFlagPath ?? args[0]!;
+    } else {
+      tokenIdentifier = args[0]!;
+      keypairPath = keypairFlagPath ?? LYC_MANAGER_KEYPAIR_FP[env];
+    }
+  } else if (args.length === 2) {
+    tokenIdentifier = args[0]!;
+    keypairPath = keypairFlagPath ?? args[1]!;
+  } else {
+    console.error(
+      "Usage: pnpm run collect-interest -- [test|prod] [TOKEN_PDA|SYMBOL] [KEYPAIR_JSON]"
+    );
+    process.exit(1);
+  }
+
+  const { signer, web3Keypair } = await loadLocalKeypairWithWeb3(keypairPath);
+  const provider = createDefaultAnchorProvider(env, web3Keypair);
+  const client = new LongYieldCarryClient(provider, env);
+
+  let tokens: LYCToken[];
+  if (tokenIdentifier !== undefined) {
+    const { tokenPda, collateralSymbol } = await resolveTokenPda(client, tokenIdentifier);
+    tokens = [await client.account.fetchToken(tokenPda, { fresh: true })];
+    console.log("Collecting interest (long-yield-carry) — single token...");
+    console.log("  token:", tokenPda, collateralSymbol ? `(${collateralSymbol})` : "");
+  } else {
+    tokens = await client.account.fetchAllTokens();
+    console.log("Collecting interest (long-yield-carry) — all tokens...");
+  }
+
+  console.log("  environment:", env);
+  console.log("  manager:", signer.address);
+  console.log("  tokens:", tokens.length);
+
+  let collected = 0;
+  let skippedNoop = 0;
+  let skippedInactive = 0;
+  let skippedNoCarry = 0;
+  let failures = 0;
+
+  for (const token of tokens) {
+    const tokenOutcomes = await collectForToken(client, signer, token);
+    collected += tokenOutcomes.collected;
+    skippedNoop += tokenOutcomes.skippedNoop;
+    skippedInactive += tokenOutcomes.skippedInactive;
+    skippedNoCarry += tokenOutcomes.skippedNoCarry;
+    failures += tokenOutcomes.failures;
+  }
+
+  console.log("\nSummary:");
+  console.log("  collected:", collected);
+  console.log("  skipped (no-op / nothing to collect):", skippedNoop);
+  console.log("  skipped (circuit breaker):", skippedInactive);
+  console.log("  skipped (no active carry):", skippedNoCarry);
+  console.log("  failures:", failures);
+
+  if (failures > 0) {
+    process.exit(1);
+  }
+}
+
+async function collectForToken(
+  client: LongYieldCarryClient,
+  signer: TransactionSigner,
+  token: LYCToken
+): Promise<{
+  collected: number;
+  skippedNoop: number;
+  skippedInactive: number;
+  skippedNoCarry: number;
+  failures: number;
+}> {
+  let collected = 0;
+  let skippedNoop = 0;
+  let skippedInactive = 0;
+  let skippedNoCarry = 0;
+  let failures = 0;
+
+  if (!token.isActive) {
+    console.log(`[skip] ${token.label} — circuit breaker active`);
+    skippedInactive++;
+    return {
+      collected,
+      skippedNoop,
+      skippedInactive,
+      skippedNoCarry,
+      failures,
+    };
+  }
+
+  const activeCarryPositions = token.activeCarryPositions;
+  if (activeCarryPositions.length === 0) {
+    skippedNoCarry++;
+    return {
+      collected,
+      skippedNoop,
+      skippedInactive,
+      skippedNoCarry,
+      failures,
+    };
+  }
+
+  for (const { index } of activeCarryPositions) {
+    const label = `${token.label} carry[${index}]`;
+    try {
+      const yieldingBank: Address = await token.deriveYieldingBankAddressForDebtCarryIndex(
+        index,
+        client.pda
+      );
+      const plan = await client.tx.collectInterest.getTx({
+        manager: signer.address,
+        token: token.address,
+        params: {
+          yieldingBank,
+        },
+      });
+      const sig = await client.sendTransaction(signer, plan);
+      console.log(`[ok] ${label} ${yieldingBank} (${sig})`);
+      collected++;
+      client.clearAllCache();
+    } catch (err) {
+      if (err instanceof NoOpTransactionError) {
+        console.log(`[noop] ${label} — ${err.message}`);
+        skippedNoop++;
+        continue;
+      }
+      failures++;
+      console.error(`[fail] ${label}: ${(err as Error).message}`);
+    }
+  }
+
+  return {
+    collected,
+    skippedNoop,
+    skippedInactive,
+    skippedNoCarry,
+    failures,
+  };
+}
+
+main()
+  .then(() => console.log("Finished"))
+  .catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });