@kestrelfi/lyc-sdk 1.0.1

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

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./env");
+const common_1 = require("common");
+const client_1 = require("../src/client/client");
+const general_1 = require("../src/constants/general");
+const errors_1 = require("../src/errors");
+const localUtils_1 = require("./localUtils");
+/**
+ * Runs `collect_interest` for on-chain tokens with active carry exposure
+ * (non-zero yielding bank shares). One transaction per carry slot.
+ *
+ * Skips tokens with the circuit breaker on. `NoOpTransactionError` (no yield
+ * to collect, solvency guard, etc.) is treated as a successful skip.
+ *
+ * Usage:
+ *   From this package:
+ *     `pnpm run collect-interest -- test|prod [TOKEN_PDA|SYMBOL] [KEYPAIR_JSON]`
+ *   From repo root:
+ *     `pnpm run lyc:collect-interest -- 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).
+ *
+ * A single extra positional is treated as a keypair path when it looks like a
+ * file path (`*.json`, contains `/`, or starts with `~`); otherwise it is a token
+ * identifier. Use two positionals for `TOKEN` + keypair explicitly.
+ *
+ * Defaults to the manager keypair for the environment ({@link LYC_MANAGER_KEYPAIR_FP}).
+ */
+async function main() {
+    const { env, rest } = (0, localUtils_1.parseCliEnvironmentAndRest)("collect-interest");
+    const { rest: args, keypairPath: keypairFlagPath } = (0, localUtils_1.extractKeypairFlag)(rest);
+    let tokenIdentifier;
+    let keypairPath;
+    if (args.length === 0) {
+        keypairPath = keypairFlagPath ?? general_1.LYC_MANAGER_KEYPAIR_FP[env];
+    }
+    else if (args.length === 1) {
+        if ((0, localUtils_1.isLikelyKeypairPath)(args[0])) {
+            keypairPath = keypairFlagPath ?? args[0];
+        }
+        else {
+            tokenIdentifier = args[0];
+            keypairPath = keypairFlagPath ?? general_1.LYC_MANAGER_KEYPAIR_FP[env];
+        }
+    }
+    else if (args.length === 2) {
+        tokenIdentifier = args[0];
+        keypairPath = keypairFlagPath ?? args[1];
+    }
+    else {
+        console.error("Usage: pnpm run collect-interest -- [test|prod] [TOKEN_PDA|SYMBOL] [KEYPAIR_JSON]");
+        process.exit(1);
+    }
+    const { signer, web3Keypair } = await (0, common_1.loadLocalKeypairWithWeb3)(keypairPath);
+    const provider = (0, common_1.createDefaultAnchorProvider)(env, web3Keypair);
+    const client = new client_1.LongYieldCarryClient(provider, env);
+    let tokens;
+    if (tokenIdentifier !== undefined) {
+        const { tokenPda, collateralSymbol } = await (0, localUtils_1.resolveTokenPda)(client, tokenIdentifier);
+        tokens = [await client.account.fetchToken(tokenPda, { fresh: true })];
+        console.log("Collecting interest (long-yield-carry) — single token...");
+        console.log("  token:", tokenPda, collateralSymbol ? `(${collateralSymbol})` : "");
+    }
+    else {
+        tokens = await client.account.fetchAllTokens();
+        console.log("Collecting interest (long-yield-carry) — all tokens...");
+    }
+    console.log("  environment:", env);
+    console.log("  manager:", signer.address);
+    console.log("  tokens:", tokens.length);
+    let collected = 0;
+    let skippedNoop = 0;
+    let skippedInactive = 0;
+    let skippedNoCarry = 0;
+    let failures = 0;
+    for (const token of tokens) {
+        const tokenOutcomes = await collectForToken(client, signer, token);
+        collected += tokenOutcomes.collected;
+        skippedNoop += tokenOutcomes.skippedNoop;
+        skippedInactive += tokenOutcomes.skippedInactive;
+        skippedNoCarry += tokenOutcomes.skippedNoCarry;
+        failures += tokenOutcomes.failures;
+    }
+    console.log("\nSummary:");
+    console.log("  collected:", collected);
+    console.log("  skipped (no-op / nothing to collect):", skippedNoop);
+    console.log("  skipped (circuit breaker):", skippedInactive);
+    console.log("  skipped (no active carry):", skippedNoCarry);
+    console.log("  failures:", failures);
+    if (failures > 0) {
+        process.exit(1);
+    }
+}
+async function collectForToken(client, signer, token) {
+    let collected = 0;
+    let skippedNoop = 0;
+    let skippedInactive = 0;
+    let skippedNoCarry = 0;
+    let failures = 0;
+    if (!token.isActive) {
+        console.log(`[skip] ${token.label} — circuit breaker active`);
+        skippedInactive++;
+        return {
+            collected,
+            skippedNoop,
+            skippedInactive,
+            skippedNoCarry,
+            failures,
+        };
+    }
+    const activeCarryPositions = token.activeCarryPositions;
+    if (activeCarryPositions.length === 0) {
+        skippedNoCarry++;
+        return {
+            collected,
+            skippedNoop,
+            skippedInactive,
+            skippedNoCarry,
+            failures,
+        };
+    }
+    for (const { index } of activeCarryPositions) {
+        const label = `${token.label} carry[${index}]`;
+        try {
+            const yieldingBank = await token.deriveYieldingBankAddressForDebtCarryIndex(index, client.pda);
+            const plan = await client.tx.collectInterest.getTx({
+                manager: signer.address,
+                token: token.address,
+                params: {
+                    yieldingBank,
+                },
+            });
+            const sig = await client.sendTransaction(signer, plan);
+            console.log(`[ok] ${label} ${yieldingBank} (${sig})`);
+            collected++;
+            client.clearAllCache();
+        }
+        catch (err) {
+            if (err instanceof errors_1.NoOpTransactionError) {
+                console.log(`[noop] ${label} — ${err.message}`);
+                skippedNoop++;
+                continue;
+            }
+            failures++;
+            console.error(`[fail] ${label}: ${err.message}`);
+        }
+    }
+    return {
+        collected,
+        skippedNoop,
+        skippedInactive,
+        skippedNoCarry,
+        failures,
+    };
+}
+main()
+    .then(() => console.log("Finished"))
+    .catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

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

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

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

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./env");
+const common_1 = require("common");
+const client_1 = require("../src/client/client");
+const general_1 = require("../src/constants/general");
+const localUtils_1 = require("./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() {
+    const { env, rest } = (0, localUtils_1.parseCliEnvironmentAndRest)("collect-protocol-fees");
+    const { rest: args, keypairPath: keypairFlagPath } = (0, localUtils_1.extractKeypairFlag)(rest);
+    let tokenIdentifier;
+    let keypairPath;
+    if (args.length === 0) {
+        keypairPath = keypairFlagPath ?? general_1.LYC_ADMIN_KEYPAIR_FP[env];
+    }
+    else if (args.length === 1) {
+        if ((0, localUtils_1.isLikelyKeypairPath)(args[0])) {
+            keypairPath = keypairFlagPath ?? args[0];
+        }
+        else {
+            tokenIdentifier = args[0];
+            keypairPath = keypairFlagPath ?? general_1.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 (0, common_1.loadLocalKeypairWithWeb3)(keypairPath);
+    const provider = (0, common_1.createDefaultAnchorProvider)(env, web3Keypair);
+    const client = new client_1.LongYieldCarryClient(provider, env);
+    let tokens;
+    if (tokenIdentifier !== undefined) {
+        const { tokenPda, collateralSymbol } = await (0, localUtils_1.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, signer, token) {
+    if (!token.isActive) {
+        console.log(`[skip] ${token.label} — circuit breaker active`);
+        return { collected: 0, skippedZero: 0, skippedInactive: 1, failures: 0 };
+    }
+    const pendingRaw = (0, common_1.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 = (0, common_1.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.message}`);
+        return { collected: 0, skippedZero: 0, skippedInactive: 0, failures: 1 };
+    }
+}
+main()
+    .then(() => console.log("Finished"))
+    .catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

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

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

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

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./env");
+const web3_js_1 = require("@solana/web3.js");
+const common_1 = require("common");
+const client_1 = require("../src/client/client");
+const allocation_1 = require("../src/services/allocation");
+const localUtils_1 = require("./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 } = (0, localUtils_1.parseCliEnvironmentAndRest)("compute-optimal-allocations");
+    const provider = (0, common_1.createDefaultAnchorProvider)(env, web3_js_1.Keypair.generate());
+    const client = new client_1.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(common_1.LendingPlatform.Kamino).data;
+    const allocationService = new allocation_1.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, tokens) {
+    const token = tokens.find((t) => t.address === realloc.token);
+    const tokenLabel = token?.label ?? realloc.token;
+    const borrowDeltaBps = Math.round((realloc.projectedBorrowApy - realloc.currentBorrowApy) * 10000);
+    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, 10000 // 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, amountUi, weightBps) {
+    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) {
+    return common_1.mints.get(mint)?.symbol ?? mint.slice(0, 6);
+}
+function formatApy(x) {
+    return `${(x * 100).toFixed(3)}%`;
+}
+main()
+    .then(() => console.log("Done."))
+    .catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

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

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

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

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./env");
+const common_1 = require("common");
+const oracle_1 = require("oracle");
+const token_1 = require("@solana-program/token");
+const client_1 = require("../src/client/client");
+const types_1 = require("../src/client/types");
+const general_1 = require("../src/constants/general");
+const localUtils_1 = require("./localUtils");
+const transactions_1 = require("../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 } = (0, localUtils_1.parseCliEnvironmentAndRest)("create-token");
+    const { rest: args, keypairPath: keypairFlagPath } = (0, localUtils_1.extractKeypairFlag)(rest);
+    const collateralSymbol = (args[0] ?? "SOL").toUpperCase();
+    const collateral = common_1.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 (0, common_1.loadLocalKeypairWithWeb3)(keypairFlagPath ?? general_1.LYC_ADMIN_KEYPAIR_FP[env]);
+    const provider = (0, common_1.createDefaultAnchorProvider)(env, web3Keypair);
+    const client = new client_1.LongYieldCarryClient(provider, env);
+    const oracleData = oracle_1.oracle.getOracleData(collateralSymbol);
+    const { mintSigner, tokenPda, id } = await (0, transactions_1.createYTokenMint)(client, adminSigner, collateral.decimals);
+    const params = {
+        id,
+        interestDistribution: (0, types_1.enumToInterestDistribution)(types_1.InterestDistribution.IntoTokenPrice),
+        oracleConfig: {
+            oracle: oracleData.oracle,
+            oracleType: (0, common_1.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_1.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):", general_1.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/dist/sdks/long-yield-carry/scripts/createTokenLendingPosition.d.ts

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

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

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./env");
+const kit_1 = require("@solana/kit");
+const common_1 = require("common");
+const lending_platforms_1 = require("lending-platforms");
+const lendingPosition_1 = require("../src/utils/lendingPosition");
+const client_1 = require("../src/client/client");
+const allocation_1 = require("../src/services/allocation");
+const carryAllocationConfig_1 = require("../src/services/carry/carryAllocationConfig");
+const general_1 = require("../src/constants/general");
+const localUtils_1 = require("./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(localUtils_1.ASSET_PRESETS).join(", ")}
+  Volatility regimes: ${localUtils_1.VOLATILITY_REGIMES.join(", ")}`;
+function parsePoolArg(arg) {
+    if (!arg)
+        return undefined;
+    if (!(0, localUtils_1.isValidPubkeyString)(arg)) {
+        console.error(`Invalid pool address: "${arg}". Must be a base58-encoded public key.`);
+        process.exit(1);
+    }
+    return (0, kit_1.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 } = (0, localUtils_1.parseCliEnvironmentAndRest)("create-lp");
+    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 explicitDebtSymbol = remaining[0]?.toUpperCase();
+    const poolOverride = parsePoolArg(remaining[1]);
+    const keypairPath = keypairFlagPath ?? remaining[2] ?? 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 tokenData = await client.account.fetchToken(tokenPda, { fresh: true });
+    const collateralMint = tokenData.collateralMint;
+    const symbol = collateralSymbol ?? tokenArg;
+    const kaminoClient = client.getLendingPlatformClientByPlatform(common_1.LendingPlatform.Kamino);
+    const pool = poolOverride ?? (0, lendingPosition_1.resolveDefaultPool)(collateralMint);
+    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 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;
+    let debtMintAddress;
+    if (explicitDebtSymbol) {
+        const debtMintInfo = common_1.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 allocation_1.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 lending_platforms_1.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 = (0, carryAllocationConfig_1.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/dist/sdks/long-yield-carry/scripts/createYieldingBank.d.ts

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