@kestrelfi/lyc-sdk 1.0.1 → 1.0.3

package/src/client/builders/createTokenLendingPositionBuilder.ts

@@ -1,219 +0,0 @@
-import type { Address, Instruction } from "@solana/kit";
-import {
-  type CpiData,
-  createCpiRefs,
-  fromWeb3Pk,
-  getCreateAtaInstructions,
-  getCreateAtaIxIfNeeded,
-  LendingPlatform,
-  lendingPlatformToEnum,
-  mints,
-  toKitInstruction,
-  toWeb3AccountMeta,
-  toWeb3Pk,
-} from "common";
-import type { AnyLendingPlatformClient } from "lending-platforms";
-import {
-  buildLendingPositionAllocation,
-  getAvailableTokenLendingUserAccountId,
-  getTokenCacheInvalidation,
-  resolveDefaultPool,
-} from "../../utils";
-import { LongYieldCarryBuilderBase } from "./base";
-import type { CreateTokenLendingPositionIxArgs, CreateTokenLendingPositionTxArgs } from "./args";
-import type { LongYieldCarryTransactionPlan } from "../types";
-
-export class CreateTokenLendingPositionBuilder extends LongYieldCarryBuilderBase<
-  CreateTokenLendingPositionIxArgs,
-  CreateTokenLendingPositionTxArgs
-> {
-  async getIx(args: CreateTokenLendingPositionIxArgs): Promise<Instruction> {
-    const tokenData = await this.account.fetchToken(args.token);
-    return this.program.methods
-      .createTokenLendingPosition({
-        lendingPlatform: args.params.lendingPlatform,
-        pool: toWeb3Pk(args.params.pool),
-        debtReserve: toWeb3Pk(args.params.debtReserve),
-        targetUtilizationRateBps: args.params.targetUtilizationRateBps,
-        maxDeviationAboveTargetUtilBps: args.params.maxDeviationAboveTargetUtilBps,
-        maxDeviationBelowTargetUtilBps: args.params.maxDeviationBelowTargetUtilBps,
-        debtMint: toWeb3Pk(args.params.debtMint),
-        debtDecimals: args.params.debtDecimals,
-        debtTokenProgram: args.params.debtTokenProgram,
-        debtOracleType: args.params.debtOracleType,
-        tokenCpis: args.params.tokenCpis ?? null,
-      })
-      .accountsPartial({
-        manager: this.resolveTokenManager(tokenData.data),
-        token: args.token,
-        lpPosition: {
-          userAccount: args.accounts.protocolUserAcc,
-          collateralReserve: args.accounts.collateralReserve,
-          debtOracle: args.accounts.debtOracle,
-        },
-      })
-      .remainingAccounts((args.params.remainingAccounts ?? []).map(toWeb3AccountMeta))
-      .instruction()
-      .then(toKitInstruction);
-  }
-
-  async getTx(txArgs: CreateTokenLendingPositionTxArgs): Promise<LongYieldCarryTransactionPlan> {
-    const tokenData = await this.account.fetchToken(txArgs.token);
-    const manager = this.resolveTokenManager(tokenData.data);
-    const lendingPlatform = txArgs.lendingPlatform ?? LendingPlatform.Kamino;
-    const lpClient = this.lendingPlatformClients.getByPlatform(lendingPlatform);
-    const pool = txArgs.pool ?? resolveDefaultPool(tokenData.collateralMint);
-
-    const duplicatePosition = tokenData.data.lendingPositions.find(
-      (p) =>
-        lendingPlatformToEnum(p.platform) !== LendingPlatform.None &&
-        fromWeb3Pk(p.pool) === pool &&
-        fromWeb3Pk(p.accounting.debt.mint) === txArgs.debtMint
-    );
-    if (duplicatePosition) {
-      throw new Error(
-        `Token ${txArgs.token} already has a lending position on pool ${pool} ` +
-          `with debt mint ${txArgs.debtMint}. Use updateLendingPositionConfig to ` +
-          `modify the existing position instead of creating a duplicate.`
-      );
-    }
-
-    const userAccountId =
-      txArgs.userAccountId ??
-      (await getAvailableTokenLendingUserAccountId({
-        lendingClient: lpClient,
-        token: tokenData,
-        pool,
-        lendingPlatform,
-      }));
-    const txId = txArgs.txId ?? `create-token-lending-position-${Date.now()}`;
-
-    const allocation = await buildLendingPositionAllocation({
-      lendingClient: lpClient,
-      tokenPda: txArgs.token,
-      collateralMint: tokenData.collateralMint,
-      debtMint: txArgs.debtMint,
-      debtReserve: txArgs.debtReserve,
-      userAccountId,
-      pool,
-      lendingPlatform,
-      targetUtilizationRateBps: txArgs.targetUtilizationRateBps,
-      maxDeviationAboveTargetUtilBps: txArgs.maxDeviationAboveTargetUtilBps,
-      maxDeviationBelowTargetUtilBps: txArgs.maxDeviationBelowTargetUtilBps,
-    });
-
-    const tokenCpisData = await this.buildSetupCpis(
-      lpClient,
-      allocation,
-      txArgs.token,
-      manager,
-      userAccountId
-    );
-
-    const {
-      accounts: remainingAccounts,
-      refs: tokenCpis,
-      lookupTables,
-    } = tokenCpisData.length
-      ? createCpiRefs(tokenCpisData)
-      : { accounts: [], refs: undefined, lookupTables: [] as readonly Address[] };
-
-    const preInstructions = tokenCpisData.length ? await lpClient.ix.getPreInstructions(txId) : [];
-    const { instructions: ataCreationIxs, postSuccessCacheInvalidations: ataCacheInvalidations } =
-      tokenCpisData.length
-        ? await getCreateAtaInstructions(this.rpc, manager, remainingAccounts)
-        : { instructions: [] as Instruction[], postSuccessCacheInvalidations: [] };
-
-    // Pre-create the token PDA's debt-mint ATA. Kamino's borrow CPI uses
-    // this ATA as `user_destination_liquidity` and fails with
-    // `AccountNotInitialized` (Anchor 3012) if the token has never held
-    // this mint. Creating it at LP setup means future rebalances/borrows
-    // against this LP don't have to reason about whether the ATA exists.
-    // The dedup-pool ATA pass above can drop the `isRequiredAta` flag if
-    // the same address appears in an earlier CPI without seeds, so we add
-    // an explicit idempotent create here.
-    const debtMintInfo = mints.get(txArgs.debtMint);
-    if (!debtMintInfo) {
-      throw new Error(
-        `CreateTokenLendingPositionBuilder: debt mint ${txArgs.debtMint} not found in mint registry`
-      );
-    }
-    const { instruction: debtAtaIx, postSuccessCacheInvalidations: debtAtaCacheInvalidations } =
-      await getCreateAtaIxIfNeeded(
-        this.rpc,
-        manager,
-        txArgs.debtMint,
-        txArgs.token,
-        debtMintInfo.tokenProgram
-      );
-
-    const ix = await this.getIx({
-      token: txArgs.token,
-      accounts: allocation.accounts,
-      params: {
-        ...allocation.params,
-        tokenCpis,
-        remainingAccounts,
-      },
-    });
-
-    const cpiCacheInvalidations = tokenCpisData.flatMap(
-      (cpi) => cpi.postSuccessCacheInvalidations ?? []
-    );
-
-    return {
-      instructions: [...preInstructions, ...ataCreationIxs, ...(debtAtaIx ? [debtAtaIx] : []), ix],
-      lookupTables: this.getTxLookupTables(txArgs.token, lookupTables ?? []),
-      postSuccessCacheInvalidations: [
-        getTokenCacheInvalidation(txArgs.token),
-        ...cpiCacheInvalidations,
-        ...ataCacheInvalidations,
-        ...debtAtaCacheInvalidations,
-      ],
-      txId,
-    };
-  }
-
-  private async buildSetupCpis(
-    lpClient: AnyLendingPlatformClient,
-    allocation: {
-      pool: Address;
-      protocolUserAccount: Address;
-      collateralReserve: Address;
-      debtReserve: Address;
-    },
-    token: Address,
-    manager: Address,
-    userAccountId: number
-  ): Promise<CpiData[]> {
-    const initBundle = await lpClient.ix.getInitLendingPositionCpiData({
-      pool: allocation.pool,
-      user: token,
-      payer: manager,
-      userAccountId,
-      collateralReserve: allocation.collateralReserve,
-      debtReserve: allocation.debtReserve,
-    });
-    const refreshCpis = await this.buildRefreshCpis(lpClient, allocation);
-    return [...initBundle.allCpis, ...refreshCpis];
-  }
-
-  private async buildRefreshCpis(
-    lpClient: AnyLendingPlatformClient,
-    allocation: {
-      pool: Address;
-      protocolUserAccount: Address;
-      collateralReserve: Address;
-      debtReserve: Address;
-    }
-  ): Promise<CpiData[]> {
-    return lpClient.ix.getPrerequisiteCpisForRefresh([
-      {
-        pool: allocation.pool,
-        userAccount: allocation.protocolUserAccount,
-        collateralReserves: [allocation.collateralReserve],
-        debtReserves: [allocation.debtReserve],
-      },
-    ]);
-  }
-}

