@kestrelfi/lyc-sdk 1.0.1

package/scripts/decreaseCarryPositions.ts

@@ -0,0 +1,359 @@
+import "./env";
+import { type Address, type TransactionSigner } from "@solana/kit";
+import {
+  fromWeb3Pk,
+  LendingPlatform,
+  loadLocalKeypairWithWeb3,
+  mints,
+  createDefaultAnchorProvider,
+} from "common";
+import { LongYieldCarryClient } from "../src/client/client";
+import { LYC_MANAGER_KEYPAIR_FP } from "../src/constants/general";
+import { NoOpTransactionError } from "../src/errors";
+import type { LYCToken, TokenLendingPositionData } from "../src/models/lycToken";
+import { LycLendingPositionManager } from "../src/services/carry/lycLendingPositionManager";
+import { findBestYieldingBankForBurn } from "../src/utils/lycData";
+import {
+  extractKeypairFlag,
+  isLikelyKeypairPath,
+  parseCliEnvironmentAndRest,
+  resolveTokenPda,
+} from "./localUtils";
+
+const USAGE = `Decrease carry positions for eligible lending positions.
+
+Usage:
+  pnpm run decrease-carry -- [test|prod] [TOKEN_PDA|COLLATERAL_SYMBOL] [SLIPPAGE_BPS] [KEYPAIR_JSON]
+
+  TOKEN omitted: scan all tokens and report DCP-eligible positions without sending transactions.
+  TOKEN provided: refresh that token path, then execute DCP for eligible positions only.
+
+Examples:
+  pnpm run decrease-carry -- test
+  pnpm run decrease-carry -- test SOL
+  pnpm run decrease-carry -- test SOL 40 --keypair ~/.config/solana/operator.json`;
+
+type DeployedScriptEnv = "test" | "prod";
+
+interface DecreaseCarryArgs {
+  tokenArg?: string;
+  swapSlippageBps?: number;
+  keypairPath: string;
+}
+
+interface DcpCandidate {
+  lendingPositionIndex: number;
+  position: TokenLendingPositionData;
+  repayUiAmount: number;
+  utilizationRateBps?: number;
+  yieldingBank?: Address;
+  bankSelectionError?: string;
+}
+
+async function main() {
+  const { env, rest } = parseCliEnvironmentAndRest("decrease-carry");
+  const { rest: args, keypairPath: keypairFlagPath } = extractKeypairFlag(rest);
+  const parsed = parseDecreaseCarryArgs(args, keypairFlagPath, env);
+
+  const { signer, web3Keypair } = await loadLocalKeypairWithWeb3(parsed.keypairPath);
+  const provider = createDefaultAnchorProvider(env, web3Keypair);
+  const client = new LongYieldCarryClient(provider, env);
+
+  console.log("Decrease carry position operator");
+  console.log("  environment:", env);
+  console.log("  signer:", signer.address);
+  console.log("  slippage:", parsed.swapSlippageBps ?? 40, "bps");
+
+  if (parsed.tokenArg === undefined) {
+    await scanAllTokens(client);
+    return;
+  }
+
+  const { tokenPda, collateralSymbol } = await resolveTokenPda(client, parsed.tokenArg);
+  console.log("  token:", tokenPda, collateralSymbol ? `(${collateralSymbol})` : "");
+
+  await refreshTokenPath(client, signer, tokenPda);
+  client.clearAllCache();
+
+  const token = await client.account.fetchToken(tokenPda, { fresh: true });
+  await executeEligibleDcps(client, signer, token, parsed.swapSlippageBps);
+}
+
+function parseDecreaseCarryArgs(
+  args: string[],
+  keypairFlagPath: string | undefined,
+  env: DeployedScriptEnv
+): DecreaseCarryArgs {
+  if (args.length > 3) {
+    console.error(USAGE);
+    process.exit(1);
+  }
+
+  let swapSlippageBps: number | undefined;
+  let keypairPath = keypairFlagPath ?? LYC_MANAGER_KEYPAIR_FP[env];
+
+  if (args.length === 0) {
+    return { keypairPath };
+  }
+
+  const first = args[0]!;
+  if (isLikelyKeypairPath(first)) {
+    if (args.length > 1) {
+      console.error(USAGE);
+      process.exit(1);
+    }
+    return { keypairPath: keypairFlagPath ?? first };
+  }
+
+  const tokenArg = first;
+
+  const second = args[1];
+  if (second !== undefined) {
+    if (isLikelyKeypairPath(second)) {
+      keypairPath = keypairFlagPath ?? second;
+    } else {
+      swapSlippageBps = parseSlippageBps(second);
+    }
+  }
+
+  const third = args[2];
+  if (third !== undefined) {
+    if (second !== undefined && isLikelyKeypairPath(second)) {
+      console.error(USAGE);
+      process.exit(1);
+    }
+    keypairPath = keypairFlagPath ?? third;
+  }
+
+  return { tokenArg, swapSlippageBps, keypairPath };
+}
+
+function parseSlippageBps(raw: string): number {
+  const value = parseInt(raw, 10);
+  if (!Number.isInteger(value) || value <= 0) {
+    console.error("SLIPPAGE_BPS must be a positive integer.");
+    process.exit(1);
+  }
+  return value;
+}
+
+async function scanAllTokens(client: LongYieldCarryClient): Promise<void> {
+  const tokens = await client.account.fetchAllTokens({ fresh: true });
+  console.log(`\nScanning ${tokens.length} token(s) for DCP eligibility...`);
+
+  let eligibleTokens = 0;
+  let eligiblePositions = 0;
+
+  for (const [index, token] of tokens.entries()) {
+    const candidates = await collectEligibleDcpCandidates(client, token);
+    if (candidates.length === 0) {
+      console.log(`[${index + 1}/${tokens.length}] ${token.label} - no DCP needed`);
+      continue;
+    }
+
+    eligibleTokens++;
+    eligiblePositions += candidates.length;
+    console.log(
+      `[${index + 1}/${tokens.length}] ${token.label} (${token.address}) needs DCP on ` +
+        `${candidates.length} position(s):`
+    );
+    for (const candidate of candidates) {
+      logCandidate("  ", candidate);
+    }
+  }
+
+  console.log(
+    `\nScan summary: ${eligibleTokens} token(s), ${eligiblePositions} position(s) need DCP`
+  );
+}
+
+async function executeEligibleDcps(
+  client: LongYieldCarryClient,
+  signer: TransactionSigner,
+  token: LYCToken,
+  swapSlippageBps?: number
+): Promise<void> {
+  const candidates = await collectEligibleDcpCandidates(client, token);
+
+  if (candidates.length === 0) {
+    console.log(`\n${token.label} has no DCP-eligible lending positions. Skipping.`);
+    return;
+  }
+
+  let succeeded = 0;
+  let skipped = 0;
+  let failures = 0;
+
+  console.log(`\nExecuting DCP for ${candidates.length} eligible position(s)...`);
+
+  for (const candidate of candidates) {
+    const label = `${token.label} LP[${candidate.lendingPositionIndex}]`;
+    const freshCandidate = await refreshCandidate(
+      client,
+      token.address,
+      candidate.lendingPositionIndex
+    );
+    if (freshCandidate === undefined) {
+      skipped++;
+      console.log(`${label} - skipped: no longer DCP-eligible`);
+      continue;
+    }
+
+    logCandidate("", freshCandidate);
+
+    if (freshCandidate.yieldingBank === undefined) {
+      skipped++;
+      console.log(`${label} - skipped: ${freshCandidate.bankSelectionError ?? "no yielding bank"}`);
+      continue;
+    }
+
+    try {
+      const plan = await client.tx.decreaseCarryPosition.getTx({
+        signer: signer.address,
+        token: token.address,
+        params: {
+          lendingPositionIndex: freshCandidate.lendingPositionIndex,
+          yieldingBank: freshCandidate.yieldingBank,
+          swapSlippageBps,
+          permissionlessOperation: true,
+        },
+      });
+      const sig = await client.sendTransaction(signer, plan);
+      console.log(`${label} - decreased carry position (${sig})`);
+      succeeded++;
+      client.clearAllCache();
+    } catch (err) {
+      if (err instanceof NoOpTransactionError) {
+        skipped++;
+        console.log(`${label} - skipped: ${err.message}`);
+        continue;
+      }
+      failures++;
+      console.error(`${label} - failed: ${(err as Error).message}`);
+    }
+  }
+
+  console.log(`\nSummary: ${succeeded} succeeded, ${skipped} skipped, ${failures} failed`);
+  if (failures > 0) {
+    process.exit(1);
+  }
+}
+
+async function refreshCandidate(
+  client: LongYieldCarryClient,
+  tokenAddress: Address,
+  lendingPositionIndex: number
+): Promise<DcpCandidate | undefined> {
+  const freshToken = await client.account.fetchToken(tokenAddress, { fresh: true });
+  const freshCandidates = await collectEligibleDcpCandidates(client, freshToken);
+  return freshCandidates.find(
+    (candidate) => candidate.lendingPositionIndex === lendingPositionIndex
+  );
+}
+
+async function collectEligibleDcpCandidates(
+  client: LongYieldCarryClient,
+  token: LYCToken
+): Promise<DcpCandidate[]> {
+  if (token.activeCarryPositions.length === 0) {
+    return [];
+  }
+
+  const candidates: DcpCandidate[] = [];
+
+  for (const { index, data: position } of token.usedLendingPositions) {
+    if (client.lendingPlatformClients.getPlatformForPosition(position) !== LendingPlatform.Kamino) {
+      continue;
+    }
+
+    const lpClient = client.getLendingPlatformClient(position);
+    const manager = await LycLendingPositionManager.create(lpClient.data, position);
+    const shouldDecrease = await manager.shouldDecreaseCarryPosition();
+    if (!shouldDecrease) {
+      continue;
+    }
+
+    const debtChangeUiAmount = await manager.calcDebtChangeAmount();
+    const repayUiAmount = Math.abs(debtChangeUiAmount);
+    if (!(repayUiAmount > 0)) {
+      continue;
+    }
+
+    const rates = await manager.getUtilizationRatesBps();
+    const candidate: DcpCandidate = {
+      lendingPositionIndex: index,
+      position,
+      repayUiAmount,
+      utilizationRateBps: rates?.realtime,
+    };
+
+    try {
+      const { yieldingBank } = await findBestYieldingBankForBurn(
+        client.account,
+        token,
+        position,
+        repayUiAmount
+      );
+      candidate.yieldingBank = yieldingBank;
+    } catch (err) {
+      candidate.bankSelectionError = (err as Error).message;
+    }
+
+    candidates.push(candidate);
+  }
+
+  return candidates;
+}
+
+async function refreshTokenPath(
+  client: LongYieldCarryClient,
+  signer: TransactionSigner,
+  token: Address
+): Promise<void> {
+  console.log("\nRefreshing token and yielding bank state...");
+  const refreshPlan = await client.tx.refreshTokens.getTx({
+    signer: signer.address,
+    params: {
+      tokens: [token],
+      alwaysRefreshYieldingBanks: true,
+    },
+  });
+  const sig = await client.sendTransaction(signer, refreshPlan);
+  console.log(`refresh succeeded (${sig})`);
+}
+
+function logCandidate(prefix: string, candidate: DcpCandidate): void {
+  const debtMint = fromWeb3Pk(candidate.position.accounting.debt.mint);
+  const debtLabel = mints.get(debtMint)?.symbol ?? shortAddress(debtMint);
+  const utilization =
+    candidate.utilizationRateBps === undefined
+      ? "unknown"
+      : `${formatBps(candidate.utilizationRateBps)}`;
+  const upperBound =
+    candidate.position.config.targetUtilizationRateBps +
+    candidate.position.config.maxDeviationAboveTargetUtilBps;
+  const bank =
+    candidate.yieldingBank ??
+    (candidate.bankSelectionError ? `unresolved (${candidate.bankSelectionError})` : "unresolved");
+
+  console.log(
+    `${prefix}LP[${candidate.lendingPositionIndex}] debt=${debtLabel} ` +
+      `repay~${candidate.repayUiAmount.toFixed(6)} util=${utilization} ` +
+      `upper=${formatBps(upperBound)} yieldingBank=${bank}`
+  );
+}
+
+function formatBps(bps: number): string {
+  return `${(bps / 100).toFixed(2)}%`;
+}
+
+function shortAddress(value: Address): string {
+  return `${value.slice(0, 6)}...`;
+}
+
+main()
+  .then(() => console.log("Finished"))
+  .catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });

package/scripts/depositUnlentCollateral.ts

@@ -0,0 +1,106 @@
+import "./env";
+import { loadLocalKeypairWithWeb3, mints, createDefaultAnchorProvider } from "common";
+import { LongYieldCarryClient } from "../src/client/client";
+import { LendingPositionService } from "../src/services/lendingPosition";
+import { LYC_MANAGER_KEYPAIR_FP } from "../src/constants/general";
+import { extractKeypairFlag, parseCliEnvironmentAndRest, resolveTokenPda } from "./localUtils";
+
+const USAGE = `Usage:
+
+  pnpm run deposit-unlent -- [test|prod] <TOKEN_PDA|COLLATERAL_SYMBOL> [DEBT_SYMBOL] [KEYPAIR_JSON]
+
+  Example: pnpm run deposit-unlent -- test SOL
+  Example: pnpm run deposit-unlent -- test SOL USDT
+
+  DEBT_SYMBOL: explicit debt mint, or omit to auto-select the optimal position.
+  KEYPAIR_JSON defaults to the manager keypair for the environment.`;
+
+/**
+ * Deposits all unlent collateral from a Token PDA into a lending position.
+ *
+ * When DEBT_SYMBOL is omitted, uses LendingPositionService to find the optimal
+ * position based on pair-adjusted APY. When provided explicitly, deposits into
+ * the position matching that debt mint.
+ */
+async function main() {
+  const { env, rest } = parseCliEnvironmentAndRest("deposit-unlent");
+  const { rest: args, keypairPath: keypairFlagPath } = extractKeypairFlag(rest);
+
+  const tokenArg = args[0];
+  if (tokenArg === undefined) {
+    console.error(USAGE);
+    process.exit(1);
+  }
+
+  const explicitDebtSymbol = args[1]?.toUpperCase();
+  const keypairPath = keypairFlagPath ?? args[2] ?? 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 tokenData = await client.account.fetchToken(tokenPda, { fresh: true });
+  console.log(`Token PDA: ${tokenPda} (collateral: ${collateralSymbol ?? "unknown"})`);
+
+  if (explicitDebtSymbol) {
+    const debtMintInfo = mints.get(explicitDebtSymbol);
+    if (!debtMintInfo) {
+      console.error(
+        `Unknown debt mint symbol "${explicitDebtSymbol}". Known symbols use the common mint registry.`
+      );
+      process.exit(1);
+    }
+
+    const lendingPositionIndex = tokenData.findLendingPositionByDebtMint(debtMintInfo.address);
+    if (lendingPositionIndex === -1) {
+      console.error(
+        `No lending position found with debt ${explicitDebtSymbol}. ` +
+          `Create one first with: pnpm run create-lp -- ${env} ${tokenArg} <lowVol|highVol> ${explicitDebtSymbol}`
+      );
+      process.exit(1);
+    }
+
+    console.log(`Using explicit LP[${lendingPositionIndex}] (debt: ${explicitDebtSymbol})`);
+
+    const refreshPlan = await client.tx.refreshTokens.getTx({
+      signer: managerSigner.address,
+      params: { tokens: [tokenPda] },
+    });
+    await client.sendTransaction(managerSigner, refreshPlan);
+    client.account.dataCache.clearAllCache();
+
+    const depositPlan = await client.tx.depositUnlentCollateral.getTx({
+      manager: managerSigner.address,
+      token: tokenPda,
+      params: { lendingPositionIndex, depositAll: true },
+    });
+    const sig = await client.sendTransaction(managerSigner, depositPlan);
+
+    console.log("deposit_unlent_collateral succeeded.");
+    console.log("  debt:", explicitDebtSymbol);
+    console.log("  lending position index:", lendingPositionIndex);
+    console.log("  signature:", sig);
+  } else {
+    console.log("No debt symbol specified — finding optimal position...");
+    const lpService = new LendingPositionService(client);
+    const result = await lpService.depositToOptimalPosition(managerSigner, tokenData, console.log);
+
+    console.log("deposit_unlent_collateral succeeded.");
+    console.log("  debt:", result.debtSymbol);
+    console.log("  lending position index:", result.lendingPositionIndex);
+    console.log("  signature:", result.signature);
+  }
+
+  console.log("  environment:", env);
+  console.log("  manager:", managerSigner.address);
+  console.log("  token PDA:", tokenPda);
+  console.log("  collateral:", collateralSymbol ?? tokenData.collateralMint);
+}
+
+main()
+  .then(() => console.log("Finished"))
+  .catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });