@kestrelfi/lyc-sdk 1.0.1 → 1.0.3

package/src/client/pda.ts

@@ -1,102 +0,0 @@
-import {
-  type Address,
-  type ProgramDerivedAddressBump,
-  getAddressEncoder,
-  getProgramDerivedAddress,
-} from "@solana/kit";
-
-const addressEncoder = getAddressEncoder();
-
-function u64LeBytes(value: bigint | number): Uint8Array {
-  const bytes = new Uint8Array(8);
-  const view = new DataView(bytes.buffer);
-  view.setBigUint64(0, BigInt(value), true);
-  return bytes;
-}
-
-/**
- * PDA derivation for the long_yield_carry program.
- *
- * The program ID is injected via constructor — no global state.
- */
-export class PdaClient {
-  constructor(private readonly programAddress: Address) {}
-
-  /**
-   * Derives the Token PDA for a given mint and ID.
-   *
-   * Seeds: ["TOKEN", mint_pubkey, id]
-   *
-   * @param mintAddress - The yToken mint address
-   * @param id - The token ID (u8)
-   * @returns Tuple of [PDA address, bump seed]
-   */
-  async deriveTokenPda(
-    mintAddress: Address,
-    id: number
-  ): Promise<readonly [Address, ProgramDerivedAddressBump]> {
-    return await getProgramDerivedAddress({
-      programAddress: this.programAddress,
-      seeds: [Buffer.from("TOKEN"), addressEncoder.encode(mintAddress), new Uint8Array([id])],
-    });
-  }
-
-  /**
-   * Derives the YieldingBank PDA for a given base mint and yielding ID.
-   *
-   * Seeds: ["YIELDING_BANK", base_mint_pubkey, id_le_bytes]
-   *
-   * @param baseMint - The base mint address
-   * @param yieldingId - The yielding bank ID (u8)
-   * @returns Tuple of [PDA address, bump seed]
-   */
-  async deriveYieldingBankPda(
-    baseMint: Address,
-    yieldingId: number
-  ): Promise<readonly [Address, ProgramDerivedAddressBump]> {
-    return await getProgramDerivedAddress({
-      programAddress: this.programAddress,
-      seeds: [
-        Buffer.from("YIELDING_BANK"),
-        addressEncoder.encode(baseMint),
-        new Uint8Array([yieldingId]),
-      ],
-    });
-  }
-
-  async deriveRedemptionEpochPda(
-    token: Address,
-    epochId: bigint | number
-  ): Promise<readonly [Address, ProgramDerivedAddressBump]> {
-    return await getProgramDerivedAddress({
-      programAddress: this.programAddress,
-      seeds: [Buffer.from("REDEMPTION_EPOCH"), addressEncoder.encode(token), u64LeBytes(epochId)],
-    });
-  }
-
-  async deriveAsyncBurnRequestPda(
-    token: Address,
-    epochId: bigint | number,
-    sequence: bigint | number
-  ): Promise<readonly [Address, ProgramDerivedAddressBump]> {
-    return await getProgramDerivedAddress({
-      programAddress: this.programAddress,
-      seeds: [
-        Buffer.from("ASYNC_BURN_REQUEST"),
-        addressEncoder.encode(token),
-        u64LeBytes(epochId),
-        u64LeBytes(sequence),
-      ],
-    });
-  }
-
-  async deriveCpiPlanPda(
-    uniqueId: Address,
-    createdTs: bigint | number
-  ): Promise<readonly [Address, ProgramDerivedAddressBump]> {
-    return await getProgramDerivedAddress({
-      programAddress: this.programAddress,
-      seeds: [Buffer.from("cpi plan"), addressEncoder.encode(uniqueId), u64LeBytes(createdTs)],
-    });
-  }
-}

package/src/client/plans/collectInterest.ts

@@ -1,207 +0,0 @@
-import { BN } from "@anchor-lang/core";
-import type { Address } from "@solana/kit";
-import { PublicKey } from "@solana/web3.js";
-import {
-  bnFromBigInt,
-  calculateTvlUsd,
-  fromUiAmount,
-  fromWeb3Pk,
-  resolveTokenProgram,
-  toBigInt,
-  tvlUsdToBaseUnits,
-} from "common";
-import type { AccountClient } from "../account";
-import type { CollectInterestPlan, CollectInterestPlanParams } from "../types";
-import { NoInterestToCollectError } from "../../errors";
-import { collectableNetYieldUsd } from "../../utils/tokenFeeMath";
-
-/**
- * Ensures the planner produced at least one positive redemption leg. Without this,
- * routing would fail or build an empty CPI list even though share math passed.
- */
-export function assertCollectInterestPlanHasPositiveRedemptions(plan: CollectInterestPlan): void {
-  const hasPositive = plan.holdingsToRedeem.some((h) => h.amount.gt(new BN(0)));
-  if (!hasPositive) {
-    throw new NoInterestToCollectError("No redeemable yielding bank assets — nothing to collect");
-  }
-}
-
-/**
- * Derive deterministic collect-interest values from fresh token and bank state.
- * This intentionally excludes route / venue selection.
- *
- * @param account - Account client used to fetch fresh token and yielding-bank state.
- * @param token - Token PDA whose carry position should collect accrued interest.
- * @param params - Yielding bank to redeem from.
- * @returns Deterministic collect-interest plan without swap routing attached.
- *
- * @throws {NoInterestToCollectError} When carry/debt math rules out collection.
- *
- * Before swap routing, run `assertCollectInterestPlanHasPositiveRedemptions` on the
- * returned plan (the `getCollectInterestTx` transaction builder does this) so rounding
- * cannot yield an empty redemption list.
- */
-export async function buildCollectInterestPlan(
-  account: AccountClient,
-  token: Address,
-  params: CollectInterestPlanParams
-): Promise<CollectInterestPlan> {
-  const [tokenData, bank] = await Promise.all([
-    account.fetchToken(token),
-    account.fetchYieldingBank(params.yieldingBank),
-  ]);
-
-  const carryIndex = tokenData.data.debtCarry.findIndex(
-    (carry) =>
-      !carry.yieldingBaseMint.equals(PublicKey.default) &&
-      fromWeb3Pk(carry.yieldingBaseMint) === bank.baseMint &&
-      carry.yieldingBankId === bank.id &&
-      toBigInt(carry.shares) > BigInt(0)
-  );
-
-  if (carryIndex === -1) {
-    throw new NoInterestToCollectError(
-      `No active carry position found for yielding bank ${params.yieldingBank}`
-    );
-  }
-
-  const carry = tokenData.data.debtCarry[carryIndex];
-  const totalCarryTvl = tokenData.totalCarryTvlUsd;
-  const totalDebtUsd = tokenData.totalLendingDebtTvlUsd;
-  const totalShares = toBigInt(bank.data.accounting.totalShares);
-  const tvlBefore = toBigInt(bank.data.accounting.tvl);
-  const carryShares = toBigInt(carry.shares);
-
-  if (!tokenData.hasInterestToCollect()) {
-    throw new NoInterestToCollectError(
-      "Token is inactive, carry surplus is absent, or surplus exceeds the 1 bp collection limit"
-    );
-  }
-  if (totalShares <= BigInt(0)) {
-    throw new NoInterestToCollectError("Yielding bank has no outstanding shares");
-  }
-  if (tvlBefore <= BigInt(0)) {
-    throw new NoInterestToCollectError("Yielding bank has zero TVL — nothing to collect");
-  }
-
-  // Only redeem from the default redemption mint — the on-chain instruction
-  // enforces this by validating the yb_redemption_token_account ATA.
-  const redemptionMint = bank.defaultRedemptionMint;
-  const redemptionHolding = bank.findAssetHolding(redemptionMint);
-  if (!redemptionHolding) {
-    throw new NoInterestToCollectError(
-      `Default redemption mint ${redemptionMint} has no active asset holding on the yielding bank`
-    );
-  }
-  const redemptionOracle = fromWeb3Pk(redemptionHolding.oracle);
-  const redemptionTokenProgram = resolveTokenProgram(redemptionHolding.tokenProgram);
-
-  // Use the redemption holding's cached on-chain price rather than a freshly
-  // fetched live price. The handler re-reads the same on-chain oracle account
-  // we cached from the previous refresh_yielding_bank, so using the cached
-  // value here lets the SDK predict the handler's `redemption_sold_tvl`
-  // exactly. (An independently-fetched Hermes/live price drifts by a few
-  // fixed-point units from the on-chain account, which previously caused
-  // strict-equality test assertions and the share_price invariant check to
-  // fail on rebalanced banks.)
-  const redemptionPrice = toBigInt(redemptionHolding.price);
-  const redemptionDecimals = redemptionHolding.decimals;
-  const redemptionHoldingAmount = toBigInt(redemptionHolding.amount);
-  if (redemptionPrice <= BigInt(0)) {
-    throw new NoInterestToCollectError(
-      `Redemption mint ${redemptionMint} has no cached price — refresh the yielding bank first`
-    );
-  }
-
-  // Collectable yield is the full carry surplus above debt — must match the on-chain cap.
-  const netYieldUsd = collectableNetYieldUsd(totalCarryTvl, totalDebtUsd);
-
-  if (params.minYieldUsd !== undefined && params.minYieldUsd > 0) {
-    const minYield8Dec = toBigInt(fromUiAmount(params.minYieldUsd, 8));
-    if (netYieldUsd < minYield8Dec) {
-      throw new NoInterestToCollectError(
-        `Net yield $${(Number(netYieldUsd) / 1e8).toFixed(4)} is below minimum $${
-          params.minYieldUsd
-        }`
-      );
-    }
-  }
-
-  // Target shares to burn: capped at this carry position's balance because a
-  // single call cannot drain more than this bank's own carry (the handler
-  // enforces the same cap against `carry.shares`).
-  //
-  // Use the same `totalShares / tvl` ratio as the handler's final derivation
-  // to keep a single truncation across all share-math steps.
-  const unboundedSharesToBurn = (netYieldUsd * totalShares) / tvlBefore;
-  const targetSharesToBurn =
-    unboundedSharesToBurn < carryShares ? unboundedSharesToBurn : carryShares;
-  if (targetSharesToBurn <= BigInt(0)) {
-    throw new NoInterestToCollectError(
-      "Computed shares to burn is zero — yield too small to collect"
-    );
-  }
-
-  // USD value we want the swap to liquidate from the redemption mint. Convert
-  // to raw token units at the cached redemption price to size the swap input.
-  const targetRedemptionTvlUsd = (targetSharesToBurn * tvlBefore) / totalShares;
-  const redemptionAmount = tvlUsdToBaseUnits(
-    targetRedemptionTvlUsd,
-    redemptionPrice,
-    redemptionDecimals
-  );
-
-  if (redemptionAmount > redemptionHoldingAmount) {
-    throw new NoInterestToCollectError(
-      `Redemption mint ${redemptionMint} holding (${redemptionHoldingAmount}) is insufficient ` +
-        `to cover yield redemption (${redemptionAmount}) — rebalance the yielding bank first`
-    );
-  }
-
-  // Predict the handler's phase 6 derivation exactly (same integer-truncation
-  // order): first recompute the *actual* USD value the handler will see from
-  // the sized `redemptionAmount`, then apply the invariant formula
-  // `shares_to_burn = redemption_sold_tvl × total_shares_before / tvl_before`.
-  // The handler uses `total_shares / tvl` rather than `bank_scale /
-  // share_price` to avoid double truncation — mirror that here.
-  const sharesBurnedValueUsd = calculateTvlUsd(
-    redemptionAmount,
-    redemptionPrice,
-    redemptionDecimals
-  );
-  const sharesToBurn = (sharesBurnedValueUsd * totalShares) / tvlBefore;
-  if (sharesToBurn <= BigInt(0)) {
-    throw new NoInterestToCollectError(
-      "Predicted shares to burn is zero — redemption amount rounds down below one share"
-    );
-  }
-
-  const holdingsToRedeem: CollectInterestPlan["holdingsToRedeem"] = [];
-  if (redemptionAmount > BigInt(0)) {
-    holdingsToRedeem.push({
-      mint: redemptionMint,
-      amount: bnFromBigInt(redemptionAmount),
-      isBaseAsset: redemptionMint === bank.baseMint,
-    });
-  }
-
-  return {
-    token,
-    yieldingBank: params.yieldingBank,
-    baseMint: bank.baseMint,
-    redemption: {
-      mint: redemptionMint,
-      tokenProgram: redemptionTokenProgram,
-      oracle: redemptionOracle,
-    },
-    collateral: {
-      mint: fromWeb3Pk(tokenData.data.collateral.mint),
-      tokenProgram: resolveTokenProgram(tokenData.data.collateral.tokenProgram),
-      oracle: fromWeb3Pk(tokenData.data.collateral.oracle),
-    },
-    carryIndex,
-    sharesToBurn: bnFromBigInt(sharesToBurn),
-    sharesBurnedValueUsd: bnFromBigInt(sharesBurnedValueUsd),
-    holdingsToRedeem,
-  };
-}

package/src/client/plans/decreaseCarryPosition.ts

@@ -1,226 +0,0 @@
-import type { Address } from "@solana/kit";
-import { BN } from "@anchor-lang/core";
-import { fromUiAmount, fromWeb3Pk, type SwapClient } from "common";
-import type { LendingPlatformData, ReserveBase } from "lending-platforms";
-import { LeverageService, type LeverageSwapContext } from "lending-platforms";
-import type { TokenLendingPositionData } from "../../models/lycToken";
-import type { LYCYieldingBank } from "../../models/yieldingBank";
-import { LycLendingPositionManager } from "../../services/carry";
-import type { AccountClient } from "../account";
-import type {
-  DecreaseCarryPositionBuilderParams,
-  DecreaseCarryPositionPlan,
-  DecreaseCarryRepaySteering,
-} from "../types";
-
-/**
- * Build the execution plan for `decrease_carry_position`.
- *
- * LYC-specific concerns (permissionless operation handling, steering-based target
- * resolution) live here. Sizing, repay CPI construction, and swap assembly are
- * delegated to the generic {@link LeverageService} from `lending-platforms`.
- */
-export async function buildDecreaseCarryPositionPlan(
-  account: AccountClient,
-  swap: SwapClient,
-  signer: Address,
-  token: Address,
-  params: DecreaseCarryPositionBuilderParams
-): Promise<DecreaseCarryPositionPlan> {
-  const tokenData = await account.fetchToken(token);
-  const position = tokenData.data.lendingPositions[params.lendingPositionIndex];
-  const debtMint = fromWeb3Pk(position.accounting.debt.mint);
-
-  const initialAccounts = await account.getCarryTradeAccounts(
-    token,
-    params.yieldingBank,
-    params.lendingPositionIndex
-  );
-
-  if (params.permissionlessOperation && params.sourceMint !== undefined) {
-    throw new Error(
-      "DecreaseCarryPositionBuilderParams: sourceMint must not be set when permissionlessOperation is true"
-    );
-  }
-
-  params.lendingIx.clearCacheEntry(
-    params.lendingIx.data.userAccountCatKey,
-    fromWeb3Pk(position.protocolUserAcc)
-  );
-  const manager = await LycLendingPositionManager.create(
-    params.lendingIx.data,
-    position,
-    params.environment
-  );
-
-  const { targetUtilizationBps, passTargetUtilizationOnChain } =
-    await resolveRepaySteeringUtilization(manager, position, params.repaySteering);
-
-  const bank = await account.fetchYieldingBank(params.yieldingBank);
-  const { swapContext, sourceAssetHoldingIndex, needsSwapPath } = resolveSwapContext(
-    swap,
-    signer,
-    params,
-    bank,
-    debtMint
-  );
-
-  const { supplyReserve, debtReserve } = manager.reservesManager;
-  const positionState = await manager.getLendingPositionAmounts();
-  const txId = params.txId ?? `decrease-carry-${Date.now()}-${position.protocolUserAcc.toBase58()}`;
-
-  const isFullDeleverage =
-    params.repaySteering?.mode === "explicitTargetUtilization" &&
-    params.repaySteering.targetUtilizationRateBps === 0;
-
-  const repayBaseUnitsOverride = isFullDeleverage
-    ? await resolveFullDeleverageRepayBaseUnits(
-        params.lendingIx.data,
-        position,
-        debtReserve,
-        manager
-      )
-    : undefined;
-
-  const leverageResult = await LeverageService.buildDecreaseLeverage(
-    {
-      lendingIx: params.lendingIx,
-      supplyReserve,
-      debtReserve,
-      user: token,
-      payer: signer,
-      pool: fromWeb3Pk(position.pool),
-      userAccount: fromWeb3Pk(position.protocolUserAcc),
-      txId,
-      environment: params.environment,
-    },
-    {
-      currentSupplyUiAmount: positionState.supplyUiAmount,
-      currentDebtUiAmount: positionState.debtUiAmount,
-      targetUtilizationRateBps: targetUtilizationBps,
-      swapContext,
-      repayBaseUnitsOverride,
-    }
-  );
-
-  return {
-    lendingPositionIndex: params.lendingPositionIndex,
-    repayAmount: leverageResult.repayBaseUnits,
-    preInstructions: leverageResult.preInstructions,
-    initialAccounts,
-    cpiDataGroups: leverageResult.cpiDataGroups,
-    ...(leverageResult.prerequisiteCpis.length
-      ? { tokenPrerequisiteCpis: leverageResult.prerequisiteCpis }
-      : {}),
-    ...(passTargetUtilizationOnChain ? { targetUtilizationRateBps: targetUtilizationBps } : {}),
-    yieldingBank: params.yieldingBank,
-    ...(needsSwapPath && sourceAssetHoldingIndex != null ? { sourceAssetHoldingIndex } : {}),
-  };
-}
-
-/**
- * Sizes a full repay from the refreshed Kamino obligation borrow (+ buffer), not
- * stale token accounting, so the SPL transfer and repay CPI stay in sync.
- */
-async function resolveFullDeleverageRepayBaseUnits(
-  lpData: LendingPlatformData,
-  position: TokenLendingPositionData,
-  debtReserve: ReserveBase,
-  manager: LycLendingPositionManager
-): Promise<BN> {
-  const pool = fromWeb3Pk(position.pool);
-  const userAccount = fromWeb3Pk(position.protocolUserAcc);
-  const obligation = await lpData.maybeFetchUserPositionInPool(pool, userAccount);
-  const borrow = obligation?.borrows.find((entry) => entry.reserve === debtReserve.address);
-
-  const fallbackUi = (await manager.getLendingPositionAmounts()).debtUiAmount;
-  const fallbackBaseUnits = fromUiAmount(fallbackUi, debtReserve.mint.mintDecimals);
-  if (!borrow) {
-    return fallbackBaseUnits;
-  }
-
-  // Kamino obligation debt can exceed stale token accounting by accrued interest
-  // (often 1 base unit on tiny positions). Size the SPL transfer and repay CPI
-  // from the refreshed obligation borrow, not the token snapshot alone.
-  return borrow.amount.gt(fallbackBaseUnits) ? borrow.amount : fallbackBaseUnits;
-}
-
-/**
- * Resolves the utilization target (bps) for leverage sizing and whether that same
- * bps should appear on-chain as `targetUtilizationRateBps` for manager post-repay checks.
- */
-async function resolveRepaySteeringUtilization(
-  manager: LycLendingPositionManager,
-  position: TokenLendingPositionData,
-  steering?: DecreaseCarryRepaySteering
-) {
-  if (!steering) {
-    return {
-      targetUtilizationBps: position.config.targetUtilizationRateBps,
-      passTargetUtilizationOnChain: false,
-    };
-  }
-
-  switch (steering.mode) {
-    case "collateralWithdrawal": {
-      const postWithdrawalTargetUtilizationRateBps =
-        steering.postWithdrawalTargetUtilizationRateBps ?? position.config.targetUtilizationRateBps;
-      const targetUtilizationBps = await manager.calcPreWithdrawalTargetUtilizationRateBps(
-        steering.collateralWithdrawalUiAmount,
-        postWithdrawalTargetUtilizationRateBps
-      );
-      return {
-        targetUtilizationBps,
-        passTargetUtilizationOnChain: steering.allowBelowTargetOnChain === true,
-      };
-    }
-    case "explicitTargetUtilization":
-      return {
-        targetUtilizationBps: steering.targetUtilizationRateBps,
-        passTargetUtilizationOnChain: true,
-      };
-    default: {
-      throw new Error(`Unexpected repaySteering: ${JSON.stringify(steering)}`);
-    }
-  }
-}
-
-/**
- * Swap context when the yielding bank's source asset differs from the debt mint.
- */
-function resolveSwapContext(
-  swap: SwapClient,
-  signer: Address,
-  params: DecreaseCarryPositionBuilderParams,
-  bank: LYCYieldingBank,
-  debtMint: Address
-): {
-  swapContext: LeverageSwapContext | undefined;
-  sourceAssetHoldingIndex: number | null;
-  needsSwapPath: boolean;
-} {
-  const sourceMint = params.sourceMint ?? bank.defaultRedemptionMint;
-  const sourceAssetHoldingIndex = bank.findAssetHoldingIndex(sourceMint);
-  const needsSwapPath = sourceAssetHoldingIndex != null && sourceMint !== debtMint;
-
-  if (!needsSwapPath) {
-    return { swapContext: undefined, sourceAssetHoldingIndex, needsSwapPath };
-  }
-
-  const sourceHolding = bank.findAssetHolding(sourceMint);
-
-  return {
-    swapContext: {
-      swap,
-      sourceMint,
-      debtMint,
-      sourceBalanceBaseUnits: sourceHolding ? BigInt(sourceHolding.amount.toString()) : 0n,
-      swapTarget: params.yieldingBank,
-      payer: signer,
-      slippageBps: params.swapSlippageBps,
-      excludeDexes: params.swapExcludeDexes,
-    },
-    sourceAssetHoldingIndex,
-    needsSwapPath,
-  };
-}

package/src/client/routes/collectInterest.ts

@@ -1,56 +0,0 @@
-import { BN } from "@anchor-lang/core";
-import type { Address } from "@solana/kit";
-import type { CpiData, SwapClient } from "common";
-import { toSafeNumber } from "common";
-import type {
-  CollectInterestExecutionPlan,
-  CollectInterestPlan,
-  CollectInterestRouteBuilderParams,
-} from "../types";
-import { NoInterestToCollectError } from "../../errors";
-
-/**
- * Convert a deterministic collect-interest plan into ordered CPI data.
- * Venue selection and slippage policy live here.
- *
- * @param swapClient - Swap client used for all intermediate and final swaps.
- * @param plan - Deterministic collect-interest plan returned by the planner layer.
- * @param params - Optional routing policy such as output mint and slippage.
- * @returns Executable collect-interest plan with ordered CPI data.
- */
-export async function buildCollectInterestRoutePlan(
-  swapClient: SwapClient,
-  plan: CollectInterestPlan,
-  params: CollectInterestRouteBuilderParams = {},
-  payer?: Address
-): Promise<CollectInterestExecutionPlan> {
-  const outputMint = params.outputMint ?? plan.collateral.mint;
-  const slippageBps = params.slippageBps ?? 100;
-  const cpiData: CpiData[] = [];
-
-  const holding = plan.holdingsToRedeem[0];
-  if (!holding || holding.amount.lte(new BN(0))) {
-    throw new NoInterestToCollectError("Expected positive redeemable yielding bank assets");
-  }
-
-  // Single swap: redemption mint → output mint (collateral or caller override).
-  const quote = await swapClient.getQuote({
-    inputMint: holding.mint,
-    outputMint,
-    amount: toSafeNumber(holding.amount, "collect_interest swap amount"),
-    slippageBps,
-  });
-  const swapCpi = await swapClient.getSwapCpiData(
-    quote,
-    plan.yieldingBank,
-    payer ? { payer } : undefined
-  );
-  cpiData.push(swapCpi);
-
-  return {
-    ...plan,
-    preInstructions: swapCpi.preInstructions ?? [],
-    initialAccounts: [],
-    cpiData,
-  };
-}