package/src/client/builders/createYieldingBankAllocationBuilder.ts

@@ -1,32 +0,0 @@
-import type { Address, Instruction } from "@solana/kit";
-import { toKitInstruction } from "common";
-import { toAnchorAllocationConfig } from "../../utils/ix";
-import { LongYieldCarrySingleInstructionBuilderService } from "./base";
-import type { CreateYieldingBankAllocationIxArgs } from "./args";
-
-export class CreateYieldingBankAllocationBuilder extends LongYieldCarrySingleInstructionBuilderService<CreateYieldingBankAllocationIxArgs> {
-  async getIx(args: CreateYieldingBankAllocationIxArgs): Promise<Instruction> {
-    const allocationMint = args.config.assetHolding?.mint;
-    if (!allocationMint) {
-      throw new Error(
-        "createYieldingBankAllocation requires config.assetHolding.mint " +
-          "to populate the allocation_mint account"
-      );
-    }
-
-    const bankData = await this.account.fetchYieldingBank(args.yieldingBank);
-    return this.program.methods
-      .createYieldingBankAllocation(toAnchorAllocationConfig(args.config))
-      .accountsPartial({
-        manager: this.resolveYieldingBankManager(bankData.data),
-        yieldingBank: args.yieldingBank,
-        allocationMint,
-      })
-      .instruction()
-      .then(toKitInstruction);
-  }
-
-  protected async buildLookupTables(): Promise<readonly Address[]> {
-    return this.getTxLookupTables();
-  }
-}

