@kestrelfi/lyc-sdk 1.0.1

package/scripts/rebalanceToken.ts

@@ -0,0 +1,269 @@
+import "./env";
+import type { Address, TransactionSigner } from "@solana/kit";
+import {
+  BUNDLE_INJECTED_IX_RESERVED_BYTES,
+  LendingPlatform,
+  loadLocalKeypairWithWeb3,
+  mints,
+  fromWeb3Pk,
+  splitIntoTransactionBins,
+  toUiAmount,
+  type DeployedEnv,
+  createDefaultAnchorProvider,
+} from "common";
+import { LongYieldCarryClient } from "../src/client/client";
+import type { LongYieldCarryTransactionPlan } from "../src/client/types";
+import { LYC_MANAGER_KEYPAIR_FP } from "../src/constants/general";
+import type { LYCToken } from "../src/models/lycToken";
+import { AllocationService } from "../src/services/allocation";
+import type { DebtReallocation } from "../src/services/allocation/types";
+import { TokenRebalanceService } from "../src/services/rebalance/token/tokenRebalanceService";
+import {
+  extractKeypairFlag,
+  isLikelyKeypairPath,
+  parseCliEnvironmentAndRest,
+  resolveTokenPda,
+} from "./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: Address): string {
+  return mints.get(mint)?.symbol ?? `${mint.slice(0, 6)}…`;
+}
+
+function logActiveLendingPositions(token: LYCToken): void {
+  console.log(`\nOn-chain lending positions — ${token.label} (${token.address}):`);
+  for (const { index, data } of token.activeLendingPositions) {
+    const dm = fromWeb3Pk(data.accounting.debt.mint);
+    const amt = toUiAmount(data.accounting.debt.amount, data.accounting.debt.decimals);
+    const pool = fromWeb3Pk(data.pool);
+    const kaminoUser = 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: string[]): {
+  positional: string[];
+  flags: Set<string>;
+  kv: Map<string, string>;
+} {
+  const positional: string[] = [];
+  const flags = new Set<string>();
+  const kv = new Map<string, string>();
+
+  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 (isLikelyKeypairPath(raw)) {
+      kv.set("keypair", raw);
+    } else {
+      positional.push(raw);
+    }
+  }
+  return { positional, flags, kv };
+}
+
+async function tryBinPackDryRun(
+  client: LongYieldCarryClient,
+  payer: TransactionSigner,
+  plan: LongYieldCarryTransactionPlan
+): Promise<void> {
+  const { value: blockhash } = await client.rpc
+    .getLatestBlockhash({ commitment: "confirmed" })
+    .send();
+  try {
+    const { bins } = await splitIntoTransactionBins(client.rpc, payer, plan.instructions, {
+      lookupTables: plan.lookupTables,
+      blockhash,
+      reservedBytes: 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 − ${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: LongYieldCarryClient,
+  managerSigner: TransactionSigner,
+  tokenAddress: Address,
+  realloc: Parameters<InstanceType<typeof TokenRebalanceService>["buildPlan"]>[1],
+  options: { dryRun: boolean; sequential: boolean }
+): Promise<void> {
+  const service = new 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(): Promise<void> {
+  const { env, rest } = parseCliEnvironmentAndRest("rebalance-token");
+  const { rest: args, keypairPath: keypairFlagPath } = 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") ?? LYC_MANAGER_KEYPAIR_FP[env as DeployedEnv];
+  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 loadLocalKeypairWithWeb3(keypairPath);
+  const provider = createDefaultAnchorProvider(env, web3Keypair);
+  const client = new LongYieldCarryClient(provider, env);
+
+  const { tokenPda } = await 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: DebtReallocation[];
+
+  if (fromAllocation) {
+    const { tokens, yieldingBanks } = await client.account.fetchAllTokensAndYieldingBanks();
+    const activeTokens = tokens.filter((t) => t.activeLendingPositions.length > 0);
+    const kaminoData = client.lendingPlatformClients.getByPlatform(LendingPlatform.Kamino).data;
+    const allocationService = new 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 = mints.get(toSymbol);
+    if (!targetMintInfo) {
+      console.error(`Unknown mint symbol: ${toSymbol}`);
+      process.exit(1);
+    }
+    const targetMint = targetMintInfo.address;
+    const currentDebtMint = 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/scripts/rebalanceYieldingBank.ts

@@ -0,0 +1,183 @@
+import "./env";
+import { address, type Address } from "@solana/kit";
+import { loadLocalKeypairWithWeb3, mints, createDefaultAnchorProvider } from "common";
+import { LongYieldCarryClient } from "../src/client/client";
+import { LYC_MANAGER_KEYPAIR_FP } from "../src/constants/general";
+import {
+  usdStarAllocationConfig,
+  usdStarJuniorAllocationConfig,
+} from "../src/constants/configs/allocations";
+import { extractKeypairFlag, isValidPubkeyString, parseCliEnvironmentAndRest } from "./localUtils";
+import { YieldingBankAllocationConfig } from "../src/client";
+
+function resolveMint(arg: string): { mint: Address; label: string } {
+  const trimmed = arg.trim();
+  const symbol = trimmed.toUpperCase();
+  const mintInfo = mints.get(symbol);
+  if (mintInfo) {
+    return { mint: mintInfo.address, label: symbol };
+  }
+
+  if (!isValidPubkeyString(trimmed)) {
+    throw new Error(
+      `Unknown mint "${arg}". Use a common mint symbol (for example USDC) or a mint address.`
+    );
+  }
+
+  return { mint: address(trimmed), label: trimmed };
+}
+
+function parseAmount(raw: string): number {
+  const trimmed = raw.trim();
+  if (!/^\d+$/.test(trimmed)) {
+    throw new Error("amount must be a positive integer in raw base units");
+  }
+
+  const amount = Number(trimmed);
+  if (!Number.isSafeInteger(amount) || amount <= 0) {
+    throw new Error("amount must be a positive safe integer");
+  }
+
+  return amount;
+}
+
+function getAutoAllocationConfigForMint(
+  targetMint: Address
+): YieldingBankAllocationConfig | undefined {
+  if (targetMint === mints.get("USD*")?.address) {
+    return usdStarAllocationConfig;
+  }
+
+  if (targetMint === mints.get("USD*-J")?.address) {
+    return usdStarJuniorAllocationConfig;
+  }
+
+  return undefined;
+}
+
+/**
+ * Rebalances a yielding bank by swapping `AMOUNT` of `SOURCE_MINT` into `TARGET_MINT`.
+ *
+ * Usage:
+ *   From this package:
+ *     `pnpm run rebalance-yielding-bank -- test|prod <YIELDING_BANK> <SOURCE_MINT> <TARGET_MINT> [AMOUNT]`
+ *   From repo root:
+ *     `pnpm run lyc:rebalance-yb -- test|prod <YIELDING_BANK> <SOURCE_MINT> <TARGET_MINT> [AMOUNT]`
+ *
+ * Mint arguments accept either common registry symbols (for example `USDC`, `USD*`)
+ * or raw mint addresses. `AMOUNT` is in raw base units. If omitted, the script
+ * fetches the yielding bank and rebalances the full source-mint holding.
+ *
+ * The signer is always the environment manager keypair: {@link LYC_MANAGER_KEYPAIR_FP}[env].
+ */
+async function main() {
+  const { env, rest } = parseCliEnvironmentAndRest("rebalance-yielding-bank");
+  const { rest: args, keypairPath: keypairFlagPath } = extractKeypairFlag(rest);
+
+  const yieldingBankArg = args[0];
+  const sourceMintArg = args[1];
+  const targetMintArg = args[2];
+  const amountArg = args[3];
+
+  if (yieldingBankArg === undefined || sourceMintArg === undefined || targetMintArg === undefined) {
+    console.error(
+      "Usage: pnpm run rebalance-yielding-bank -- [test|prod] <YIELDING_BANK> <SOURCE_MINT> <TARGET_MINT> [AMOUNT]"
+    );
+    process.exit(1);
+  }
+
+  if (!isValidPubkeyString(yieldingBankArg)) {
+    console.error(`Invalid yielding bank address "${yieldingBankArg}".`);
+    process.exit(1);
+  }
+
+  let sourceMint: Address;
+  let sourceLabel: string;
+  let targetMint: Address;
+  let targetLabel: string;
+
+  try {
+    ({ mint: sourceMint, label: sourceLabel } = resolveMint(sourceMintArg));
+    ({ mint: targetMint, label: targetLabel } = resolveMint(targetMintArg));
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+
+  if (sourceMint === targetMint) {
+    console.error("Source mint and target mint must be different.");
+    process.exit(1);
+  }
+
+  const yieldingBank = address(yieldingBankArg);
+  const { signer: managerSigner, web3Keypair } = await loadLocalKeypairWithWeb3(
+    keypairFlagPath ?? LYC_MANAGER_KEYPAIR_FP[env]
+  );
+  const provider = createDefaultAnchorProvider(env, web3Keypair);
+  const client = new LongYieldCarryClient(provider, env);
+  const bank = await client.account.fetchYieldingBank(yieldingBank);
+  const targetHolding = bank.findAssetHolding(targetMint);
+  const newAllocation =
+    targetHolding === null ? getAutoAllocationConfigForMint(targetMint) : undefined;
+
+  let amount: number;
+  if (amountArg !== undefined) {
+    try {
+      amount = parseAmount(amountArg);
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : err);
+      process.exit(1);
+    }
+  } else {
+    const sourceHolding = bank.findAssetHolding(sourceMint);
+    if (sourceHolding === null) {
+      console.error(`Yielding bank does not currently hold source mint ${sourceMint}.`);
+      process.exit(1);
+    }
+
+    try {
+      amount = parseAmount(sourceHolding.amount.toString());
+    } catch {
+      console.error(
+        `Unable to use full source balance for ${sourceMint}; holding amount is zero or exceeds a safe integer.`
+      );
+      process.exit(1);
+    }
+  }
+
+  const plan = await client.tx.rebalanceYieldingBank.getTx({
+    yieldingBank,
+    params: {
+      swaps: [
+        {
+          inputMint: sourceMint,
+          outputMint: targetMint,
+          amount,
+        },
+      ],
+      newAllocation: newAllocation ? { config: newAllocation } : undefined,
+    },
+  });
+  const sig = await client.sendTransaction(managerSigner, plan);
+
+  console.log("rebalance_yielding_bank succeeded.");
+  console.log("  environment:", env);
+  console.log("  manager:", managerSigner.address);
+  console.log("  yielding bank:", yieldingBank);
+  console.log("  source mint:", sourceMint, `(${sourceLabel})`);
+  console.log("  target mint:", targetMint, `(${targetLabel})`);
+  console.log("  amount (raw units):", amount);
+  console.log(
+    "  amount source:",
+    amountArg === undefined ? "full yielding bank source balance" : "cli"
+  );
+  console.log("  auto allocation:", newAllocation ? "added" : "not needed");
+  console.log("  signature:", sig);
+}
+
+main()
+  .then(() => console.log("Finished"))
+  .catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });

package/scripts/recollateralizeLoss.ts

@@ -0,0 +1,79 @@
+import "./env";
+import { loadLocalKeypairWithWeb3, createDefaultAnchorProvider } from "common";
+import { LongYieldCarryClient } from "../src/client/client";
+import {
+  DEFAULT_RECOLLATERALIZE_LOSS_SLIPPAGE_BPS,
+  LYC_MANAGER_KEYPAIR_FP,
+} from "../src/constants/general";
+import { composePhasedTransactionPlan } from "../src/utils";
+import { extractKeypairFlag, parseCliEnvironmentAndRest, resolveTokenPda } from "./localUtils";
+
+/**
+ * Recollateralizes a loss on a token by withdrawing collateral, swapping it
+ * for the debt asset, and repaying excess debt.
+ *
+ * Usage:
+ *   From this package: `pnpm run recollateralize-loss -- test|prod <TOKEN> [SLIPPAGE_BPS] [KEYPAIR_JSON]`
+ *   From repo root:   `pnpm run lyc:recollateralize-loss -- test|prod <TOKEN> [SLIPPAGE_BPS] [KEYPAIR_JSON]`
+ *
+ * TOKEN accepts either a Token PDA address or a collateral mint symbol (e.g. SOL).
+ * SLIPPAGE_BPS defaults to 150 (1.5%). KEYPAIR_JSON defaults to the environment manager keypair.
+ */
+async function main() {
+  const { env, rest } = parseCliEnvironmentAndRest("recollateralize-loss");
+  const { rest: args, keypairPath: keypairFlagPath } = extractKeypairFlag(rest);
+
+  const tokenArg = args[0];
+  if (tokenArg === undefined) {
+    console.error(
+      "Usage: pnpm run recollateralize-loss -- [test|prod] <TOKEN> [SLIPPAGE_BPS] [KEYPAIR_JSON]"
+    );
+    process.exit(1);
+  }
+
+  const slippageBps = args[1] !== undefined ? parseInt(args[1], 10) : undefined;
+  if (slippageBps !== undefined && (isNaN(slippageBps) || slippageBps <= 0)) {
+    console.error("SLIPPAGE_BPS must be a positive integer.");
+    process.exit(1);
+  }
+
+  const keypairPath = keypairFlagPath ?? args[2] ?? LYC_MANAGER_KEYPAIR_FP[env];
+  const { signer, web3Keypair } = await loadLocalKeypairWithWeb3(keypairPath);
+  const provider = createDefaultAnchorProvider(env, web3Keypair);
+  const client = new LongYieldCarryClient(provider, env);
+
+  const { tokenPda, collateralSymbol } = await resolveTokenPda(client, tokenArg);
+
+  console.log("Recollateralizing loss...");
+  console.log("  environment:", env);
+  console.log("  manager:", signer.address);
+  console.log("  token:", tokenPda, collateralSymbol ? `(${collateralSymbol})` : "");
+  console.log("  slippage:", slippageBps ?? DEFAULT_RECOLLATERALIZE_LOSS_SLIPPAGE_BPS, "bps");
+
+  const phases = await client.tx.recollateralizeLoss.getTx({
+    token: tokenPda,
+    params: {
+      swapSlippageBps: slippageBps,
+    },
+  });
+
+  const hasDcp = phases.length > 1;
+  console.log(`  plan: ${hasDcp ? "DCP + recollateralize" : "recollateralize only"}`);
+
+  // Submit both phases atomically while preserving their internal split
+  // boundaries. Each phase starts in a fresh transaction, but setup
+  // instructions may split away from its indivisible heap-frame + core pair.
+  const plan = composePhasedTransactionPlan(phases);
+
+  const sig = await client.sendTransaction(signer, plan);
+  console.log(`  tx: ${sig}`);
+
+  console.log("recollateralize_loss succeeded.");
+}
+
+main()
+  .then(() => console.log("Finished"))
+  .catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });

package/scripts/refresh.ts

@@ -0,0 +1,156 @@
+import "./env";
+import { type Address, type TransactionSigner } from "@solana/kit";
+import {
+  fromWeb3Pk,
+  getAtaAddress,
+  loadLocalKeypairWithWeb3,
+  resolveTokenProgram,
+  createDefaultAnchorProvider,
+} from "common";
+import { LongYieldCarryClient } from "../src/client/client";
+import { LYC_MANAGER_KEYPAIR_FP } from "../src/constants/general";
+import {
+  extractKeypairFlag,
+  isLikelyKeypairPath,
+  parseCliEnvironmentAndRest,
+  resolveTokenPda,
+} from "./localUtils";
+
+/**
+ * Refreshes LYC state.
+ *
+ * Usage:
+ *   From this package: `pnpm run refresh -- test|prod [TOKEN_PDA|COLLATERAL_SYMBOL] [KEYPAIR_JSON]`
+ *   From repo root:   `pnpm run lyc:refresh -- test|prod [TOKEN_PDA|COLLATERAL_SYMBOL] [KEYPAIR_JSON]`
+ *
+ * With no token argument, refreshes every yielding bank first, then every token.
+ * With a token argument, refreshes only that token.
+ *
+ * Refreshes are sent one account per transaction to avoid transaction-size and
+ * account-list limits from combining multiple dense refresh instructions.
+ */
+async function main() {
+  const { env, rest } = parseCliEnvironmentAndRest("refresh");
+  const { rest: args, keypairPath: keypairFlagPath } = extractKeypairFlag(rest);
+
+  const { tokenArg, keypairPath } = parseRefreshArgs(args, keypairFlagPath, env);
+
+  const { signer, web3Keypair } = await loadLocalKeypairWithWeb3(keypairPath);
+  const provider = createDefaultAnchorProvider(env, web3Keypair);
+  const client = new LongYieldCarryClient(provider, env);
+
+  if (tokenArg !== undefined) {
+    const { tokenPda, collateralSymbol } = await resolveTokenPda(client, tokenArg);
+    console.log("Refreshing long-yield-carry token...");
+    console.log("  environment:", env);
+    console.log("  signer:", signer.address);
+    console.log("  token:", tokenPda, collateralSymbol ? `(${collateralSymbol})` : "");
+    await refreshTokens(client, signer, [tokenPda]);
+    console.log("refresh succeeded.");
+    return;
+  }
+
+  const { tokens, yieldingBanks } = await client.account.fetchAllTokensAndYieldingBanks();
+
+  console.log("Refreshing long-yield-carry state...");
+  console.log("  environment:", env);
+  console.log("  signer:", signer.address);
+  console.log("  yielding banks:", yieldingBanks.length);
+  console.log("  tokens:", tokens.length);
+
+  await refreshYieldingBanks(
+    client,
+    signer,
+    yieldingBanks.map((bank) => bank.address)
+  );
+
+  client.clearAllCache();
+
+  await refreshTokens(
+    client,
+    signer,
+    tokens.map((token) => token.address)
+  );
+
+  console.log("refresh succeeded.");
+}
+
+function parseRefreshArgs(
+  args: string[],
+  keypairFlagPath: string | undefined,
+  env: "test" | "prod"
+): { tokenArg?: string; keypairPath: string } {
+  if (args.length > 2) {
+    console.error(
+      "Usage: pnpm run refresh -- [test|prod] [TOKEN_PDA|COLLATERAL_SYMBOL] [KEYPAIR_JSON]"
+    );
+    process.exit(1);
+  }
+
+  if (args.length === 0) {
+    return { keypairPath: keypairFlagPath ?? LYC_MANAGER_KEYPAIR_FP[env] };
+  }
+
+  if (args.length === 1) {
+    const arg = args[0]!;
+    if (isLikelyKeypairPath(arg)) {
+      return { keypairPath: keypairFlagPath ?? arg };
+    }
+    return { tokenArg: arg, keypairPath: keypairFlagPath ?? LYC_MANAGER_KEYPAIR_FP[env] };
+  }
+
+  return { tokenArg: args[0]!, keypairPath: keypairFlagPath ?? args[1]! };
+}
+
+async function refreshYieldingBanks(
+  client: LongYieldCarryClient,
+  signer: TransactionSigner,
+  yieldingBanks: Address[]
+) {
+  for (const [index, yieldingBank] of yieldingBanks.entries()) {
+    const plan = await client.tx.refreshYieldingBank.getTx({
+      signer: signer.address,
+      yieldingBank: yieldingBank,
+    });
+    const sig = await client.sendTransaction(signer, plan);
+    console.log(
+      `[yielding bank ${index + 1}/${yieldingBanks.length}] refreshed ${yieldingBank} (${sig})`
+    );
+  }
+}
+
+async function refreshTokens(
+  client: LongYieldCarryClient,
+  signer: TransactionSigner,
+  tokens: Address[]
+) {
+  for (const [index, tokenAddress] of tokens.entries()) {
+    const token = await client.account.fetchToken(tokenAddress, { fresh: true });
+    const collateralOracle = fromWeb3Pk(token.data.collateral.oracle);
+    const secondaryOracle = fromWeb3Pk(token.data.collateral.secondaryOracle);
+    const collateralMint = fromWeb3Pk(token.data.collateral.mint);
+    const collateralTokenProgram = resolveTokenProgram(token.data.collateral.tokenProgram);
+    const collateralTokenAccount = await getAtaAddress(
+      collateralMint,
+      token.address,
+      collateralTokenProgram
+    );
+    const plan = await client.tx.refreshTokenState.getTx({
+      signer: signer.address,
+      token: token.address,
+      collateralOracle,
+      secondaryCollateralOracle: secondaryOracle,
+      collateralTokenAccount,
+      collateralTokenProgram,
+    });
+    const sig = await client.sendTransaction(signer, plan);
+    console.log(`[token ${index + 1}/${tokens.length}] refreshed ${token.address} (${sig})`);
+  }
+}
+
+main()
+  .then(() => console.log("Finished"))
+  .catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });