@kestrelfi/lyc-sdk 1.0.1

package/src/client/builders/createTokenLendingPositionBuilder.ts

@@ -0,0 +1,219 @@
+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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,162 @@
+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

@@ -0,0 +1,95 @@
+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

@@ -0,0 +1,105 @@
+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

@@ -0,0 +1,37 @@
+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";