package/src/client/builders/createYieldingBankBuilder.ts

@@ -1,39 +0,0 @@
-import type { Address, Instruction } from "@solana/kit";
-import { TOKEN_PROGRAM_ADDRESS } from "@solana-program/token";
-import { toKitInstruction, toWeb3Pk } from "common";
-import { PROTOCOL_ADMIN } from "../../constants/general";
-import { LongYieldCarrySingleInstructionBuilderService } from "./base";
-import type { CreateYieldingBankIxArgs } from "./args";
-
-export class CreateYieldingBankBuilder extends LongYieldCarrySingleInstructionBuilderService<CreateYieldingBankIxArgs> {
-  async getIx(args: CreateYieldingBankIxArgs): Promise<Instruction> {
-    const [yieldingBankPda] = await this.pda.deriveYieldingBankPda(args.baseMint, args.params.id);
-    return this.program.methods
-      .createYieldingBank({
-        id: args.params.id,
-        oracleConfig: {
-          oracle: toWeb3Pk(args.params.oracleConfig.oracle),
-          oracleType: args.params.oracleConfig.oracleType,
-          secondaryOracle: args.params.oracleConfig.secondaryOracle
-            ? toWeb3Pk(args.params.oracleConfig.secondaryOracle)
-            : null,
-        },
-      })
-      .accountsPartial({
-        curator: args.curator ?? PROTOCOL_ADMIN[this.environment],
-        adminRole: args.adminRole ?? null,
-        managerRole: args.managerRole ?? null,
-        cbControllerRole: args.cbControllerRole ?? null,
-        baseMint: args.baseMint,
-        defaultRedemptionMint: args.params.defaultRedemptionMint,
-        yieldingBank: yieldingBankPda,
-        baseMintTokenProgram: args.baseMintTokenProgram ?? TOKEN_PROGRAM_ADDRESS,
-      })
-      .instruction()
-      .then(toKitInstruction);
-  }
-
-  protected async buildLookupTables(): Promise<readonly Address[]> {
-    return this.getTxLookupTables();
-  }
-}

package/src/client/builders/decreaseCarryPositionBuilder.ts

@@ -1,162 +0,0 @@
-import type { Address, Instruction } from "@solana/kit";
-import type { TransactionCacheInvalidation } from "common";
-import type {
-  DecreaseCarryPositionTxBuilderParams,
-  DecreaseCarryPositionTxParams,
-  LongYieldCarryTransactionPlan,
-} from "../types";
-import type { LongYieldCarryBuilderContext } from "../types/builders";
-import { LongYieldCarryBuilderBase } from "./base";
-import type { DecreaseCarryPositionIxArgs, DecreaseCarryPositionTxArgs } from "./args";
-import { getLendingUserAccountCacheInvalidation } from "lending-platforms";
-import {
-  getCreateAtaInstructions,
-  requestHeapFrameIx,
-  toKitInstruction,
-  toWeb3AccountMeta,
-  fromWeb3Pk,
-} from "common";
-import { buildDecreaseCarryPositionPlan } from "../plans/decreaseCarryPosition";
-import { MAX_HEAP_FRAME_BYTES } from "../../constants/general";
-import {
-  getTokenCacheInvalidation,
-  getYieldingBankCacheInvalidation,
-  type ResolvedDecreaseCarryCpiPlan,
-  resolveDecreaseCarryCpiPlan,
-} from "../../utils";
-
-export type { ResolvedDecreaseCarryCpiPlan } from "../../utils";
-
-/**
- * Options for {@link DecreaseCarryPositionBuilder.buildTx}. Supports pre-merged CPI accounts
- * and custom heap size.
- */
-export type DecreaseCarryPositionBuildTxOptions = {
-  includePreInstructions: boolean;
-  /** Defaults to {@link MAX_HEAP_FRAME_BYTES}. */
-  heapFrameBytes?: number;
-  /**
-   * When set, skips internal {@link resolveDecreaseCarryCpiPlan}(plan). Use when remaining
-   * accounts already include additional CPI account slots (e.g. lending withdraw merged for burn).
-   */
-  resolvedCpiPlan?: ResolvedDecreaseCarryCpiPlan;
-  /** When set, the DCP loss is attributed to this epoch instead of socialised into the price. */
-  redemptionEpoch?: Address;
-};
-
-export class DecreaseCarryPositionBuilder extends LongYieldCarryBuilderBase<
-  DecreaseCarryPositionIxArgs,
-  DecreaseCarryPositionTxArgs
-> {
-  constructor(context: LongYieldCarryBuilderContext) {
-    super(context);
-  }
-
-  async getIx(args: DecreaseCarryPositionIxArgs): Promise<Instruction> {
-    return this.program.methods
-      .decreaseCarryPosition({
-        prerequisiteCpis: args.params.prerequisiteCpis ?? null,
-        targetUtilizationRateBps: args.params.targetUtilizationRateBps ?? null,
-        ybIxRefs: args.params.ybIxRefs ?? null,
-        tokenIxRefs: args.params.tokenIxRefs,
-        lendingPositionIndex: args.params.lendingPositionIndex,
-        repayAmount: args.params.repayAmount ?? null,
-        sourceAssetHoldingIndex: args.params.sourceAssetHoldingIndex ?? null,
-      })
-      .accountsPartial({
-        signer: args.signer,
-        redemptionEpoch: args.params.redemptionEpoch ?? null,
-      })
-      .remainingAccounts(args.params.remainingAccounts.map(toWeb3AccountMeta))
-      .instruction()
-      .then(toKitInstruction);
-  }
-
-  async getTx(args: DecreaseCarryPositionTxArgs): Promise<LongYieldCarryTransactionPlan> {
-    return this.buildTx(args.signer, args.token, args.params, {
-      includePreInstructions: true,
-      redemptionEpoch: args.redemptionEpoch,
-    });
-  }
-
-  async buildTx(
-    signer: Address,
-    token: Address,
-    params: DecreaseCarryPositionTxParams,
-    options: DecreaseCarryPositionBuildTxOptions
-  ): Promise<LongYieldCarryTransactionPlan> {
-    const plan = "plan" in params ? params.plan : await this.buildPlan(signer, token, params);
-    const tokenData = await this.account.fetchToken(token);
-    const position = tokenData.data.lendingPositions[plan.lendingPositionIndex];
-    const instructions: Instruction[] = [];
-
-    if (options.includePreInstructions) {
-      instructions.push(...plan.preInstructions);
-    }
-
-    const {
-      accounts: remainingAccounts,
-      prerequisiteCpis,
-      tokenIxRefs,
-      ybIxRefs,
-      lookupTables,
-    } = options.resolvedCpiPlan ?? resolveDecreaseCarryCpiPlan(plan);
-
-    const { instructions: ataCreationIxs, postSuccessCacheInvalidations: ataPostSuccess } =
-      await getCreateAtaInstructions(this.rpc, signer, remainingAccounts);
-    instructions.push(...ataCreationIxs);
-    const decreaseCarryIx = await this.getIx({
-      signer,
-      params: {
-        prerequisiteCpis,
-        targetUtilizationRateBps: plan.targetUtilizationRateBps,
-        ybIxRefs,
-        tokenIxRefs,
-        lendingPositionIndex: plan.lendingPositionIndex,
-        ...(plan.omitOnChainRepayAmount ? {} : { repayAmount: plan.repayAmount }),
-        sourceAssetHoldingIndex: plan.sourceAssetHoldingIndex,
-        redemptionEpoch: options.redemptionEpoch,
-        remainingAccounts,
-      },
-    });
-    if (options.includePreInstructions) {
-      // Heap configuration applies only to its transaction, so keep it
-      // adjacent to and indivisible from the CPI-heavy instruction. Earlier
-      // refresh and ATA setup instructions remain available to the splitter.
-      instructions.push(
-        requestHeapFrameIx(options.heapFrameBytes ?? MAX_HEAP_FRAME_BYTES),
-        decreaseCarryIx
-      );
-    } else {
-      instructions.push(decreaseCarryIx);
-    }
-
-    const postSuccessCacheInvalidations: TransactionCacheInvalidation[] = [
-      getTokenCacheInvalidation(token),
-      getYieldingBankCacheInvalidation(plan.yieldingBank),
-      getLendingUserAccountCacheInvalidation(fromWeb3Pk(position.protocolUserAcc)),
-      ...ataPostSuccess,
-    ];
-
-    return {
-      instructions,
-      lookupTables: this.getTxLookupTables(token, lookupTables ?? []),
-      segmentLengths: options.includePreInstructions
-        ? [...instructions.slice(0, -2).map(() => 1), 2]
-        : undefined,
-      postSuccessCacheInvalidations,
-    };
-  }
-
-  async buildPlan(signer: Address, token: Address, params: DecreaseCarryPositionTxBuilderParams) {
-    const tokenData = await this.account.fetchToken(token);
-    const position = tokenData.data.lendingPositions[params.lendingPositionIndex];
-    const lpClient = this.getLendingPlatformClient(position);
-
-    return buildDecreaseCarryPositionPlan(this.account, this.swap, signer, token, {
-      ...params,
-      lendingIx: lpClient.ix,
-      environment: this.context.environment,
-    });
-  }
-}

package/src/client/builders/depositUnlentCollateralBuilder.ts

@@ -1,95 +0,0 @@
-import type { Address, Instruction } from "@solana/kit";
-import type { LongYieldCarryTransactionPlan } from "../types";
-import { LongYieldCarryBuilderBase } from "./base";
-import type { DepositUnlentCollateralIxArgs, DepositUnlentCollateralTxArgs } from "./args";
-import {
-  createCpiRefs,
-  fromWeb3Pk,
-  getCreateAtaInstructions,
-  resolveTokenProgram,
-  toKitInstruction,
-  toUiAmount,
-  toWeb3AccountMeta,
-} from "common";
-
-export class DepositUnlentCollateralBuilder extends LongYieldCarryBuilderBase<
-  DepositUnlentCollateralIxArgs,
-  DepositUnlentCollateralTxArgs
-> {
-  async getIx(args: DepositUnlentCollateralIxArgs): Promise<Instruction> {
-    const tokenData = await this.account.fetchToken(args.token);
-    const position = tokenData.data.lendingPositions[args.params.lendingPositionIndex];
-    const collateralMint = fromWeb3Pk(tokenData.data.collateral.mint);
-    const collateralTokenProgram = resolveTokenProgram(tokenData.data.collateral.tokenProgram);
-
-    return this.program.methods
-      .depositUnlentCollateral(args.params.ixRefs, args.params.lendingPositionIndex)
-      .accountsPartial({
-        manager: this.resolveTokenManager(tokenData.data),
-        token: args.token,
-        collateralMint,
-        collateralTokenProgram,
-        lendingPositionUserAccount: position ? fromWeb3Pk(position.protocolUserAcc) : args.token,
-        lendingPositionCollateralReserve: position
-          ? fromWeb3Pk(position.collateralReserve)
-          : args.token,
-      })
-      .remainingAccounts(args.params.remainingAccounts.map(toWeb3AccountMeta))
-      .instruction()
-      .then(toKitInstruction);
-  }
-
-  async getTx(args: DepositUnlentCollateralTxArgs): Promise<LongYieldCarryTransactionPlan> {
-    const tokenData = await this.account.fetchToken(args.token, { fresh: args.params.depositAll });
-    const position = tokenData.data.lendingPositions[args.params.lendingPositionIndex];
-    const uiAmount = args.params.depositAll
-      ? toUiAmount(tokenData.data.collateral.unlentAmount, tokenData.data.collateral.decimals)
-      : args.params.uiAmount!;
-
-    if (args.params.depositAll && uiAmount === 0) {
-      throw new Error(
-        `depositAll: unlentAmount is 0 on token ${args.token} (raw: ${tokenData.data.collateral.unlentAmount})`
-      );
-    }
-
-    const txId =
-      args.params.txId ??
-      `deposit-unlent-collateral-${Date.now()}-${position.protocolUserAcc.toBase58()}`;
-    const manager = this.resolveTokenManager(tokenData.data);
-    const cpiBundle = await this.getLendingOperationCpiData(
-      args.token,
-      manager,
-      position,
-      txId,
-      "deposit",
-      uiAmount
-    );
-    const {
-      accounts: remainingAccounts,
-      refs: ixRefs,
-      lookupTables,
-    } = createCpiRefs(cpiBundle.allCpis);
-    const lpClient = this.getLendingPlatformClient(position);
-    const preInstructions = await lpClient.ix.getPreInstructions(txId);
-    const { instructions: ataCreationIxs, postSuccessCacheInvalidations } =
-      await getCreateAtaInstructions(this.rpc, args.manager, remainingAccounts);
-    const depositIx = await this.getIx({
-      token: args.token,
-      params: {
-        ixRefs,
-        lendingPositionIndex: args.params.lendingPositionIndex,
-        remainingAccounts,
-      },
-    });
-
-    return {
-      instructions: [...preInstructions, ...ataCreationIxs, depositIx],
-      lookupTables: this.getTxLookupTables(args.token, lookupTables ?? []),
-      postSuccessCacheInvalidations: [
-        ...cpiBundle.postSuccessCacheInvalidations,
-        ...postSuccessCacheInvalidations,
-      ],
-      txId,
-    };
-  }
-}

package/src/client/builders/increaseCarryPositionBuilder.ts

@@ -1,105 +0,0 @@
-import type { Address, Instruction } from "@solana/kit";
-import type { LongYieldCarryTransactionPlan } from "../types";
-import { LongYieldCarryBuilderBase } from "./base";
-import type { IncreaseCarryPositionIxArgs, IncreaseCarryPositionTxArgs } from "./args";
-import {
-  createMultiCpiRefs,
-  fromWeb3Pk,
-  getCreateAtaInstructions,
-  toKitInstruction,
-  toWeb3AccountMeta,
-} from "common";
-import { NoOpTransactionError } from "../../errors";
-import { getTokenCacheInvalidation, getYieldingBankCacheInvalidation } from "../../utils";
-import { getLendingUserAccountCacheInvalidation } from "lending-platforms";
-import { RefreshYieldingBankBuilder } from "./refreshYieldingBankBuilder";
-
-export class IncreaseCarryPositionBuilder extends LongYieldCarryBuilderBase<
-  IncreaseCarryPositionIxArgs,
-  IncreaseCarryPositionTxArgs
-> {
-  async getIx(args: IncreaseCarryPositionIxArgs): Promise<Instruction> {
-    const tokenData = await this.account.fetchToken(args.token);
-    return this.program.methods
-      .increaseCarryPosition({
-        prerequisiteCpis: args.params.prerequisiteCpis ?? null,
-        ixRefs: args.params.ixRefs,
-        lendingPositionIndex: args.params.lendingPositionIndex,
-      })
-      .accountsPartial({ manager: this.resolveTokenManager(tokenData.data) })
-      .remainingAccounts(args.params.remainingAccounts.map(toWeb3AccountMeta))
-      .instruction()
-      .then(toKitInstruction);
-  }
-
-  async getTx(args: IncreaseCarryPositionTxArgs): Promise<LongYieldCarryTransactionPlan> {
-    if (!Number.isFinite(args.params.uiAmount) || args.params.uiAmount <= 0) {
-      throw new NoOpTransactionError(
-        `Invalid uiAmount for increase carry position: ${args.params.uiAmount} (must be a positive finite number)`
-      );
-    }
-
-    const tokenData = await this.account.fetchToken(args.token);
-    const position = tokenData.data.lendingPositions[args.params.lendingPositionIndex];
-    const carryTradeAccounts = await this.account.getCarryTradeAccounts(
-      args.token,
-      args.params.yieldingBank,
-      args.params.lendingPositionIndex
-    );
-    const txId =
-      args.params.txId ?? `increase-carry-${Date.now()}-${position.protocolUserAcc.toBase58()}`;
-    const lpClient = this.getLendingPlatformClient(position);
-    const manager = this.resolveTokenManager(tokenData.data);
-    const { prerequisiteCpis, cpis, postSuccessCacheInvalidations } =
-      await this.getLendingOperationCpiData(
-        args.token,
-        manager,
-        position,
-        txId,
-        "borrow",
-        args.params.uiAmount
-      );
-    const {
-      accounts: remainingAccounts,
-      refsGroups,
-      lookupTables,
-    } = createMultiCpiRefs(prerequisiteCpis.length ? [prerequisiteCpis, cpis] : [cpis], {
-      initialAccounts: carryTradeAccounts,
-    });
-    const prerequisiteCpiRefs = prerequisiteCpis.length ? refsGroups[0] : undefined;
-    const ixRefs = refsGroups[prerequisiteCpis.length ? 1 : 0];
-    const preInstructions = await lpClient.ix.getPreInstructions(txId);
-    const { instructions: ataCreationIxs, postSuccessCacheInvalidations: ataCreationCacheInv } =
-      await getCreateAtaInstructions(this.rpc, args.manager, remainingAccounts);
-    const refreshYieldingBankPlan = await new RefreshYieldingBankBuilder(this.context).getTx({
-      signer: args.manager,
-      yieldingBank: args.params.yieldingBank,
-    });
-
-    return {
-      instructions: [
-        ...preInstructions,
-        ...ataCreationIxs,
-        ...refreshYieldingBankPlan.instructions,
-        await this.getIx({
-          token: args.token,
-          params: {
-            prerequisiteCpis: prerequisiteCpiRefs,
-            ixRefs,
-            lendingPositionIndex: args.params.lendingPositionIndex,
-            remainingAccounts,
-          },
-        }),
-      ],
-      lookupTables: this.getTxLookupTables(args.token, lookupTables ?? []),
-      postSuccessCacheInvalidations: [
-        getTokenCacheInvalidation(args.token),
-        getYieldingBankCacheInvalidation(args.params.yieldingBank),
-        getLendingUserAccountCacheInvalidation(fromWeb3Pk(position.protocolUserAcc)),
-        ...postSuccessCacheInvalidations,
-        ...ataCreationCacheInv,
-      ],
-      txId,
-    };
-  }
-}

