@kestrelfi/lyc-sdk 1.0.1

package/scripts/emergency/deleverageAll.ts

@@ -0,0 +1,287 @@
+import "../env";
+import type { Address, TransactionSigner } from "@solana/kit";
+import {
+  fromWeb3Pk,
+  loadLocalKeypairWithWeb3,
+  mints,
+  toBigInt,
+  toUiAmount,
+  createDefaultAnchorProvider,
+} from "common";
+import { LongYieldCarryClient } from "../../src/client/client";
+import { LYC_MANAGER_KEYPAIR_FP } from "../../src/constants/general";
+import type { LYCToken } from "../../src/models/lycToken";
+import {
+  extractKeypairFlag,
+  isLikelyKeypairPath,
+  parseCliEnvironmentAndRest,
+  resolveLendingPositionIndex,
+  resolveTokenPda,
+} from "../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`;
+
+type DeployedScriptEnv = "test" | "prod";
+
+interface DeleverageArgs {
+  tokenArg?: string;
+  positionIdentifier?: string;
+  keypairPath: string;
+}
+
+interface DeleverageCounts {
+  failures: number;
+  skipped: number;
+  succeeded: number;
+}
+
+async function main() {
+  const { env, rest } = parseCliEnvironmentAndRest("deleverage-all");
+  const { rest: args, keypairPath: keypairFlagPath } = extractKeypairFlag(rest);
+  const parsed = parseDeleverageArgs(args, keypairFlagPath, env);
+
+  const { signer, web3Keypair } = await loadLocalKeypairWithWeb3(parsed.keypairPath);
+  const provider = createDefaultAnchorProvider(env, web3Keypair);
+  const client = new LongYieldCarryClient(provider, env);
+
+  console.log("Deleveraging (zeroing out debt)...");
+  console.log("  environment:", env);
+  console.log("  signer:", signer.address);
+
+  let tokens: LYCToken[];
+  let lendingPositionIndex: number | undefined;
+
+  if (parsed.tokenArg === undefined) {
+    tokens = await client.account.fetchAllTokens();
+    console.log("  scope: all tokens");
+    console.log("  tokens:", tokens.length);
+  } else {
+    const { tokenPda, collateralSymbol } = await 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 = resolveLendingPositionIndex(
+        tokens[0]!,
+        parsed.positionIdentifier,
+        tokenPda
+      );
+      console.log("  lending position index:", lendingPositionIndex);
+    }
+  }
+
+  const totals: DeleverageCounts = { 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: string[],
+  keypairFlagPath: string | undefined,
+  env: DeployedScriptEnv
+): DeleverageArgs {
+  if (args.length > 3) {
+    console.error(USAGE);
+    process.exit(1);
+  }
+
+  let keypairPath = keypairFlagPath ?? LYC_MANAGER_KEYPAIR_FP[env];
+
+  if (args.length === 0) {
+    return { keypairPath };
+  }
+
+  const first = args[0]!;
+  if (isLikelyKeypairPath(first)) {
+    if (args.length > 1) {
+      console.error(USAGE);
+      process.exit(1);
+    }
+    return { keypairPath: keypairFlagPath ?? first };
+  }
+
+  const tokenArg = first;
+  let positionIdentifier: string | undefined;
+
+  const second = args[1];
+  if (second !== undefined) {
+    if (isLikelyKeypairPath(second)) {
+      keypairPath = keypairFlagPath ?? second;
+    } else {
+      positionIdentifier = second;
+    }
+  }
+
+  const third = args[2];
+  if (third !== undefined) {
+    if (second !== undefined && isLikelyKeypairPath(second)) {
+      console.error(USAGE);
+      process.exit(1);
+    }
+    keypairPath = keypairFlagPath ?? third;
+  }
+
+  return { tokenArg, positionIdentifier, keypairPath };
+}
+
+async function deleverageToken(
+  client: LongYieldCarryClient,
+  signer: TransactionSigner,
+  token: LYCToken,
+  options: { lendingPositionIndex?: number; prefix: string }
+): Promise<DeleverageCounts> {
+  const { lendingPositionIndex, prefix } = options;
+  const counts: DeleverageCounts = { 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 = toBigInt(lp.data.accounting.debt.amount);
+    if (debtAmount === BigInt(0)) {
+      console.log(`${prefix} LP[${lp.index}] — no outstanding debt, skipping`);
+      continue;
+    }
+
+    const debtMint = fromWeb3Pk(lp.data.accounting.debt.mint);
+    const debtLabel = mints.get(debtMint)?.symbol ?? debtMint;
+    const debtUi = 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: LYCToken,
+  client: LongYieldCarryClient
+): Promise<Address[]> {
+  const seen = new Set<string>();
+  const banks: Address[] = [];
+  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/scripts/emergency/triggerCircuitBreaker.ts

@@ -0,0 +1,87 @@
+import "../env";
+import { loadLocalKeypairWithWeb3, createDefaultAnchorProvider } from "common";
+import { LongYieldCarryClient } from "../../src/client/client";
+import { LYC_CB_KEYPAIR_FP } from "../../src/constants/general";
+import {
+  setTokenCircuitBreaker,
+  setYieldingBankCircuitBreaker,
+} from "../../src/utils/transactions";
+import { extractKeypairFlag, parseCliEnvironmentAndRest } from "../localUtils";
+
+/**
+ * Triggers the circuit breaker on ALL tokens and yielding banks for a given environment.
+ *
+ * Usage:
+ *   From this package: `pnpm run trigger-cb -- test|prod [KEYPAIR_JSON]`
+ *   From repo root:   `pnpm run lyc:trigger-cb -- test|prod [KEYPAIR_JSON]`
+ *
+ * Keypair defaults to ~/.config/solana/tp-lyc-cb-{env}.json (circuit breaker controller).
+ * Admin keypair can also be used.
+ */
+async function main() {
+  const { env, rest } = parseCliEnvironmentAndRest("trigger-cb");
+  const { rest: args, keypairPath: keypairFlagPath } = extractKeypairFlag(rest);
+  const keypairPath = keypairFlagPath ?? args[0] ?? LYC_CB_KEYPAIR_FP[env];
+
+  if (args.length > 1) {
+    console.error("Usage: pnpm run trigger-cb -- [test|prod] [KEYPAIR_JSON]");
+    process.exit(1);
+  }
+
+  const { signer, web3Keypair } = await loadLocalKeypairWithWeb3(keypairPath);
+  const provider = createDefaultAnchorProvider(env, web3Keypair);
+  const client = new LongYieldCarryClient(provider, env);
+
+  const { tokens, yieldingBanks } = await client.account.fetchAllTokensAndYieldingBanks();
+
+  console.log("Triggering circuit breaker on all accounts...");
+  console.log("  environment:", env);
+  console.log("  signer:", signer.address);
+  console.log("  tokens:", tokens.length);
+  console.log("  yielding banks:", yieldingBanks.length);
+
+  let failures = 0;
+
+  for (const [i, token] of tokens.entries()) {
+    try {
+      const sig = await setTokenCircuitBreaker(client, signer, token.address, true);
+      console.log(
+        `[token ${i + 1}/${tokens.length}] ✓ circuit breaker ON  ${token.address} (${sig})`
+      );
+    } catch (err) {
+      failures++;
+      console.error(`[token ${i + 1}/${tokens.length}] ✗ FAILED ${token.address}:`, err);
+    }
+  }
+
+  for (const [i, bank] of yieldingBanks.entries()) {
+    try {
+      const sig = await setYieldingBankCircuitBreaker(client, signer, bank.address, true);
+      console.log(
+        `[yielding bank ${i + 1}/${yieldingBanks.length}] ✓ circuit breaker ON  ${
+          bank.address
+        } (${sig})`
+      );
+    } catch (err) {
+      failures++;
+      console.error(
+        `[yielding bank ${i + 1}/${yieldingBanks.length}] ✗ FAILED ${bank.address}:`,
+        err
+      );
+    }
+  }
+
+  if (failures > 0) {
+    console.error(`\n${failures} transaction(s) failed.`);
+    process.exit(1);
+  }
+
+  console.log("\nAll circuit breakers triggered successfully.");
+}
+
+main()
+  .then(() => console.log("Finished"))
+  .catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });

package/scripts/env.ts

@@ -0,0 +1,4 @@
+import { config } from "dotenv";
+import path from "path";
+
+config({ path: path.resolve(__dirname, "../.env") });

package/scripts/findTxs.ts

@@ -0,0 +1,169 @@
+import "./env";
+import {
+  createMinIntervalThrottle,
+  createReadOnlyAnchorProvider,
+  getRpcUrl,
+  jsonRpcFetchWithRetries,
+  type JsonRpcCall,
+} from "common";
+import { PROGRAM_ID } from "../src/constants/general";
+import { LongYieldCarryClient } from "../src/client/client";
+import { listLycTopLevelInstructionNames } from "../src/decoders/lycInstructionNames";
+import { parseRecordPayload } from "../src/decoders/decodeTransaction";
+import type { LycProgramTransactionRecord } from "../src/decoders/types";
+import { parseCliEnvironmentAndRest, resolveTokenPda } from "./localUtils";
+
+/**
+ * Scan a program's transaction history and print signatures matching an
+ * instruction name and optional collateral-mint filter.
+ *
+ * Usage (from this package):
+ *   pnpm run find-txs -- test|prod <INSTRUCTION> [TOKEN_SYMBOL] [LIMIT]
+ *
+ * Usage (from repo root):
+ *   pnpm run lyc:find-txs -- test|prod <INSTRUCTION> [TOKEN_SYMBOL] [LIMIT]
+ *
+ * Arguments:
+ *   INSTRUCTION         Instruction name in snake_case or camelCase (e.g. claim_incentives).
+ *   TOKEN_PDA|SYMBOL    Optional. Collateral symbol (e.g. SOL) or Token PDA address.
+ *                       Resolves to the Token PDA and filters to txs whose account
+ *                       keys include that PDA.
+ *   LIMIT               Optional. Stop after printing this many matching signatures
+ *                       (default: unlimited).
+ *
+ * Examples:
+ *   pnpm run find-txs -- test claim_incentives sol 1
+ *   pnpm run find-txs -- prod mint_token usdc 5
+ */
+
+// snake_case → camelCase (claim_incentives → claimIncentives)
+function toCamelCase(s: string): string {
+  return s.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+
+interface SignaturePage {
+  signature: string;
+  slot: number;
+  blockTime: number | null;
+  err: unknown;
+}
+
+async function main(): Promise<void> {
+  const { env, rest } = parseCliEnvironmentAndRest("find-txs");
+
+  if (rest.length < 1) {
+    console.error("Usage: pnpm run find-txs -- test|prod <INSTRUCTION> [TOKEN_SYMBOL] [LIMIT]");
+    process.exit(1);
+  }
+
+  const ixArg = rest[0]!;
+  const ixName = toCamelCase(ixArg); // normalise to camelCase for comparison
+
+  let tokenPdaFilter: string | undefined;
+  let tokenPdaLabel: string | undefined;
+  let limit: number | undefined;
+
+  for (const arg of rest.slice(1)) {
+    const asNum = parseInt(arg, 10);
+    if (Number.isFinite(asNum) && asNum > 0) {
+      limit = asNum;
+      continue;
+    }
+    // Treat as a collateral mint identifier — resolve to the Token PDA
+    const provider = createReadOnlyAnchorProvider(env);
+    const client = new LongYieldCarryClient(provider, env);
+    const { tokenPda, collateralSymbol } = await resolveTokenPda(client, arg);
+    tokenPdaFilter = String(tokenPda);
+    tokenPdaLabel = collateralSymbol ?? arg;
+  }
+
+  const programId = String(PROGRAM_ID[env]);
+  const rpcUrl = getRpcUrl(env);
+
+  console.error(`env:         ${env}`);
+  console.error(`program:     ${programId}`);
+  console.error(`instruction: ${ixName}`);
+  if (tokenPdaFilter) console.error(`token PDA:   ${tokenPdaFilter}  (${tokenPdaLabel})`);
+  if (limit !== undefined) console.error(`limit:       ${limit}`);
+  console.error("");
+
+  const throttle = createMinIntervalThrottle(200);
+  const rpcCall: JsonRpcCall = <T>(method: string, params: unknown[]) =>
+    jsonRpcFetchWithRetries(throttle, rpcUrl, method, params, 6, 500);
+
+  const PAGE = 1000;
+  let before: string | undefined;
+  let found = 0;
+  let scanned = 0;
+
+  outer: while (true) {
+    const page = await rpcCall<SignaturePage[]>("getSignaturesForAddress", [
+      programId,
+      {
+        limit: PAGE,
+        commitment: "confirmed",
+        ...(before ? { before } : {}),
+      },
+    ]);
+
+    if (page.length === 0) break;
+
+    for (const sigInfo of page) {
+      scanned++;
+      if (sigInfo.err != null) continue; // skip failed txs
+
+      // Fetch the full transaction
+      let payload: unknown;
+      try {
+        payload = await rpcCall<unknown>("getTransaction", [
+          sigInfo.signature,
+          {
+            commitment: "confirmed",
+            encoding: "json",
+            maxSupportedTransactionVersion: 0,
+          },
+        ]);
+      } catch {
+        console.error(`[warn] getTransaction failed for ${sigInfo.signature}`);
+        continue;
+      }
+      if (!payload) continue;
+
+      const record: LycProgramTransactionRecord = {
+        source: "lyc-program-transaction",
+        receivedAt: 0,
+        signature: sigInfo.signature,
+        slot: sigInfo.slot,
+        payload,
+      };
+
+      const names = listLycTopLevelInstructionNames(record);
+      if (!names || !names.includes(ixName)) continue;
+
+      // Apply optional token PDA filter — check account keys
+      if (tokenPdaFilter) {
+        const parsed = parseRecordPayload(record);
+        if (!parsed || !parsed.keys.includes(tokenPdaFilter)) continue;
+      }
+
+      found++;
+      const ts = sigInfo.blockTime
+        ? new Date(sigInfo.blockTime * 1000).toISOString()
+        : "unknown-time";
+      console.log(`${sigInfo.signature}  slot=${sigInfo.slot}  time=${ts}`);
+
+      if (limit !== undefined && found >= limit) break outer;
+    }
+
+    const oldest = page[page.length - 1]!;
+    if (page.length < PAGE) break;
+    before = oldest.signature;
+  }
+
+  console.error(`\nscanned ${scanned} txs, found ${found} match(es).`);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/scripts/increaseCarryPositions.ts

@@ -0,0 +1,134 @@
+import "./env";
+import { loadLocalKeypairWithWeb3, LendingPlatform, createDefaultAnchorProvider } from "common";
+import { LongYieldCarryClient } from "../src/client/client";
+import { LYC_MANAGER_KEYPAIR_FP } from "../src/constants/general";
+import { LycLendingPositionManager } from "../src/services/carry/lycLendingPositionManager";
+import { NoOpTransactionError, isSkippableLycTransactionError } from "../src/errors";
+import { resolveYieldingBankForPosition } from "../src/utils/yieldingBank";
+import { extractKeypairFlag, parseCliEnvironmentAndRest, resolveTokenPda } from "./localUtils";
+
+/**
+ * Increases carry positions for all eligible lending positions on a given token.
+ *
+ * For each active Kamino lending position whose LTV utilization has fallen
+ * below the lower trigger band, borrows additional debt to push utilization
+ * back toward the target and deposits the proceeds into the yielding bank.
+ *
+ * Usage:
+ *   pnpm run increase-carry -- [test|prod] <TOKEN_PDA|COLLATERAL_SYMBOL> [KEYPAIR_JSON]
+ *
+ * KEYPAIR_JSON defaults to the manager keypair for the environment.
+ */
+async function main() {
+  const { env, rest } = parseCliEnvironmentAndRest("increase-carry");
+  const { rest: args, keypairPath: keypairFlagPath } = extractKeypairFlag(rest);
+
+  const tokenArg = args[0];
+  const keypairPath = keypairFlagPath ?? args[1] ?? LYC_MANAGER_KEYPAIR_FP[env];
+
+  if (tokenArg === undefined) {
+    console.error(
+      "Usage: pnpm run increase-carry -- [test|prod] <TOKEN_PDA|COLLATERAL_SYMBOL> [KEYPAIR_JSON]"
+    );
+    process.exit(1);
+  }
+
+  const { signer: managerSigner, web3Keypair } = await loadLocalKeypairWithWeb3(keypairPath);
+  const provider = createDefaultAnchorProvider(env, web3Keypair);
+  const client = new LongYieldCarryClient(provider, env);
+
+  const { tokenPda, collateralSymbol } = await resolveTokenPda(client, tokenArg);
+
+  console.log(`Token PDA: ${tokenPda} (collateral: ${collateralSymbol ?? "unknown"})`);
+  console.log(`Environment: ${env}`);
+  console.log(`Manager: ${managerSigner.address}`);
+
+  // Refresh token state so utilization rates are current
+  const refreshPlan = await client.tx.refreshTokens.getTx({
+    signer: managerSigner.address,
+    params: {
+      tokens: [tokenPda],
+    },
+  });
+  await client.sendTransaction(managerSigner, refreshPlan);
+  client.clearAllCache();
+
+  const tokenData = await client.account.fetchToken(tokenPda, { fresh: true });
+  const { yieldingBanks: allBanks } = await client.account.fetchAllTokensAndYieldingBanks();
+
+  const yieldingBank = resolveYieldingBankForPosition(allBanks);
+  if (!yieldingBank) {
+    console.error("No active yielding bank available. Cannot increase carry positions.");
+    process.exit(1);
+  }
+
+  let succeeded = 0;
+  let skipped = 0;
+  let failures = 0;
+
+  for (const { index: i, data: position } of tokenData.usedLendingPositions) {
+    if (client.lendingPlatformClients.getPlatformForPosition(position) !== LendingPlatform.Kamino) {
+      continue;
+    }
+
+    const label = `LP[${i}]`;
+
+    try {
+      const lycLendingPositionManager = await LycLendingPositionManager.create(
+        client.getLendingPlatformClient(position).data,
+        position
+      );
+      const shouldIncrease = await lycLendingPositionManager.shouldIncreaseCarryPosition();
+
+      if (!shouldIncrease) {
+        console.log(`${label} — utilization within target band, skipping`);
+        skipped++;
+        continue;
+      }
+
+      const uiBorrow = await lycLendingPositionManager.calcDebtChangeAmount();
+      console.log(`${label} — borrowing ${uiBorrow} to increase carry position...`);
+
+      const plan = await client.tx.increaseCarryPosition.getTx({
+        manager: managerSigner.address,
+        token: tokenPda,
+        params: {
+          lendingPositionIndex: i,
+          yieldingBank,
+          uiAmount: uiBorrow,
+        },
+      });
+      const sig = await client.sendTransaction(managerSigner, plan);
+
+      console.log(`${label} ✓ increased carry position (${sig})`);
+      succeeded++;
+
+      client.clearAllCache();
+    } catch (err) {
+      if (err instanceof NoOpTransactionError) {
+        console.log(`${label} — skipped: ${err.message}`);
+        skipped++;
+        continue;
+      }
+      if (isSkippableLycTransactionError(err)) {
+        console.log(`${label} — skipped: utilization guard rejected increase`);
+        skipped++;
+        continue;
+      }
+      failures++;
+      console.error(`${label} ✗ failed: ${(err as Error).message}`);
+    }
+  }
+
+  console.log(`\nSummary: ${succeeded} succeeded, ${skipped} skipped, ${failures} failed`);
+  if (failures > 0) {
+    process.exit(1);
+  }
+}
+
+main()
+  .then(() => console.log("Finished"))
+  .catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });