@kestrelfi/lyc-sdk 1.0.1

package/scripts/collectProtocolFees.ts

@@ -0,0 +1,144 @@
+import "./env";
+import { type TransactionSigner } from "@solana/kit";
+import {
+  loadLocalKeypairWithWeb3,
+  toBigInt,
+  toUiAmount,
+  createDefaultAnchorProvider,
+} from "common";
+import { LongYieldCarryClient } from "../src/client/client";
+import { LYC_ADMIN_KEYPAIR_FP } from "../src/constants/general";
+import type { LYCToken } from "../src/models/lycToken";
+import {
+  extractKeypairFlag,
+  isLikelyKeypairPath,
+  parseCliEnvironmentAndRest,
+  resolveTokenPda,
+} from "./localUtils";
+
+/**
+ * Collects pending protocol fees (mint & burn fee share) for all tokens.
+ * The signer must be the program-level `PROTOCOL_ADMIN`.
+ *
+ * Skips tokens whose `pending_protocol_fees` are zero and tokens with the
+ * circuit breaker active.
+ *
+ * Usage:
+ *   From this package:
+ *     `pnpm run collect-protocol-fees -- test|prod [TOKEN_PDA|SYMBOL] [KEYPAIR_JSON]`
+ *   From repo root:
+ *     `pnpm run lyc:collect-protocol-fees -- 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).
+ *
+ * Defaults to the admin keypair for the environment ({@link LYC_ADMIN_KEYPAIR_FP}).
+ */
+async function main(): Promise<void> {
+  const { env, rest } = parseCliEnvironmentAndRest("collect-protocol-fees");
+  const { rest: args, keypairPath: keypairFlagPath } = extractKeypairFlag(rest);
+
+  let tokenIdentifier: string | undefined;
+  let keypairPath: string;
+
+  if (args.length === 0) {
+    keypairPath = keypairFlagPath ?? LYC_ADMIN_KEYPAIR_FP[env];
+  } else if (args.length === 1) {
+    if (isLikelyKeypairPath(args[0]!)) {
+      keypairPath = keypairFlagPath ?? args[0]!;
+    } else {
+      tokenIdentifier = args[0]!;
+      keypairPath = keypairFlagPath ?? LYC_ADMIN_KEYPAIR_FP[env];
+    }
+  } else if (args.length === 2) {
+    tokenIdentifier = args[0]!;
+    keypairPath = keypairFlagPath ?? args[1]!;
+  } else {
+    console.error(
+      "Usage: pnpm run collect-protocol-fees -- [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 protocol fees (long-yield-carry) — single token...");
+    console.log("  token:", tokenPda, collateralSymbol ? `(${collateralSymbol})` : "");
+  } else {
+    tokens = await client.account.fetchAllTokens();
+    console.log("Collecting protocol fees (long-yield-carry) — all tokens...");
+  }
+
+  console.log("  environment:", env);
+  console.log("  authority:", signer.address);
+  console.log("  tokens:", tokens.length);
+
+  let collected = 0;
+  let skippedZero = 0;
+  let skippedInactive = 0;
+  let failures = 0;
+
+  for (const token of tokens) {
+    const result = await collectForToken(client, signer, token);
+    collected += result.collected;
+    skippedZero += result.skippedZero;
+    skippedInactive += result.skippedInactive;
+    failures += result.failures;
+  }
+
+  console.log("\nSummary:");
+  console.log("  collected:", collected);
+  console.log("  skipped (zero pending fees):", skippedZero);
+  console.log("  skipped (circuit breaker):", skippedInactive);
+  console.log("  failures:", failures);
+
+  if (failures > 0) {
+    process.exit(1);
+  }
+}
+
+async function collectForToken(
+  client: LongYieldCarryClient,
+  signer: TransactionSigner,
+  token: LYCToken
+): Promise<{ collected: number; skippedZero: number; skippedInactive: number; failures: number }> {
+  if (!token.isActive) {
+    console.log(`[skip] ${token.label} — circuit breaker active`);
+    return { collected: 0, skippedZero: 0, skippedInactive: 1, failures: 0 };
+  }
+
+  const pendingRaw = toBigInt(token.data.accounting.pendingProtocolFees);
+  if (pendingRaw <= 0n) {
+    console.log(`[skip] ${token.label} — no pending protocol fees`);
+    return { collected: 0, skippedZero: 1, skippedInactive: 0, failures: 0 };
+  }
+
+  const pendingUi = toUiAmount(token.data.accounting.pendingProtocolFees, token.decimals);
+  try {
+    const plan = await client.tx.collectFees.getTx({
+      token: token.address,
+      authority: signer.address,
+    });
+    const sig = await client.sendTransaction(signer, plan);
+    console.log(`[ok] ${token.label} — ${pendingUi.toLocaleString("en-US")} yTokens (${sig})`);
+    client.clearAllCache();
+    return { collected: 1, skippedZero: 0, skippedInactive: 0, failures: 0 };
+  } catch (err) {
+    console.error(`[fail] ${token.label}: ${(err as Error).message}`);
+    return { collected: 0, skippedZero: 0, skippedInactive: 0, failures: 1 };
+  }
+}
+
+main()
+  .then(() => console.log("Finished"))
+  .catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });

package/scripts/computeOptimalAllocations.ts

@@ -0,0 +1,117 @@
+import "./env";
+import type { Address } from "@solana/kit";
+import { Keypair } from "@solana/web3.js";
+import { LendingPlatform, mints, createDefaultAnchorProvider } from "common";
+import { LongYieldCarryClient } from "../src/client/client";
+import type { LYCToken } from "../src/models/lycToken";
+import { AllocationService } from "../src/services/allocation";
+import type { DebtReallocation } from "../src/services/allocation";
+import { parseCliEnvironmentAndRest } from "./localUtils";
+
+/**
+ * Fetches all on-chain tokens and reports the optimal debt allocation per
+ * active lending position, as computed by {@link AllocationService}.
+ *
+ * Usage:
+ *   From this package: `pnpm run compute-optimal-allocations -- test|prod`
+ *   From repo root:    `pnpm run lyc:compute-optimal-allocations -- test|prod`
+ *
+ * This is a read-only analysis — no transactions are sent.
+ */
+async function main() {
+  const { env } = parseCliEnvironmentAndRest("compute-optimal-allocations");
+
+  const provider = createDefaultAnchorProvider(env, Keypair.generate());
+  const client = new LongYieldCarryClient(provider, env);
+
+  console.log(`Fetching tokens and yielding banks (env=${env})...`);
+  const { tokens, yieldingBanks } = await client.account.fetchAllTokensAndYieldingBanks();
+  const activeTokens = tokens.filter((t) => t.activeLendingPositions.length > 0);
+  console.log(`  tokens: ${tokens.length} (${activeTokens.length} with active lending positions)`);
+
+  if (activeTokens.length === 0) {
+    console.log("No tokens with active lending positions. Nothing to optimize.");
+    return;
+  }
+
+  const kaminoData = client.lendingPlatformClients.getByPlatform(LendingPlatform.Kamino).data;
+  const allocationService = new AllocationService(kaminoData, {
+    logger: console.log,
+    yieldingBanks,
+  });
+
+  console.log("Computing optimal allocations...");
+  const reallocations = await allocationService.computeOptimalAllocations(activeTokens);
+
+  console.log(
+    `Found ${reallocations.length} suggested reallocation(s) out of ${activeTokens.reduce(
+      (n, t) => n + t.activeLendingPositions.length,
+      0
+    )} active position(s).\n`
+  );
+
+  if (reallocations.length === 0) {
+    console.log("All positions are already optimally allocated.");
+    return;
+  }
+
+  for (const realloc of reallocations) {
+    printReallocation(realloc, activeTokens);
+  }
+}
+
+function printReallocation(realloc: DebtReallocation, tokens: LYCToken[]) {
+  const token = tokens.find((t) => t.address === realloc.token);
+  const tokenLabel = token?.label ?? realloc.token;
+  const borrowDeltaBps = Math.round(
+    (realloc.projectedBorrowApy - realloc.currentBorrowApy) * 10_000
+  );
+
+  console.log("─".repeat(78));
+  console.log(`Token:             ${tokenLabel} (${realloc.token})`);
+  console.log(`Position index:    ${realloc.lendingPositionIndex}`);
+
+  const incentiveNote =
+    realloc.currentSupplyIncentiveApy > 0
+      ? `  (+ ${formatApy(realloc.currentSupplyIncentiveApy)} supply incentive on collateral)`
+      : "";
+  console.log(`Current borrow APY:   ${formatApy(realloc.currentBorrowApy)}${incentiveNote}`);
+  console.log("Current allocation:");
+  printAllocationRow(
+    mintSymbol(realloc.currentDebtMint),
+    realloc.currentDebtAmountUi,
+    10_000 // 100% is in the current debt mint
+  );
+
+  console.log(
+    `Projected borrow APY: ${formatApy(realloc.projectedBorrowApy)}  (Δ ${
+      borrowDeltaBps > 0 ? "+" : ""
+    }${borrowDeltaBps} bps)`
+  );
+  console.log("Target allocation:");
+  for (const target of realloc.targets) {
+    printAllocationRow(mintSymbol(target.mint), target.amountUi, target.weightBps);
+  }
+  console.log();
+}
+
+function printAllocationRow(symbol: string, amountUi: number, weightBps: number) {
+  const pct = (weightBps / 100).toFixed(2);
+  const amount = amountUi.toLocaleString(undefined, { maximumFractionDigits: 2 });
+  console.log(`  ${pct.padStart(6)}%  ${symbol.padEnd(6)}  ${amount}`);
+}
+
+function mintSymbol(mint: Address): string {
+  return mints.get(mint)?.symbol ?? mint.slice(0, 6);
+}
+
+function formatApy(x: number): string {
+  return `${(x * 100).toFixed(3)}%`;
+}
+
+main()
+  .then(() => console.log("Done."))
+  .catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });

package/scripts/createToken.ts

@@ -0,0 +1,100 @@
+import "./env";
+import {
+  mints,
+  enumToOracleType,
+  loadLocalKeypairWithWeb3,
+  createDefaultAnchorProvider,
+} from "common";
+import { oracle } from "oracle";
+import { TOKEN_PROGRAM_ADDRESS } from "@solana-program/token";
+import { LongYieldCarryClient } from "../src/client/client";
+import {
+  type CreateTokenParams,
+  enumToInterestDistribution,
+  InterestDistribution,
+} from "../src/client/types";
+import { PROTOCOL_ADMIN, LYC_ADMIN_KEYPAIR_FP } from "../src/constants/general";
+import { extractKeypairFlag, parseCliEnvironmentAndRest } from "./localUtils";
+import { createYTokenMint } from "../src/utils/transactions";
+
+/**
+ * Creates a yToken mint (authority = token PDA) and registers it via `create_token`.
+ *
+ * Usage:
+ *   From this package: `pnpm run create-token -- [test|prod] [COLLATERAL_SYMBOL]`
+ *   From repo root:   `pnpm run lyc:create-token -- [test|prod] [COLLATERAL_SYMBOL]`
+ *   Or: `npx tsx scripts/createToken.ts …` with cwd = this package.
+ *
+ * Collateral defaults to SOL (registry + oracle). Admin keypair: {@link LYC_ADMIN_KEYPAIR_FP}[env].
+ * Afterward, run `pnpm run update-token-luts` if you use LUTs.
+ */
+async function main() {
+  const { env, rest } = parseCliEnvironmentAndRest("create-token");
+  const { rest: args, keypairPath: keypairFlagPath } = extractKeypairFlag(rest);
+  const collateralSymbol = (args[0] ?? "SOL").toUpperCase();
+  const collateral = mints.get(collateralSymbol);
+  if (!collateral) {
+    console.error(
+      `Unknown collateral symbol "${collateralSymbol}". Known symbols use the common mint registry.`
+    );
+    process.exit(1);
+  }
+
+  const { signer: adminSigner, web3Keypair } = await loadLocalKeypairWithWeb3(
+    keypairFlagPath ?? LYC_ADMIN_KEYPAIR_FP[env]
+  );
+  const provider = createDefaultAnchorProvider(env, web3Keypair);
+  const client = new LongYieldCarryClient(provider, env);
+
+  const oracleData = oracle.getOracleData(collateralSymbol);
+
+  const { mintSigner, tokenPda, id } = await createYTokenMint(
+    client,
+    adminSigner,
+    collateral.decimals
+  );
+
+  const params: CreateTokenParams = {
+    id,
+    interestDistribution: enumToInterestDistribution(InterestDistribution.IntoTokenPrice),
+    oracleConfig: {
+      oracle: oracleData.oracle,
+      oracleType: enumToOracleType(oracleData.oracleType),
+      ...(oracleData.secondaryOracle ? { secondaryOracle: oracleData.secondaryOracle } : {}),
+    },
+    feeConfig: {
+      performanceFeeBps: 500,
+      mintingFeeBps: 30,
+      burningFeeBps: 30,
+      protocolMintBurnPctBps: 5000,
+      curatorMintBurnPctBps: 5000,
+      curatorPerfPctBps: 5000,
+    },
+  };
+
+  const plan = await client.tx.createToken.getTx({
+    mint: mintSigner.address,
+    collateralMint: collateral.address,
+    params,
+    tokenProgram: TOKEN_PROGRAM_ADDRESS,
+    collateralTokenProgram: collateral.tokenProgram,
+  });
+
+  await client.sendTransaction(adminSigner, plan);
+
+  console.log("create_token succeeded.");
+  console.log("  environment:", env);
+  console.log("  admin (must match on-chain):", PROTOCOL_ADMIN[env]);
+  console.log("  yToken mint:", mintSigner.address);
+  console.log("  token PDA:", tokenPda);
+  console.log("  collateral mint:", collateral.address);
+  console.log("  Save mintSigner secret if you need it later; it is not written to disk here.");
+  console.log("  If you use lookup tables, run: pnpm run update-token-luts --", env);
+}
+
+main()
+  .then(() => console.log("Finished"))
+  .catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });

package/scripts/createTokenLendingPosition.ts

@@ -0,0 +1,204 @@
+import "./env";
+import { type Address, address } from "@solana/kit";
+import {
+  LendingPlatform,
+  loadLocalKeypairWithWeb3,
+  mints,
+  createDefaultAnchorProvider,
+} from "common";
+import { ReservesManager } from "lending-platforms";
+import { resolveDefaultPool } from "../src/utils/lendingPosition";
+import { LongYieldCarryClient } from "../src/client/client";
+import { AllocationService } from "../src/services/allocation";
+import { computeCarryLendingAllocationConfig } from "../src/services/carry/carryAllocationConfig";
+import { LYC_MANAGER_KEYPAIR_FP } from "../src/constants/general";
+import {
+  extractKeypairFlag,
+  parseCliEnvironmentAndRest,
+  resolveTokenPda,
+  isValidPubkeyString,
+  VOLATILITY_REGIMES,
+  ASSET_PRESETS,
+  isVolatilityRegime,
+  resolvePresets,
+} from "./localUtils";
+
+const USAGE = `Usage:
+
+  pnpm run create-lp -- [test|prod] <TOKEN> <lowVol|highVol> [DEBT_SYMBOL] [POOL] [KEYPAIR_JSON]
+
+  Example: pnpm run create-lp -- test SOL lowVol
+  Example: pnpm run create-lp -- test SOL highVol USDT
+  Example: pnpm run create-lp -- test SOL lowVol USDC <pool-address>
+
+  DEBT_SYMBOL: explicit debt mint, or omit to auto-select the optimal debt mint via AllocationService.
+  POOL defaults to auto-resolved from collateral mint.
+  Available presets: ${Object.keys(ASSET_PRESETS).join(", ")}
+  Volatility regimes: ${VOLATILITY_REGIMES.join(", ")}`;
+
+function parsePoolArg(arg: string | undefined): Address | undefined {
+  if (!arg) return undefined;
+  if (!isValidPubkeyString(arg)) {
+    console.error(`Invalid pool address: "${arg}". Must be a base58-encoded public key.`);
+    process.exit(1);
+  }
+  return address(arg);
+}
+
+/**
+ * Creates a new token lending position on a given token.
+ *
+ * Resolves the carry trade preset for the collateral asset and volatility regime,
+ * fetches `maxLtv` and `liquidationThreshold` from the on-chain reserves, and
+ * computes the BPS config via `computeCarryLendingAllocationConfig`.
+ */
+async function main() {
+  const rawArgs = process.argv.slice(2).filter((a) => a !== "--");
+  if (rawArgs.length < 3) {
+    console.error(USAGE);
+    process.exit(1);
+  }
+
+  const { env, rest } = parseCliEnvironmentAndRest("create-lp");
+  const { rest: args, keypairPath: keypairFlagPath } = extractKeypairFlag(rest);
+
+  if (args.length < 2) {
+    console.error(USAGE);
+    process.exit(1);
+  }
+
+  const [tokenArg, regimeArg, ...remaining] = args;
+
+  if (!isVolatilityRegime(regimeArg)) {
+    console.error(
+      `Invalid volatility regime "${regimeArg}". Must be one of: ${VOLATILITY_REGIMES.join(", ")}\n`
+    );
+    console.error(USAGE);
+    process.exit(1);
+  }
+
+  const explicitDebtSymbol = remaining[0]?.toUpperCase();
+  const poolOverride = parsePoolArg(remaining[1]);
+  const keypairPath = keypairFlagPath ?? remaining[2] ?? LYC_MANAGER_KEYPAIR_FP[env];
+
+  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);
+  const tokenData = await client.account.fetchToken(tokenPda, { fresh: true });
+  const collateralMint = tokenData.collateralMint;
+  const symbol = collateralSymbol ?? tokenArg;
+  const kaminoClient = client.getLendingPlatformClientByPlatform(LendingPlatform.Kamino);
+  const pool = poolOverride ?? resolveDefaultPool(collateralMint);
+
+  const entry = resolvePresets(symbol);
+  if (!entry) {
+    console.error(
+      `No carry preset found for "${symbol}". Available: ${Object.keys(ASSET_PRESETS).join(", ")}.`
+    );
+    process.exit(1);
+  }
+
+  const preset = entry.presets[regimeArg];
+  console.log(`Using preset: ${symbol.toUpperCase()}.${regimeArg}`);
+  console.log(
+    `  drawdownPctFromTargetToLiq: ${preset.drawdownPctFromTargetToLiq}%\n` +
+      `  drawdownPctFromUnwindToLiq: ${preset.drawdownPctFromUnwindToLiq}%\n` +
+      `  maxPriceChangeUpPercent:    ${preset.maxPriceChangeUpPercent}%`
+  );
+
+  const collateralReserve = await kaminoClient.data.fetchReserveByMint(pool, collateralMint);
+  if (!collateralReserve) {
+    console.error(`No Kamino reserve found for collateral mint ${collateralMint} in pool ${pool}`);
+    process.exit(1);
+  }
+
+  // Resolve debt mint: use explicit arg if provided, otherwise find the optimal one
+  let debtSymbol: string;
+  let debtMintAddress: Address;
+
+  if (explicitDebtSymbol) {
+    const debtMintInfo = mints.get(explicitDebtSymbol);
+    if (!debtMintInfo) {
+      console.error(
+        `Unknown debt mint symbol "${explicitDebtSymbol}". Known symbols use the common mint registry.`
+      );
+      process.exit(1);
+    }
+    debtSymbol = explicitDebtSymbol;
+    debtMintAddress = debtMintInfo.address;
+  } else {
+    console.log("\nNo debt symbol specified — finding optimal debt mint...");
+    const yieldingBanks = await client.account.fetchAllYieldingBanks();
+    const allocationService = new AllocationService(kaminoClient.data, {
+      logger: console.log,
+      yieldingBanks,
+    });
+    const optimal = await allocationService.findOptimalDebtMint(pool, collateralReserve, tokenData);
+    if (!optimal) {
+      console.error("No viable debt mint candidates found on this pool.");
+      process.exit(1);
+    }
+    debtSymbol = optimal.symbol;
+    debtMintAddress = optimal.mint;
+    console.log(
+      `  Selected: ${debtSymbol} (borrow APY: ${(optimal.borrowApy * 100).toFixed(3)}%)\n`
+    );
+  }
+
+  const debtReserve = await kaminoClient.data.fetchReserveByMint(pool, debtMintAddress);
+  if (!debtReserve) {
+    console.error(`No Kamino reserve found for debt mint ${debtMintAddress} in pool ${pool}`);
+    process.exit(1);
+  }
+
+  const rm = new ReservesManager(collateralReserve, debtReserve);
+  const maxLtv = rm.maxLtv;
+  const liqThreshPct = rm.supplyReserve.config.liquidationThresholdPct;
+  const liquidationThreshold = liqThreshPct <= 1 ? liqThreshPct : liqThreshPct / 100;
+
+  console.log(
+    `  maxLtv: ${(maxLtv * 100).toFixed(1)}%, liquidationThreshold: ${(
+      liquidationThreshold * 100
+    ).toFixed(1)}%`
+  );
+
+  const config = computeCarryLendingAllocationConfig({
+    ...preset,
+    maxLtv,
+    liquidationThreshold,
+  });
+
+  console.log(`\nToken PDA: ${tokenPda} (collateral: ${symbol})`);
+  console.log(`Debt: ${debtSymbol} (${debtMintAddress})`);
+  console.log(`Pool: ${pool}`);
+  console.log(`Collateral reserve: ${collateralReserve.address}`);
+  console.log(`Debt reserve: ${debtReserve.address}`);
+  console.log("");
+  console.log("Lending position config:");
+  console.log(`  targetUtilizationRateBps:        ${config.targetUtilizationRateBps}`);
+  console.log(`  maxDeviationAboveTargetUtilBps:  ${config.maxDeviationAboveTargetUtilBps}`);
+  console.log(`  maxDeviationBelowTargetUtilBps:  ${config.maxDeviationBelowTargetUtilBps}`);
+
+  const plan = await client.tx.createTokenLendingPosition.getTx({
+    token: tokenPda,
+    debtMint: debtMintAddress,
+    pool,
+    ...config,
+  });
+  const sig = await client.sendTransaction(managerSigner, plan);
+
+  console.log("");
+  console.log("create_token_lending_position succeeded.");
+  console.log("  environment:", env);
+  console.log("  manager:", managerSigner.address);
+  console.log("  signature:", sig);
+}
+
+main()
+  .then(() => console.log("Finished"))
+  .catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });

package/scripts/createYieldingBank.ts

@@ -0,0 +1,91 @@
+import "./env";
+import {
+  mints,
+  enumToOracleType,
+  loadLocalKeypairWithWeb3,
+  createDefaultAnchorProvider,
+} from "common";
+import { oracle } from "oracle";
+import { LongYieldCarryClient } from "../src/client/client";
+import type { CreateYieldingBankParams } from "../src/client/types";
+import { PROTOCOL_ADMIN, LYC_ADMIN_KEYPAIR_FP } from "../src/constants/general";
+import { findFreeYieldingBankId } from "../src/utils/data";
+import { extractKeypairFlag, parseCliEnvironmentAndRest } from "./localUtils";
+
+/**
+ * Registers a new yielding bank for a base mint via `create_yielding_bank`.
+ *
+ * Usage (use `tsx` via pnpm below):
+ *   From this package: `pnpm run create-yielding-bank -- …`
+ *   From repo root:   `pnpm run lyc:create-yielding-bank -- …`
+ *
+ * Base mint defaults to USDC. Default redemption mint symbol defaults to USD* (mint registry).
+ * Admin keypair: {@link LYC_ADMIN_KEYPAIR_FP}[env].
+ */
+async function main() {
+  const { env, rest } = parseCliEnvironmentAndRest("create-yielding-bank");
+  const { rest: args, keypairPath: keypairFlagPath } = extractKeypairFlag(rest);
+  const baseSymbol = (args[0] ?? "USDC").toUpperCase();
+  const baseMint = mints.get(baseSymbol);
+  if (!baseMint) {
+    console.error(
+      `Unknown base mint symbol "${baseSymbol}". Known symbols use the common mint registry.`
+    );
+    process.exit(1);
+  }
+
+  const redemptionSymbol = (args[1] ?? "USD*").toUpperCase();
+  const redemptionMint = mints.get(redemptionSymbol);
+  if (!redemptionMint) {
+    console.error(
+      `Unknown default redemption mint symbol "${redemptionSymbol}". Known symbols use the common mint registry.`
+    );
+    process.exit(1);
+  }
+
+  const { signer: adminSigner, web3Keypair } = await loadLocalKeypairWithWeb3(
+    keypairFlagPath ?? LYC_ADMIN_KEYPAIR_FP[env]
+  );
+  const provider = createDefaultAnchorProvider(env, web3Keypair);
+  const client = new LongYieldCarryClient(provider, env);
+
+  const id = await findFreeYieldingBankId(client, baseMint.address);
+  const oracleData = oracle.getOracleData(baseSymbol);
+
+  const params: CreateYieldingBankParams = {
+    id,
+    oracleConfig: {
+      oracle: oracleData.oracle,
+      oracleType: enumToOracleType(oracleData.oracleType),
+    },
+    defaultRedemptionMint: redemptionMint.address,
+  };
+
+  const plan = await client.tx.createYieldingBank.getTx({
+    baseMint: baseMint.address,
+    params,
+    baseMintTokenProgram: baseMint.tokenProgram,
+  });
+
+  await client.sendTransaction(adminSigner, plan);
+
+  const [yieldingBankPda] = await client.pda.deriveYieldingBankPda(baseMint.address, id);
+
+  console.log("create_yielding_bank succeeded.");
+  console.log("  environment:", env);
+  console.log("  admin (must match on-chain):", PROTOCOL_ADMIN[env]);
+  console.log("  base mint:", baseMint.address, `(${baseSymbol})`);
+  console.log("  default redemption mint:", redemptionMint.address, `(${redemptionSymbol})`);
+  console.log("  yielding bank PDA:", yieldingBankPda);
+  console.log("  bank id (u8):", id);
+  console.log(
+    "  If you use lookup tables, run: pnpm run update-general-lut -- test|prod (and update-token-luts if needed)"
+  );
+}
+
+main()
+  .then(() => console.log("Finished"))
+  .catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });