@kestrelfi/lyc-sdk 1.0.1

package/dist/sdks/long-yield-carry/scripts/emergency/triggerCircuitBreaker.js

@@ -0,0 +1,68 @@
+"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 transactions_1 = require("../../src/utils/transactions");
+const localUtils_1 = require("../localUtils");
+/**
+ * Triggers the circuit breaker on ALL tokens and yielding banks for a given environment.
+ *
+ * Usage:
+ *   From this package: `pnpm run trigger-cb -- test|prod [KEYPAIR_JSON]`
+ *   From repo root:   `pnpm run lyc:trigger-cb -- test|prod [KEYPAIR_JSON]`
+ *
+ * Keypair defaults to ~/.config/solana/tp-lyc-cb-{env}.json (circuit breaker controller).
+ * Admin keypair can also be used.
+ */
+async function main() {
+    const { env, rest } = (0, localUtils_1.parseCliEnvironmentAndRest)("trigger-cb");
+    const { rest: args, keypairPath: keypairFlagPath } = (0, localUtils_1.extractKeypairFlag)(rest);
+    const keypairPath = keypairFlagPath ?? args[0] ?? general_1.LYC_CB_KEYPAIR_FP[env];
+    if (args.length > 1) {
+        console.error("Usage: pnpm run trigger-cb -- [test|prod] [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);
+    const { tokens, yieldingBanks } = await client.account.fetchAllTokensAndYieldingBanks();
+    console.log("Triggering circuit breaker on all accounts...");
+    console.log("  environment:", env);
+    console.log("  signer:", signer.address);
+    console.log("  tokens:", tokens.length);
+    console.log("  yielding banks:", yieldingBanks.length);
+    let failures = 0;
+    for (const [i, token] of tokens.entries()) {
+        try {
+            const sig = await (0, transactions_1.setTokenCircuitBreaker)(client, signer, token.address, true);
+            console.log(`[token ${i + 1}/${tokens.length}] ✓ circuit breaker ON  ${token.address} (${sig})`);
+        }
+        catch (err) {
+            failures++;
+            console.error(`[token ${i + 1}/${tokens.length}] ✗ FAILED ${token.address}:`, err);
+        }
+    }
+    for (const [i, bank] of yieldingBanks.entries()) {
+        try {
+            const sig = await (0, transactions_1.setYieldingBankCircuitBreaker)(client, signer, bank.address, true);
+            console.log(`[yielding bank ${i + 1}/${yieldingBanks.length}] ✓ circuit breaker ON  ${bank.address} (${sig})`);
+        }
+        catch (err) {
+            failures++;
+            console.error(`[yielding bank ${i + 1}/${yieldingBanks.length}] ✗ FAILED ${bank.address}:`, err);
+        }
+    }
+    if (failures > 0) {
+        console.error(`\n${failures} transaction(s) failed.`);
+        process.exit(1);
+    }
+    console.log("\nAll circuit breakers triggered successfully.");
+}
+main()
+    .then(() => console.log("Finished"))
+    .catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dotenv_1 = require("dotenv");
+const path_1 = __importDefault(require("path"));
+(0, dotenv_1.config)({ path: path_1.default.resolve(__dirname, "../.env") });

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

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

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

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./env");
+const common_1 = require("common");
+const general_1 = require("../src/constants/general");
+const client_1 = require("../src/client/client");
+const lycInstructionNames_1 = require("../src/decoders/lycInstructionNames");
+const decodeTransaction_1 = require("../src/decoders/decodeTransaction");
+const localUtils_1 = require("./localUtils");
+/**
+ * Scan a program's transaction history and print signatures matching an
+ * instruction name and optional collateral-mint filter.
+ *
+ * Usage (from this package):
+ *   pnpm run find-txs -- test|prod <INSTRUCTION> [TOKEN_SYMBOL] [LIMIT]
+ *
+ * Usage (from repo root):
+ *   pnpm run lyc:find-txs -- test|prod <INSTRUCTION> [TOKEN_SYMBOL] [LIMIT]
+ *
+ * Arguments:
+ *   INSTRUCTION         Instruction name in snake_case or camelCase (e.g. claim_incentives).
+ *   TOKEN_PDA|SYMBOL    Optional. Collateral symbol (e.g. SOL) or Token PDA address.
+ *                       Resolves to the Token PDA and filters to txs whose account
+ *                       keys include that PDA.
+ *   LIMIT               Optional. Stop after printing this many matching signatures
+ *                       (default: unlimited).
+ *
+ * Examples:
+ *   pnpm run find-txs -- test claim_incentives sol 1
+ *   pnpm run find-txs -- prod mint_token usdc 5
+ */
+// snake_case → camelCase (claim_incentives → claimIncentives)
+function toCamelCase(s) {
+    return s.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+async function main() {
+    const { env, rest } = (0, localUtils_1.parseCliEnvironmentAndRest)("find-txs");
+    if (rest.length < 1) {
+        console.error("Usage: pnpm run find-txs -- test|prod <INSTRUCTION> [TOKEN_SYMBOL] [LIMIT]");
+        process.exit(1);
+    }
+    const ixArg = rest[0];
+    const ixName = toCamelCase(ixArg); // normalise to camelCase for comparison
+    let tokenPdaFilter;
+    let tokenPdaLabel;
+    let limit;
+    for (const arg of rest.slice(1)) {
+        const asNum = parseInt(arg, 10);
+        if (Number.isFinite(asNum) && asNum > 0) {
+            limit = asNum;
+            continue;
+        }
+        // Treat as a collateral mint identifier — resolve to the Token PDA
+        const provider = (0, common_1.createReadOnlyAnchorProvider)(env);
+        const client = new client_1.LongYieldCarryClient(provider, env);
+        const { tokenPda, collateralSymbol } = await (0, localUtils_1.resolveTokenPda)(client, arg);
+        tokenPdaFilter = String(tokenPda);
+        tokenPdaLabel = collateralSymbol ?? arg;
+    }
+    const programId = String(general_1.PROGRAM_ID[env]);
+    const rpcUrl = (0, common_1.getRpcUrl)(env);
+    console.error(`env:         ${env}`);
+    console.error(`program:     ${programId}`);
+    console.error(`instruction: ${ixName}`);
+    if (tokenPdaFilter)
+        console.error(`token PDA:   ${tokenPdaFilter}  (${tokenPdaLabel})`);
+    if (limit !== undefined)
+        console.error(`limit:       ${limit}`);
+    console.error("");
+    const throttle = (0, common_1.createMinIntervalThrottle)(200);
+    const rpcCall = (method, params) => (0, common_1.jsonRpcFetchWithRetries)(throttle, rpcUrl, method, params, 6, 500);
+    const PAGE = 1000;
+    let before;
+    let found = 0;
+    let scanned = 0;
+    outer: while (true) {
+        const page = await rpcCall("getSignaturesForAddress", [
+            programId,
+            {
+                limit: PAGE,
+                commitment: "confirmed",
+                ...(before ? { before } : {}),
+            },
+        ]);
+        if (page.length === 0)
+            break;
+        for (const sigInfo of page) {
+            scanned++;
+            if (sigInfo.err != null)
+                continue; // skip failed txs
+            // Fetch the full transaction
+            let payload;
+            try {
+                payload = await rpcCall("getTransaction", [
+                    sigInfo.signature,
+                    {
+                        commitment: "confirmed",
+                        encoding: "json",
+                        maxSupportedTransactionVersion: 0,
+                    },
+                ]);
+            }
+            catch {
+                console.error(`[warn] getTransaction failed for ${sigInfo.signature}`);
+                continue;
+            }
+            if (!payload)
+                continue;
+            const record = {
+                source: "lyc-program-transaction",
+                receivedAt: 0,
+                signature: sigInfo.signature,
+                slot: sigInfo.slot,
+                payload,
+            };
+            const names = (0, lycInstructionNames_1.listLycTopLevelInstructionNames)(record);
+            if (!names || !names.includes(ixName))
+                continue;
+            // Apply optional token PDA filter — check account keys
+            if (tokenPdaFilter) {
+                const parsed = (0, decodeTransaction_1.parseRecordPayload)(record);
+                if (!parsed || !parsed.keys.includes(tokenPdaFilter))
+                    continue;
+            }
+            found++;
+            const ts = sigInfo.blockTime
+                ? new Date(sigInfo.blockTime * 1000).toISOString()
+                : "unknown-time";
+            console.log(`${sigInfo.signature}  slot=${sigInfo.slot}  time=${ts}`);
+            if (limit !== undefined && found >= limit)
+                break outer;
+        }
+        const oldest = page[page.length - 1];
+        if (page.length < PAGE)
+            break;
+        before = oldest.signature;
+    }
+    console.error(`\nscanned ${scanned} txs, found ${found} match(es).`);
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

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

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

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

@@ -0,0 +1,112 @@
+"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 lycLendingPositionManager_1 = require("../src/services/carry/lycLendingPositionManager");
+const errors_1 = require("../src/errors");
+const yieldingBank_1 = require("../src/utils/yieldingBank");
+const localUtils_1 = require("./localUtils");
+/**
+ * Increases carry positions for all eligible lending positions on a given token.
+ *
+ * For each active Kamino lending position whose LTV utilization has fallen
+ * below the lower trigger band, borrows additional debt to push utilization
+ * back toward the target and deposits the proceeds into the yielding bank.
+ *
+ * Usage:
+ *   pnpm run increase-carry -- [test|prod] <TOKEN_PDA|COLLATERAL_SYMBOL> [KEYPAIR_JSON]
+ *
+ * KEYPAIR_JSON defaults to the manager keypair for the environment.
+ */
+async function main() {
+    const { env, rest } = (0, localUtils_1.parseCliEnvironmentAndRest)("increase-carry");
+    const { rest: args, keypairPath: keypairFlagPath } = (0, localUtils_1.extractKeypairFlag)(rest);
+    const tokenArg = args[0];
+    const keypairPath = keypairFlagPath ?? args[1] ?? general_1.LYC_MANAGER_KEYPAIR_FP[env];
+    if (tokenArg === undefined) {
+        console.error("Usage: pnpm run increase-carry -- [test|prod] <TOKEN_PDA|COLLATERAL_SYMBOL> [KEYPAIR_JSON]");
+        process.exit(1);
+    }
+    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);
+    console.log(`Token PDA: ${tokenPda} (collateral: ${collateralSymbol ?? "unknown"})`);
+    console.log(`Environment: ${env}`);
+    console.log(`Manager: ${managerSigner.address}`);
+    // Refresh token state so utilization rates are current
+    const refreshPlan = await client.tx.refreshTokens.getTx({
+        signer: managerSigner.address,
+        params: {
+            tokens: [tokenPda],
+        },
+    });
+    await client.sendTransaction(managerSigner, refreshPlan);
+    client.clearAllCache();
+    const tokenData = await client.account.fetchToken(tokenPda, { fresh: true });
+    const { yieldingBanks: allBanks } = await client.account.fetchAllTokensAndYieldingBanks();
+    const yieldingBank = (0, yieldingBank_1.resolveYieldingBankForPosition)(allBanks);
+    if (!yieldingBank) {
+        console.error("No active yielding bank available. Cannot increase carry positions.");
+        process.exit(1);
+    }
+    let succeeded = 0;
+    let skipped = 0;
+    let failures = 0;
+    for (const { index: i, data: position } of tokenData.usedLendingPositions) {
+        if (client.lendingPlatformClients.getPlatformForPosition(position) !== common_1.LendingPlatform.Kamino) {
+            continue;
+        }
+        const label = `LP[${i}]`;
+        try {
+            const lycLendingPositionManager = await lycLendingPositionManager_1.LycLendingPositionManager.create(client.getLendingPlatformClient(position).data, position);
+            const shouldIncrease = await lycLendingPositionManager.shouldIncreaseCarryPosition();
+            if (!shouldIncrease) {
+                console.log(`${label} — utilization within target band, skipping`);
+                skipped++;
+                continue;
+            }
+            const uiBorrow = await lycLendingPositionManager.calcDebtChangeAmount();
+            console.log(`${label} — borrowing ${uiBorrow} to increase carry position...`);
+            const plan = await client.tx.increaseCarryPosition.getTx({
+                manager: managerSigner.address,
+                token: tokenPda,
+                params: {
+                    lendingPositionIndex: i,
+                    yieldingBank,
+                    uiAmount: uiBorrow,
+                },
+            });
+            const sig = await client.sendTransaction(managerSigner, plan);
+            console.log(`${label} ✓ increased carry position (${sig})`);
+            succeeded++;
+            client.clearAllCache();
+        }
+        catch (err) {
+            if (err instanceof errors_1.NoOpTransactionError) {
+                console.log(`${label} — skipped: ${err.message}`);
+                skipped++;
+                continue;
+            }
+            if ((0, errors_1.isSkippableLycTransactionError)(err)) {
+                console.log(`${label} — skipped: utilization guard rejected increase`);
+                skipped++;
+                continue;
+            }
+            failures++;
+            console.error(`${label} ✗ failed: ${err.message}`);
+        }
+    }
+    console.log(`\nSummary: ${succeeded} succeeded, ${skipped} skipped, ${failures} failed`);
+    if (failures > 0) {
+        process.exit(1);
+    }
+}
+main()
+    .then(() => console.log("Finished"))
+    .catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

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

@@ -0,0 +1,13 @@
+import type { Address } from "@solana/kit";
+import { type Environment } from "common";
+import type { EnrichedTokenSnapshot, EnrichedYieldingBankSnapshot } from "../../src/types/enriched";
+export interface FeeWalletBalance {
+    symbol: string;
+    decimals: number;
+    balance: bigint;
+}
+export declare function formatHeader(env: Environment, tokenCount: number, bankCount: number): string;
+export declare function formatFooter(totalTvlUsd: number): string;
+export declare function formatYieldingBankSnapshot(bank: EnrichedYieldingBankSnapshot, allTokens?: EnrichedTokenSnapshot[]): string;
+export declare function formatTokenSnapshot(token: EnrichedTokenSnapshot, enrichedBanks?: EnrichedYieldingBankSnapshot[]): string;
+export declare function formatFeeWallet(wallet: Address, balances: FeeWalletBalance[]): string;