package/src/client/transaction.ts

@@ -1,106 +0,0 @@
-import type { TransactionPlan as BaseTransactionPlan } from "common";
-import type { LongYieldCarryBuilderContext } from "./types/builders";
-import {
-  BurnTokenBuilder,
-  ClaimIncentivesBuilder,
-  CollectFeesBuilder,
-  CollectInterestBuilder,
-  CreditUnlentToRedemptionEpochBuilder,
-  CreateCpiPlanBuilder,
-  CreateTokenBuilder,
-  CreateTokenLendingPositionBuilder,
-  CreateYieldingBankAllocationBuilder,
-  CreateYieldingBankBuilder,
-  DecreaseCarryPositionBuilder,
-  DepositUnlentCollateralBuilder,
-  IncreaseCarryPositionBuilder,
-  MintTokenBuilder,
-  RebalanceTokenBuilder,
-  RebalanceYieldingBankBuilder,
-  RecollateralizeLossBuilder,
-  RefreshTokenStateBuilder,
-  RefreshTokensBuilder,
-  RefreshYieldingBankBuilder,
-  ProcessAsyncBurnBuilder,
-  ResetTokenBurnRateLimitBuilder,
-  SetRedemptionEpochStatusBuilder,
-  SetTokenCircuitBreakerBuilder,
-  SetYieldingBankCircuitBreakerBuilder,
-  UpdateLendingPositionConfigBuilder,
-  UpdateTokenConfigurationBuilder,
-  UpdateTokenMetadataBuilder,
-  UpdateYieldingBankConfigBuilder,
-  TopUpUnlentReservesBuilder,
-} from "./builders";
-import type { LongYieldCarryTransactionPlan } from "./types";
-
-export * from "./builders";
-
-export class TransactionClient {
-  readonly burnToken: BurnTokenBuilder;
-  readonly claimIncentives: ClaimIncentivesBuilder;
-  readonly collectFees: CollectFeesBuilder;
-  readonly collectInterest: CollectInterestBuilder;
-  readonly creditUnlentToRedemptionEpoch: CreditUnlentToRedemptionEpochBuilder;
-  readonly createCpiPlan: CreateCpiPlanBuilder;
-  readonly createToken: CreateTokenBuilder;
-  readonly createTokenLendingPosition: CreateTokenLendingPositionBuilder;
-  readonly createYieldingBank: CreateYieldingBankBuilder;
-  readonly createYieldingBankAllocation: CreateYieldingBankAllocationBuilder;
-  readonly decreaseCarryPosition: DecreaseCarryPositionBuilder;
-  readonly depositUnlentCollateral: DepositUnlentCollateralBuilder;
-  readonly increaseCarryPosition: IncreaseCarryPositionBuilder;
-  readonly mintToken: MintTokenBuilder;
-  readonly rebalanceToken: RebalanceTokenBuilder;
-  readonly rebalanceYieldingBank: RebalanceYieldingBankBuilder;
-  readonly recollateralizeLoss: RecollateralizeLossBuilder;
-  readonly refreshTokenState: RefreshTokenStateBuilder;
-  readonly refreshTokens: RefreshTokensBuilder;
-  readonly refreshYieldingBank: RefreshYieldingBankBuilder;
-  readonly processAsyncBurn: ProcessAsyncBurnBuilder;
-  readonly resetTokenBurnRateLimit: ResetTokenBurnRateLimitBuilder;
-  readonly setRedemptionEpochStatus: SetRedemptionEpochStatusBuilder;
-  readonly setTokenCircuitBreaker: SetTokenCircuitBreakerBuilder;
-  readonly setYieldingBankCircuitBreaker: SetYieldingBankCircuitBreakerBuilder;
-  readonly updateLendingPositionConfig: UpdateLendingPositionConfigBuilder;
-  readonly updateTokenConfiguration: UpdateTokenConfigurationBuilder;
-  readonly updateTokenMetadata: UpdateTokenMetadataBuilder;
-  readonly updateYieldingBankConfig: UpdateYieldingBankConfigBuilder;
-  readonly topUpUnlentReserves: TopUpUnlentReservesBuilder;
-
-  constructor(readonly context: LongYieldCarryBuilderContext) {
-    this.burnToken = new BurnTokenBuilder(context);
-    this.claimIncentives = new ClaimIncentivesBuilder(context);
-    this.collectFees = new CollectFeesBuilder(context);
-    this.collectInterest = new CollectInterestBuilder(context);
-    this.creditUnlentToRedemptionEpoch = new CreditUnlentToRedemptionEpochBuilder(context);
-    this.createCpiPlan = new CreateCpiPlanBuilder(context);
-    this.createToken = new CreateTokenBuilder(context);
-    this.createTokenLendingPosition = new CreateTokenLendingPositionBuilder(context);
-    this.createYieldingBank = new CreateYieldingBankBuilder(context);
-    this.createYieldingBankAllocation = new CreateYieldingBankAllocationBuilder(context);
-    this.decreaseCarryPosition = new DecreaseCarryPositionBuilder(context);
-    this.depositUnlentCollateral = new DepositUnlentCollateralBuilder(context);
-    this.increaseCarryPosition = new IncreaseCarryPositionBuilder(context);
-    this.mintToken = new MintTokenBuilder(context);
-    this.rebalanceToken = new RebalanceTokenBuilder(context);
-    this.rebalanceYieldingBank = new RebalanceYieldingBankBuilder(context);
-    this.recollateralizeLoss = new RecollateralizeLossBuilder(context);
-    this.refreshTokenState = new RefreshTokenStateBuilder(context);
-    this.refreshTokens = new RefreshTokensBuilder(context);
-    this.refreshYieldingBank = new RefreshYieldingBankBuilder(context);
-    this.processAsyncBurn = new ProcessAsyncBurnBuilder(context);
-    this.resetTokenBurnRateLimit = new ResetTokenBurnRateLimitBuilder(context);
-    this.setRedemptionEpochStatus = new SetRedemptionEpochStatusBuilder(context);
-    this.setTokenCircuitBreaker = new SetTokenCircuitBreakerBuilder(context);
-    this.setYieldingBankCircuitBreaker = new SetYieldingBankCircuitBreakerBuilder(context);
-    this.updateLendingPositionConfig = new UpdateLendingPositionConfigBuilder(context);
-    this.updateTokenConfiguration = new UpdateTokenConfigurationBuilder(context);
-    this.updateTokenMetadata = new UpdateTokenMetadataBuilder(context);
-    this.updateYieldingBankConfig = new UpdateYieldingBankConfigBuilder(context);
-    this.topUpUnlentReserves = new TopUpUnlentReservesBuilder(context);
-  }
-}
-
-export type TransactionBuilder = TransactionClient[keyof TransactionClient];
-export type CompositeTransactionPlan = BaseTransactionPlan | LongYieldCarryTransactionPlan;