@kestrelfi/lyc-sdk 1.0.1

package/dist/sdks/long-yield-carry/scripts/updateFees.js

@@ -0,0 +1,369 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./env");
+const core_1 = require("@anchor-lang/core");
+const common_1 = require("common");
+const client_1 = require("../src/client/client");
+const general_1 = require("../src/constants/general");
+const localUtils_1 = require("./localUtils");
+const MAX_FEE_BPS = 1000;
+const MAX_PCT_BPS = 10000;
+const MAX_FEE_DRIP_APY_BPS = 1500;
+const MAX_FEE_DRIP_DURATION_SECS = 90 * 86400;
+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.`;
+/**
+ * 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() {
+    const { env, rest } = (0, localUtils_1.parseCliEnvironmentAndRest)("update-fees");
+    const args = parseArgs(rest);
+    const { signer, web3Keypair } = await (0, common_1.loadLocalKeypairWithWeb3)(general_1.LYC_MANAGER_KEYPAIR_FP[env]);
+    const provider = (0, common_1.createDefaultAnchorProvider)(env, web3Keypair);
+    const client = new client_1.LongYieldCarryClient(provider, env);
+    let tokens;
+    let target = "all active tokens";
+    if (args.tokenArg === undefined) {
+        tokens = await client.account.fetchAllTokens();
+    }
+    else {
+        const { tokenPda, collateralSymbol } = await (0, localUtils_1.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.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) {
+    let performanceFeeBps;
+    let mintingFeeBps;
+    let burningFeeBps;
+    let protocolMintBurnPctBps;
+    let curatorMintBurnPctBps;
+    let curatorPerfPctBps;
+    let feeDripMaxApyBps;
+    let feeDripDurationSecs;
+    let dryRun = false;
+    let tokenArg;
+    const positional = [];
+    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, flag, maxBps) {
+    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, flag) {
+    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, flag) {
+    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: 3600, d: 86400 }[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 core_1.BN(seconds);
+}
+function parseBps(raw, fieldName, maxBps = MAX_PCT_BPS) {
+    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, raw, fieldName, maxBps) {
+    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, args) {
+    const invalid = tokens
+        .filter((token) => token.isActive)
+        .map((token) => ({ token, update: getTokenFeeUpdate(token, args) }))
+        .map(({ token, update }) => {
+        const errors = [];
+        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 core_1.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, args) {
+    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) {
+    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, update) {
+    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) {
+    return `${value} bps (${(value / 100).toFixed(2)}%)`;
+}
+main()
+    .then(() => console.log("Finished"))
+    .catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/sdks/long-yield-carry/scripts/updateGeneralLut.d.ts

@@ -0,0 +1 @@
+import "./env";

package/dist/sdks/long-yield-carry/scripts/updateGeneralLut.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./env");
+const common_1 = require("common");
+const client_1 = require("../src/client/client");
+const lookupTables_1 = require("../src/utils/lookupTables");
+const localUtils_1 = require("./localUtils");
+async function main() {
+    const { env, rest } = (0, localUtils_1.parseCliEnvironmentAndRest)("update-general-lut");
+    const { rest: args, keypairPath: keypairFlagPath } = (0, localUtils_1.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 (0, common_1.loadLocalKeypairWithWeb3)(keypairFlagPath ?? common_1.TP_LUT_MANAGER_KP_FP);
+    const rpc = (0, common_1.createRpc)(env);
+    const provider = (0, common_1.createDefaultAnchorProvider)(env, web3Keypair);
+    const client = new client_1.LongYieldCarryClient(provider, env);
+    const lutAddress = await (0, lookupTables_1.updateGeneralLutIfNeeded)(signer, rpc, client);
+    console.log("General LUT address:", lutAddress);
+}
+main()
+    .then(() => console.log("Finished"))
+    .catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/sdks/long-yield-carry/scripts/updateLendingPositionConfig.d.ts

@@ -0,0 +1 @@
+import "./env";

package/dist/sdks/long-yield-carry/scripts/updateLendingPositionConfig.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./env");
+const common_1 = require("common");
+const client_1 = require("../src/client/client");
+const carry_1 = require("../src/services/carry");
+const general_1 = require("../src/constants/general");
+const localUtils_1 = require("./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(localUtils_1.ASSET_PRESETS).join(", ")}
+  Volatility regimes: ${localUtils_1.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 } = (0, localUtils_1.parseCliEnvironmentAndRest)("update-lp-config");
+    const { rest: args, keypairPath: keypairFlagPath } = (0, localUtils_1.extractKeypairFlag)(rest);
+    if (args.length < 2) {
+        console.error(USAGE);
+        process.exit(1);
+    }
+    const [tokenArg, regimeArg, ...remaining] = args;
+    if (!(0, localUtils_1.isVolatilityRegime)(regimeArg)) {
+        console.error(`Invalid volatility regime "${regimeArg}". Must be one of: ${localUtils_1.VOLATILITY_REGIMES.join(", ")}\n`);
+        console.error(USAGE);
+        process.exit(1);
+    }
+    const positionIdentifier = remaining[0];
+    const keypairPath = keypairFlagPath ?? remaining[1] ?? general_1.LYC_MANAGER_KEYPAIR_FP[env];
+    const { signer: managerSigner, web3Keypair } = await (0, common_1.loadLocalKeypairWithWeb3)(keypairPath);
+    const provider = (0, common_1.createDefaultAnchorProvider)(env, web3Keypair);
+    const client = new client_1.LongYieldCarryClient(provider, env);
+    const { tokenPda, collateralSymbol } = await (0, localUtils_1.resolveTokenPda)(client, tokenArg);
+    const token = await client.account.fetchToken(tokenPda, { fresh: true });
+    const positions = token.data.lendingPositions;
+    let lendingPositionIndex;
+    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 = common_1.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 = (0, localUtils_1.resolvePresets)(symbol);
+    if (!entry) {
+        console.error(`No carry preset found for "${symbol}". Available: ${Object.keys(localUtils_1.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 carry_1.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);
+});

package/dist/sdks/long-yield-carry/scripts/updateTokenLuts.d.ts

@@ -0,0 +1 @@
+import "./env";

package/dist/sdks/long-yield-carry/scripts/updateTokenLuts.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./env");
+const common_1 = require("common");
+const client_1 = require("../src/client/client");
+const lookupTables_1 = require("../src/utils/lookupTables");
+const localUtils_1 = require("./localUtils");
+async function main() {
+    const { env, rest } = (0, localUtils_1.parseCliEnvironmentAndRest)("update-token-luts");
+    const { rest: args, keypairPath: keypairFlagPath } = (0, localUtils_1.extractKeypairFlag)(rest);
+    if (args.length > 0) {
+        console.error("Usage: pnpm run update-token-luts -- [test|prod] [--keypair KEYPAIR_JSON]");
+        process.exit(1);
+    }
+    const { signer, web3Keypair } = await (0, common_1.loadLocalKeypairWithWeb3)(keypairFlagPath ?? common_1.TP_LUT_MANAGER_KP_FP);
+    const rpc = (0, common_1.createRpc)(env);
+    const provider = (0, common_1.createDefaultAnchorProvider)(env, web3Keypair);
+    const client = new client_1.LongYieldCarryClient(provider, env);
+    await (0, lookupTables_1.updateTokenLutsIfNeeded)(signer, rpc, client);
+    console.log("Per-token LUT updates finished (see TOKEN_LOOKUP_TABLES in constants).");
+}
+main()
+    .then(() => console.log("Finished"))
+    .catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/sdks/long-yield-carry/scripts/updateTokenMetadata.d.ts

@@ -0,0 +1 @@
+import "./env";