@kestrelfi/lyc-sdk 1.0.1

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

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

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

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

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

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

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

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

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

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

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

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