@kestrelfi/lyc-sdk 1.0.1

package/scripts/updateFees.ts

@@ -0,0 +1,486 @@
+import "./env";
+import { BN } from "@anchor-lang/core";
+import { loadLocalKeypairWithWeb3, 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 { parseCliEnvironmentAndRest, resolveTokenPda } from "./localUtils";
+
+const MAX_FEE_BPS = 1_000;
+const MAX_PCT_BPS = 10_000;
+const MAX_FEE_DRIP_APY_BPS = 1_500;
+const MAX_FEE_DRIP_DURATION_SECS = 90 * 86_400;
+const MIN_COMBINED_MINT_BURN_FEE_BPS = 10;
+
+const USAGE = `Usage:
+
+  pnpm run update-fees -- [test|prod] [TOKEN_PDA|COLLATERAL_SYMBOL|COLLATERAL_SYMBOL:ID] [FEE_FLAGS] [--dry-run]
+
+  Fee flags:
+    --performance-fee <BPS|PERCENT%>
+    --minting-fee <BPS|PERCENT%>
+    --burning-fee <BPS|PERCENT%>
+    --protocol-mint-burn-pct <BPS|PERCENT%>
+    --curator-mint-burn-pct <BPS|PERCENT%>
+    --curator-performance-pct <BPS|PERCENT%>
+    --fee-drip-max-apy <BPS|PERCENT%>
+    --fee-drip-duration <SECONDS|Nd|Nh|Nm>
+
+  Examples:
+    pnpm run update-fees -- test cbbtc --fee-drip-max-apy 2% --fee-drip-duration 3d
+    pnpm run update-fees -- test --performance-fee 5% --minting-fee 25bps
+    pnpm run update-fees -- prod --curator-mint-burn-pct 10% --dry-run
+
+  Updates fee fields on the selected Token account, or every active Token account if omitted.
+  Any field you omit is preserved at its current on-chain value.
+  Always signs with the environment manager keypair.
+  At least one fee argument is required.`;
+
+interface ParsedArgs {
+  performanceFeeBps?: number;
+  mintingFeeBps?: number;
+  burningFeeBps?: number;
+  protocolMintBurnPctBps?: number;
+  curatorMintBurnPctBps?: number;
+  curatorPerfPctBps?: number;
+  feeDripMaxApyBps?: number;
+  feeDripDurationSecs?: BN;
+  tokenArg?: string;
+  dryRun: boolean;
+}
+
+interface TokenFeeUpdate {
+  performanceFeeBps: number;
+  mintingFeeBps: number;
+  burningFeeBps: number;
+  protocolMintBurnPctBps: number;
+  curatorMintBurnPctBps: number;
+  curatorPerfPctBps: number;
+  feeDripMaxApyBps: number;
+  feeDripDurationSecs: BN;
+}
+
+/**
+ * Updates fee fields for a selected token or every active token.
+ *
+ * The signer is always the environment manager. The script preserves every
+ * omitted fee and preflights all on-chain fee ceilings before sending.
+ */
+async function main(): Promise<void> {
+  const { env, rest } = parseCliEnvironmentAndRest("update-fees");
+  const args = parseArgs(rest);
+
+  const { signer, web3Keypair } = await loadLocalKeypairWithWeb3(LYC_MANAGER_KEYPAIR_FP[env]);
+  const provider = createDefaultAnchorProvider(env, web3Keypair);
+  const client = new LongYieldCarryClient(provider, env);
+  let tokens: LYCToken[];
+  let target = "all active tokens";
+
+  if (args.tokenArg === undefined) {
+    tokens = await client.account.fetchAllTokens();
+  } else {
+    const { tokenPda, collateralSymbol } = await resolveTokenPda(client, args.tokenArg);
+    const token = await client.account.fetchToken(tokenPda);
+    tokens = [token];
+    target = `${token.address}${collateralSymbol ? ` (${collateralSymbol}:${token.id})` : ""}`;
+  }
+
+  preflightTokens(tokens, args);
+
+  console.log("Updating token fees (long-yield-carry)...");
+  console.log("  environment:", env);
+  console.log("  manager:", signer.address);
+  console.log("  target:", target);
+  console.log(
+    "  performanceFeeBps:",
+    args.performanceFeeBps === undefined ? "unchanged" : args.performanceFeeBps
+  );
+  console.log(
+    "  mintingFeeBps:",
+    args.mintingFeeBps === undefined ? "unchanged" : args.mintingFeeBps
+  );
+  console.log(
+    "  burningFeeBps:",
+    args.burningFeeBps === undefined ? "unchanged" : args.burningFeeBps
+  );
+  console.log(
+    "  protocolMintBurnPctBps:",
+    args.protocolMintBurnPctBps === undefined ? "unchanged" : args.protocolMintBurnPctBps
+  );
+  console.log(
+    "  curatorMintBurnPctBps:",
+    args.curatorMintBurnPctBps === undefined ? "unchanged" : args.curatorMintBurnPctBps
+  );
+  console.log(
+    "  curatorPerfPctBps:",
+    args.curatorPerfPctBps === undefined ? "unchanged" : args.curatorPerfPctBps
+  );
+  console.log(
+    "  feeDripMaxApyBps:",
+    args.feeDripMaxApyBps === undefined ? "unchanged" : args.feeDripMaxApyBps
+  );
+  console.log(
+    "  feeDripDurationSecs:",
+    args.feeDripDurationSecs === undefined ? "unchanged" : args.feeDripDurationSecs.toString()
+  );
+  console.log("  dry run:", args.dryRun ? "yes" : "no");
+  console.log("  token count:", tokens.length);
+
+  let updated = 0;
+  let skippedUnchanged = 0;
+  let skippedInactive = 0;
+  let failures = 0;
+
+  for (const token of tokens) {
+    if (!token.isActive) {
+      console.log(`[skip] ${token.label} - circuit breaker active`);
+      skippedInactive++;
+      continue;
+    }
+
+    const update = getTokenFeeUpdate(token, args);
+    if (
+      token.data.fees.performanceFeeBps === update.performanceFeeBps &&
+      token.data.fees.mintingFeeBps === update.mintingFeeBps &&
+      token.data.fees.burningFeeBps === update.burningFeeBps &&
+      token.data.fees.protocolMintBurnPctBps === update.protocolMintBurnPctBps &&
+      token.data.fees.curatorMintBurnPctBps === update.curatorMintBurnPctBps &&
+      token.data.fees.curatorPerfPctBps === update.curatorPerfPctBps &&
+      token.data.fees.feeDripMaxApyBps === update.feeDripMaxApyBps &&
+      token.data.fees.feeDripDurationSecs.eq(update.feeDripDurationSecs)
+    ) {
+      console.log(`[skip] ${token.label} - already ${formatTokenFeeUpdate(update)}`);
+      skippedUnchanged++;
+      continue;
+    }
+
+    if (args.dryRun) {
+      console.log(`[dry-run] ${token.label} - ${formatTokenFeeChange(token, update)}`);
+      updated++;
+      continue;
+    }
+
+    try {
+      const plan = await client.tx.updateTokenConfiguration.getTx({
+        token: token.address,
+        admin: signer.address,
+        params: {
+          performanceFeeBps: update.performanceFeeBps,
+          mintingFeeBps: update.mintingFeeBps,
+          burningFeeBps: update.burningFeeBps,
+          protocolMintBurnPctBps: update.protocolMintBurnPctBps,
+          curatorMintBurnPctBps: update.curatorMintBurnPctBps,
+          curatorPerfPctBps: update.curatorPerfPctBps,
+          feeDripMaxApyBps: update.feeDripMaxApyBps,
+          feeDripDurationSecs: update.feeDripDurationSecs,
+        },
+      });
+      const sig = await client.sendTransaction(signer, plan);
+      console.log(`[ok] ${token.label} - ${formatTokenFeeChange(token, update)} (${sig})`);
+      updated++;
+    } catch (err) {
+      console.error(`[fail] ${token.label}: ${(err as Error).message}`);
+      failures++;
+    }
+  }
+
+  console.log("\nSummary:");
+  console.log(args.dryRun ? "  would update:" : "  updated:", updated);
+  console.log("  skipped (unchanged):", skippedUnchanged);
+  console.log("  skipped (circuit breaker):", skippedInactive);
+  console.log("  failures:", failures);
+
+  if (failures > 0) {
+    process.exit(1);
+  }
+}
+
+function parseArgs(args: string[]): ParsedArgs {
+  let performanceFeeBps: number | undefined;
+  let mintingFeeBps: number | undefined;
+  let burningFeeBps: number | undefined;
+  let protocolMintBurnPctBps: number | undefined;
+  let curatorMintBurnPctBps: number | undefined;
+  let curatorPerfPctBps: number | undefined;
+  let feeDripMaxApyBps: number | undefined;
+  let feeDripDurationSecs: BN | undefined;
+  let dryRun = false;
+  let tokenArg: string | undefined;
+  const positional: string[] = [];
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]!;
+    if (arg === "--dry-run") {
+      dryRun = true;
+      continue;
+    }
+
+    if (arg === "--performance-fee" || arg === "--performance-fee-bps") {
+      performanceFeeBps = parseFlagBps(args[++i], arg, MAX_FEE_BPS);
+      continue;
+    }
+
+    if (arg === "--minting-fee" || arg === "--minting-fee-bps" || arg === "--mint-fee") {
+      mintingFeeBps = parseFlagBps(args[++i], arg, MAX_FEE_BPS);
+      continue;
+    }
+
+    if (arg === "--burning-fee" || arg === "--burning-fee-bps" || arg === "--burn-fee") {
+      burningFeeBps = parseFlagBps(args[++i], arg, MAX_FEE_BPS);
+      continue;
+    }
+
+    if (arg === "--protocol-mint-burn-pct" || arg === "--protocol-pct") {
+      protocolMintBurnPctBps = parseFlagBps(args[++i], arg, MAX_PCT_BPS);
+      continue;
+    }
+
+    if (arg === "--curator-mint-burn-pct" || arg === "--curator-pct") {
+      curatorMintBurnPctBps = parseFlagBps(args[++i], arg, MAX_PCT_BPS);
+      continue;
+    }
+
+    if (arg === "--curator-performance-pct" || arg === "--curator-perf-pct") {
+      curatorPerfPctBps = parseFlagBps(args[++i], arg, MAX_PCT_BPS);
+      continue;
+    }
+
+    if (arg === "--fee-drip-max-apy" || arg === "--fee-drip-max-apy-bps") {
+      feeDripMaxApyBps = parseFlagApyBps(args[++i], arg);
+      continue;
+    }
+
+    if (arg === "--fee-drip-duration" || arg === "--fee-drip-duration-secs") {
+      feeDripDurationSecs = parseFlagDuration(args[++i], arg);
+      continue;
+    }
+
+    if (arg.startsWith("--")) {
+      console.error(`Unknown argument "${arg}".\n`);
+      console.error(USAGE);
+      process.exit(1);
+    }
+
+    positional.push(arg);
+  }
+
+  if (
+    performanceFeeBps === undefined &&
+    mintingFeeBps === undefined &&
+    burningFeeBps === undefined &&
+    protocolMintBurnPctBps === undefined &&
+    curatorMintBurnPctBps === undefined &&
+    curatorPerfPctBps === undefined &&
+    feeDripMaxApyBps === undefined &&
+    feeDripDurationSecs === undefined
+  ) {
+    console.error("At least one fee argument is required.\n");
+    console.error(USAGE);
+    process.exit(1);
+  }
+
+  if (positional.length > 1) {
+    console.error(USAGE);
+    process.exit(1);
+  }
+
+  if (positional.length === 1) {
+    tokenArg = positional[0];
+  }
+
+  return {
+    performanceFeeBps,
+    mintingFeeBps,
+    burningFeeBps,
+    protocolMintBurnPctBps,
+    curatorMintBurnPctBps,
+    curatorPerfPctBps,
+    feeDripMaxApyBps,
+    feeDripDurationSecs,
+    tokenArg,
+    dryRun,
+  };
+}
+
+function parseFlagBps(raw: string | undefined, flag: string, maxBps: number): number {
+  if (raw === undefined || raw.startsWith("--")) {
+    console.error(`Missing value for ${flag}.\n`);
+    console.error(USAGE);
+    process.exit(1);
+  }
+
+  return parseBps(raw, flag, maxBps);
+}
+
+function parseFlagApyBps(raw: string | undefined, flag: string): number {
+  if (raw === undefined || raw.startsWith("--")) {
+    console.error(`Missing value for ${flag}.\n`);
+    console.error(USAGE);
+    process.exit(1);
+  }
+  return parseBps(raw, flag, MAX_FEE_DRIP_APY_BPS);
+}
+
+function parseFlagDuration(raw: string | undefined, flag: string): BN {
+  if (raw === undefined || raw.startsWith("--")) {
+    console.error(`Missing value for ${flag}.\n`);
+    console.error(USAGE);
+    process.exit(1);
+  }
+
+  const trimmed = raw.trim().toLowerCase();
+  const match = trimmed.match(/^(\d+)([dhms]?)$/);
+  if (!match) {
+    console.error(
+      `Invalid value "${raw}" for ${flag}. Use seconds (604800) or a suffix (7d, 24h, 30m).`
+    );
+    process.exit(1);
+  }
+  const value = Number(match[1]);
+  const unitSecs = { "": 1, s: 1, m: 60, h: 3_600, d: 86_400 }[match[2]!]!;
+  const seconds = value * unitSecs;
+  if (seconds > MAX_FEE_DRIP_DURATION_SECS) {
+    console.error(`Invalid value "${raw}" for ${flag}. Must be at most 90 days.`);
+    process.exit(1);
+  }
+  return new BN(seconds);
+}
+
+function parseBps(raw: string, fieldName: string, maxBps: number = MAX_PCT_BPS): number {
+  const trimmed = raw.trim().toLowerCase();
+  const percentMatch = trimmed.match(/^(\d+(?:\.\d+)?)%$/);
+  if (percentMatch) {
+    return validateBps(Math.round(Number(percentMatch[1]) * 100), raw, fieldName, maxBps);
+  }
+
+  const bpsText = trimmed.endsWith("bps") ? trimmed.slice(0, -3) : trimmed;
+  if (!/^\d+$/.test(bpsText)) {
+    console.error(
+      `Invalid value "${raw}" for ${fieldName}. Use integer bps (5000) or a percent (50%).`
+    );
+    process.exit(1);
+  }
+
+  return validateBps(Number(bpsText), raw, fieldName, maxBps);
+}
+
+function validateBps(value: number, raw: string, fieldName: string, maxBps: number): number {
+  if (!Number.isInteger(value) || value < 0 || value > maxBps) {
+    console.error(
+      `Invalid value "${raw}" for ${fieldName}. Value must be between 0 and ${maxBps} bps.`
+    );
+    process.exit(1);
+  }
+  return value;
+}
+
+function preflightTokens(tokens: LYCToken[], args: ParsedArgs): void {
+  const invalid = tokens
+    .filter((token) => token.isActive)
+    .map((token) => ({ token, update: getTokenFeeUpdate(token, args) }))
+    .map(({ token, update }) => {
+      const errors: string[] = [];
+      if (update.performanceFeeBps > MAX_FEE_BPS) {
+        errors.push(`performance fee exceeds ${MAX_FEE_BPS} bps`);
+      }
+      if (update.mintingFeeBps > MAX_FEE_BPS) {
+        errors.push(`minting fee exceeds ${MAX_FEE_BPS} bps`);
+      }
+      if (update.burningFeeBps > MAX_FEE_BPS) {
+        errors.push(`burning fee exceeds ${MAX_FEE_BPS} bps`);
+      }
+      if (update.mintingFeeBps + update.burningFeeBps < MIN_COMBINED_MINT_BURN_FEE_BPS) {
+        errors.push(
+          `minting + burning fees must be at least ${MIN_COMBINED_MINT_BURN_FEE_BPS} bps`
+        );
+      }
+      if (update.protocolMintBurnPctBps > MAX_PCT_BPS) {
+        errors.push(`protocol mint/burn share exceeds ${MAX_PCT_BPS} bps`);
+      }
+      if (update.curatorMintBurnPctBps > MAX_PCT_BPS) {
+        errors.push(`curator mint/burn share exceeds ${MAX_PCT_BPS} bps`);
+      }
+      if (update.protocolMintBurnPctBps + update.curatorMintBurnPctBps > MAX_PCT_BPS) {
+        errors.push(`protocol + curator mint/burn shares exceed ${MAX_PCT_BPS} bps`);
+      }
+      if (update.curatorPerfPctBps > MAX_PCT_BPS) {
+        errors.push(`curator performance share exceeds ${MAX_PCT_BPS} bps`);
+      }
+      if (update.feeDripMaxApyBps > MAX_FEE_DRIP_APY_BPS) {
+        errors.push(`fee-drip APY exceeds ${MAX_FEE_DRIP_APY_BPS} bps`);
+      }
+      if (update.feeDripDurationSecs.gt(new BN(MAX_FEE_DRIP_DURATION_SECS))) {
+        errors.push("fee-drip duration exceeds 90 days");
+      }
+      return { token, errors };
+    })
+    .filter(({ errors }) => errors.length > 0);
+
+  if (invalid.length === 0) return;
+
+  console.error("Cannot update because one or more resulting fee configurations are invalid:");
+  for (const { token, errors } of invalid) {
+    console.error(`  ${token.label}: ${errors.join("; ")}`);
+  }
+  process.exit(1);
+}
+
+function getTokenFeeUpdate(token: LYCToken, args: ParsedArgs): TokenFeeUpdate {
+  return {
+    performanceFeeBps: args.performanceFeeBps ?? token.data.fees.performanceFeeBps,
+    mintingFeeBps: args.mintingFeeBps ?? token.data.fees.mintingFeeBps,
+    burningFeeBps: args.burningFeeBps ?? token.data.fees.burningFeeBps,
+    protocolMintBurnPctBps: args.protocolMintBurnPctBps ?? token.data.fees.protocolMintBurnPctBps,
+    curatorMintBurnPctBps: args.curatorMintBurnPctBps ?? token.data.fees.curatorMintBurnPctBps,
+    curatorPerfPctBps: args.curatorPerfPctBps ?? token.data.fees.curatorPerfPctBps,
+    feeDripMaxApyBps: args.feeDripMaxApyBps ?? token.data.fees.feeDripMaxApyBps,
+    feeDripDurationSecs: args.feeDripDurationSecs ?? token.data.fees.feeDripDurationSecs,
+  };
+}
+
+function formatTokenFeeUpdate(update: TokenFeeUpdate): string {
+  return (
+    `performance ${formatBps(update.performanceFeeBps)}, ` +
+    `mint ${formatBps(update.mintingFeeBps)}, ` +
+    `burn ${formatBps(update.burningFeeBps)}, ` +
+    `protocol ${formatBps(update.protocolMintBurnPctBps)}, ` +
+    `curator ${formatBps(update.curatorMintBurnPctBps)}, ` +
+    `curator performance ${formatBps(update.curatorPerfPctBps)}, ` +
+    `drip cap ${formatBps(update.feeDripMaxApyBps)}, ` +
+    `drip ${update.feeDripDurationSecs.toString()}s`
+  );
+}
+
+function formatTokenFeeChange(token: LYCToken, update: TokenFeeUpdate): string {
+  return (
+    `performance ${formatBps(token.data.fees.performanceFeeBps)} -> ${formatBps(
+      update.performanceFeeBps
+    )}, ` +
+    `mint ${formatBps(token.data.fees.mintingFeeBps)} -> ${formatBps(update.mintingFeeBps)}, ` +
+    `burn ${formatBps(token.data.fees.burningFeeBps)} -> ${formatBps(update.burningFeeBps)}, ` +
+    `protocol ${formatBps(token.data.fees.protocolMintBurnPctBps)} -> ${formatBps(
+      update.protocolMintBurnPctBps
+    )}, ` +
+    `curator ${formatBps(token.data.fees.curatorMintBurnPctBps)} -> ${formatBps(
+      update.curatorMintBurnPctBps
+    )}, ` +
+    `curator performance ${formatBps(token.data.fees.curatorPerfPctBps)} -> ${formatBps(
+      update.curatorPerfPctBps
+    )}, ` +
+    `drip cap ${formatBps(token.data.fees.feeDripMaxApyBps)} -> ${formatBps(
+      update.feeDripMaxApyBps
+    )}, ` +
+    `drip ${token.data.fees.feeDripDurationSecs.toString()}s -> ${update.feeDripDurationSecs.toString()}s`
+  );
+}
+
+function formatBps(value: number): string {
+  return `${value} bps (${(value / 100).toFixed(2)}%)`;
+}
+
+main()
+  .then(() => console.log("Finished"))
+  .catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });

package/scripts/updateGeneralLut.ts

@@ -0,0 +1,36 @@
+import "./env";
+import {
+  createRpc,
+  loadLocalKeypairWithWeb3,
+  TP_LUT_MANAGER_KP_FP,
+  createDefaultAnchorProvider,
+} from "common";
+import { LongYieldCarryClient } from "../src/client/client";
+import { updateGeneralLutIfNeeded } from "../src/utils/lookupTables";
+import { extractKeypairFlag, parseCliEnvironmentAndRest } from "./localUtils";
+
+async function main() {
+  const { env, rest } = parseCliEnvironmentAndRest("update-general-lut");
+  const { rest: args, keypairPath: keypairFlagPath } = extractKeypairFlag(rest);
+  if (args.length > 0) {
+    console.error("Usage: pnpm run update-general-lut -- [test|prod] [--keypair KEYPAIR_JSON]");
+    process.exit(1);
+  }
+
+  const { signer, web3Keypair } = await loadLocalKeypairWithWeb3(
+    keypairFlagPath ?? TP_LUT_MANAGER_KP_FP
+  );
+  const rpc = createRpc(env);
+  const provider = createDefaultAnchorProvider(env, web3Keypair);
+  const client = new LongYieldCarryClient(provider, env);
+
+  const lutAddress = await updateGeneralLutIfNeeded(signer, rpc, client);
+  console.log("General LUT address:", lutAddress);
+}
+
+main()
+  .then(() => console.log("Finished"))
+  .catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });

package/scripts/updateLendingPositionConfig.ts

@@ -0,0 +1,172 @@
+import "./env";
+import { loadLocalKeypairWithWeb3, mints, createDefaultAnchorProvider } from "common";
+import { LongYieldCarryClient } from "../src/client/client";
+import { LycLendingPositionManager } from "../src/services/carry";
+import { LYC_MANAGER_KEYPAIR_FP } from "../src/constants/general";
+import {
+  extractKeypairFlag,
+  parseCliEnvironmentAndRest,
+  resolveTokenPda,
+  VOLATILITY_REGIMES,
+  ASSET_PRESETS,
+  isVolatilityRegime,
+  resolvePresets,
+} from "./localUtils";
+
+const USAGE = `Usage:
+
+  pnpm run update-lp-config -- [test|prod] <TOKEN> <lowVol|highVol> [DEBT_SYMBOL | LP_INDEX] [KEYPAIR_JSON]
+
+  Example: pnpm run update-lp-config -- test SOL lowVol
+  Example: pnpm run update-lp-config -- test SOL highVol USDT
+  Example: pnpm run update-lp-config -- test SOL lowVol 0
+
+  The position is identified by DEBT_SYMBOL (defaults to USDC) or by a numeric LP_INDEX.
+  Available presets: ${Object.keys(ASSET_PRESETS).join(", ")}
+  Volatility regimes: ${VOLATILITY_REGIMES.join(", ")}`;
+
+/**
+ * Updates the lending position config for a specific lending position on a token.
+ *
+ * Resolves the carry trade preset for the collateral asset and volatility regime,
+ * fetches `maxLtv` and `liquidationThreshold` from the on-chain reserve, and
+ * computes the BPS config via `LycLendingPositionManager.getLendingAllocationConfigFromPriceBands`.
+ */
+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("update-lp-config");
+  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 positionIdentifier = remaining[0];
+  const keypairPath = keypairFlagPath ?? remaining[1] ?? 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 token = await client.account.fetchToken(tokenPda, { fresh: true });
+  const positions = token.data.lendingPositions;
+
+  let lendingPositionIndex: number;
+
+  const parsedIndex = positionIdentifier !== undefined ? parseInt(positionIdentifier, 10) : NaN;
+  if (Number.isFinite(parsedIndex) && parsedIndex >= 0) {
+    lendingPositionIndex = parsedIndex;
+    if (
+      lendingPositionIndex >= positions.length ||
+      "none" in positions[lendingPositionIndex].platform
+    ) {
+      console.error(
+        `Lending position ${lendingPositionIndex} is inactive or out of bounds ` +
+          `(token has ${positions.length} slots).`
+      );
+      process.exit(1);
+    }
+  } else {
+    const debtSymbol = (positionIdentifier ?? "USDC").toUpperCase();
+    const debtMintInfo = mints.get(debtSymbol);
+    if (!debtMintInfo) {
+      console.error(
+        `Unknown debt mint symbol "${debtSymbol}". Known symbols use the common mint registry.`
+      );
+      process.exit(1);
+    }
+    lendingPositionIndex = token.findLendingPositionByDebtMint(debtMintInfo.address);
+    if (lendingPositionIndex === -1) {
+      console.error(
+        `No active lending position found with debt ${debtSymbol} (${debtMintInfo.address}) on token ${tokenPda}.`
+      );
+      process.exit(1);
+    }
+  }
+
+  const symbol = collateralSymbol ?? tokenArg;
+  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 lendingPosition = positions[lendingPositionIndex];
+  const manager = await LycLendingPositionManager.create(
+    client.getLendingPlatformClient(lendingPosition).data,
+    lendingPosition
+  );
+  const newConfig = manager.getLendingAllocationConfigFromPriceBands(preset);
+
+  const { maxLtv } = manager.reservesManager;
+  const liqThreshPct = manager.reservesManager.supplyReserve.config.liquidationThresholdPct;
+  const liquidationThreshold = liqThreshPct <= 1 ? liqThreshPct : liqThreshPct / 100;
+  console.log(
+    `  maxLtv: ${(maxLtv * 100).toFixed(1)}%, liquidationThreshold: ${(
+      liquidationThreshold * 100
+    ).toFixed(1)}%`
+  );
+
+  const currentConfig = positions[lendingPositionIndex].config;
+  console.log(`\nToken PDA: ${tokenPda} (collateral: ${collateralSymbol ?? "unknown"})`);
+  console.log(`Lending position index: ${lendingPositionIndex}`);
+  console.log("");
+  console.log("Current config:");
+  console.log(`  targetUtilizationRateBps:        ${currentConfig.targetUtilizationRateBps}`);
+  console.log(`  maxDeviationAboveTargetUtilBps:  ${currentConfig.maxDeviationAboveTargetUtilBps}`);
+  console.log(`  maxDeviationBelowTargetUtilBps:  ${currentConfig.maxDeviationBelowTargetUtilBps}`);
+  console.log("");
+  console.log("New config:");
+  console.log(`  targetUtilizationRateBps:        ${newConfig.targetUtilizationRateBps}`);
+  console.log(`  maxDeviationAboveTargetUtilBps:  ${newConfig.maxDeviationAboveTargetUtilBps}`);
+  console.log(`  maxDeviationBelowTargetUtilBps:  ${newConfig.maxDeviationBelowTargetUtilBps}`);
+
+  const plan = await client.tx.updateLendingPositionConfig.getTx({
+    token: tokenPda,
+    params: {
+      lendingPositionIndex,
+      ...newConfig,
+    },
+  });
+  const sig = await client.sendTransaction(managerSigner, plan);
+
+  console.log("");
+  console.log("update_lending_position_config 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);
+  });