package/src/client/builders/index.ts

@@ -1,37 +0,0 @@
-export {
-  CreditUnlentToRedemptionEpochBuilder,
-  ProcessAsyncBurnBuilder,
-  SetRedemptionEpochStatusBuilder,
-  TopUpUnlentReservesBuilder,
-} from "./asyncBurnBuilder";
-export { getRefreshTokenInstructionsIfStale } from "./utils";
-export { BurnTokenBuilder, type BundledBurnPlan } from "./burnTokenBuilder";
-export { ClaimIncentivesBuilder } from "./claimIncentivesBuilder";
-export { CollectFeesBuilder } from "./collectFeesBuilder";
-export { CollectInterestBuilder } from "./collectInterestBuilder";
-export { CreateCpiPlanBuilder } from "./createCpiPlanBuilder";
-export { CreateTokenBuilder } from "./createTokenBuilder";
-export { CreateTokenLendingPositionBuilder } from "./createTokenLendingPositionBuilder";
-export { CreateYieldingBankAllocationBuilder } from "./createYieldingBankAllocationBuilder";
-export { CreateYieldingBankBuilder } from "./createYieldingBankBuilder";
-export {
-  DecreaseCarryPositionBuilder,
-  type DecreaseCarryPositionBuildTxOptions,
-  type ResolvedDecreaseCarryCpiPlan,
-} from "./decreaseCarryPositionBuilder";
-export { DepositUnlentCollateralBuilder } from "./depositUnlentCollateralBuilder";
-export { IncreaseCarryPositionBuilder } from "./increaseCarryPositionBuilder";
-export { MintTokenBuilder } from "./mintTokenBuilder";
-export { RebalanceTokenBuilder } from "./rebalanceTokenBuilder";
-export { RebalanceYieldingBankBuilder } from "./rebalanceYieldingBankBuilder";
-export { RecollateralizeLossBuilder } from "./recollateralizeLossBuilder";
-export { RefreshTokenStateBuilder } from "./refreshTokenStateBuilder";
-export { RefreshTokensBuilder } from "./refreshTokensBuilder";
-export { RefreshYieldingBankBuilder } from "./refreshYieldingBankBuilder";
-export { ResetTokenBurnRateLimitBuilder } from "./resetTokenBurnRateLimitBuilder";
-export { SetTokenCircuitBreakerBuilder } from "./setTokenCircuitBreakerBuilder";
-export { SetYieldingBankCircuitBreakerBuilder } from "./setYieldingBankCircuitBreakerBuilder";
-export { UpdateLendingPositionConfigBuilder } from "./updateLendingPositionConfigBuilder";
-export { UpdateTokenConfigurationBuilder } from "./updateTokenConfigurationBuilder";
-export { UpdateTokenMetadataBuilder } from "./updateTokenMetadataBuilder";
-export { UpdateYieldingBankConfigBuilder } from "./updateYieldingBankConfigBuilder";