@kestrelfi/lyc-sdk 1.0.1 → 1.0.3

package/src/client/builders/mintTokenBuilder.ts

@@ -1,137 +0,0 @@
-import type { Instruction } from "@solana/kit";
-import { BN } from "@anchor-lang/core";
-import type { LongYieldCarryTransactionPlan } from "../types";
-import { LongYieldCarryBuilderBase } from "./base";
-import type { MintTokenIxArgs, MintTokenTxArgs } from "./args";
-import {
-  getAtaAddress,
-  getCreateAtaIxIfNeeded,
-  mints,
-  resolveTokenProgram,
-  toKitInstruction,
-} from "common";
-import { AMOUNT_ALL_SENTINEL } from "../../constants/general";
-import { getRefreshTokenInstructionsIfStale } from "./utils";
-
-/** Reserve kept in the wallet when depositing "all" SOL (covers tx fees + rent). */
-const SOL_RESERVE_LAMPORTS = 10_000_000; // 0.01 SOL
-
-export class MintTokenBuilder extends LongYieldCarryBuilderBase<MintTokenIxArgs, MintTokenTxArgs> {
-  async getIx(args: MintTokenIxArgs): Promise<Instruction> {
-    const tokenData = await this.account.fetchToken(args.token);
-    const mint = tokenData.mint;
-    const collateralMint = tokenData.collateralMint;
-    const tokenProgram = resolveTokenProgram(tokenData.data.config.tokenProgram);
-    const collateralTokenProgram = resolveTokenProgram(tokenData.data.collateral.tokenProgram);
-    const userCollateralAccount = await getAtaAddress(
-      collateralMint,
-      args.signer,
-      collateralTokenProgram
-    );
-    const userTokenAccount = await getAtaAddress(mint, args.signer, tokenProgram);
-    const collateralTokenAccount = await getAtaAddress(
-      collateralMint,
-      args.token,
-      collateralTokenProgram
-    );
-
-    return this.program.methods
-      .mintToken(args.depositAmount)
-      .accountsPartial({
-        signer: args.signer,
-        token: args.token,
-        mint,
-        collateralMint,
-        userCollateralAccount,
-        userTokenAccount,
-        collateralTokenAccount,
-        tokenProgram,
-        collateralTokenProgram,
-      })
-      .instruction()
-      .then(toKitInstruction);
-  }
-
-  async getTx(args: MintTokenTxArgs): Promise<LongYieldCarryTransactionPlan> {
-    const isAll = args.params.depositAmount === "all";
-
-    const tokenData = await this.account.fetchToken(args.token);
-    const mint = tokenData.mint;
-    const collateralMint = tokenData.collateralMint;
-    const tokenProgram = resolveTokenProgram(tokenData.data.config.tokenProgram);
-    const instructions: Instruction[] = [];
-    const postSuccessCacheInvalidations: NonNullable<
-      LongYieldCarryTransactionPlan["postSuccessCacheInvalidations"]
-    > = [];
-    instructions.push(
-      ...(await getRefreshTokenInstructionsIfStale(this.context, args.signer, tokenData))
-    );
-
-    // Resolve the deposit amount. For native SOL + "all", we query the wallet
-    // balance and reserve 0.01 SOL for tx fees, then wrap that concrete amount.
-    // For non-SOL + "all", use the on-chain sentinel so the program reads the
-    // ATA balance at execution time.
-    const solMint = mints.get("SOL");
-    const isSolCollateral = solMint != null && collateralMint === solMint.address;
-    let depositAmount: BN;
-
-    if (isAll && isSolCollateral) {
-      const { value: balanceLamports } = await this.rpc.getBalance(args.signer).send();
-      const available = BigInt(balanceLamports.toString()) - BigInt(SOL_RESERVE_LAMPORTS);
-      if (available <= 0n) {
-        throw new Error(
-          `Insufficient SOL balance: need more than ${
-            SOL_RESERVE_LAMPORTS / 1e9
-          } SOL reserved for fees`
-        );
-      }
-      depositAmount = new BN(available.toString());
-    } else if (isAll) {
-      depositAmount = AMOUNT_ALL_SENTINEL;
-    } else {
-      depositAmount = args.params.depositAmount as BN;
-    }
-
-    if (!isAll || isSolCollateral) {
-      const wrap = await this.getWrapSolInstructionsIfMintIsSol(
-        args.signer,
-        collateralMint,
-        depositAmount
-      );
-      if (wrap.instructions) {
-        instructions.push(...wrap.instructions);
-      }
-      if (wrap.postSuccessCacheInvalidations) {
-        postSuccessCacheInvalidations.push(...wrap.postSuccessCacheInvalidations);
-      }
-    }
-
-    const createAtaOptions = { accountClient: this.account };
-    const yTokenAta = await getCreateAtaIxIfNeeded(
-      this.rpc,
-      args.signer,
-      mint,
-      args.signer,
-      tokenProgram,
-      createAtaOptions
-    );
-    if (yTokenAta.instruction) {
-      instructions.push(yTokenAta.instruction);
-    }
-    postSuccessCacheInvalidations.push(...yTokenAta.postSuccessCacheInvalidations);
-    instructions.push(
-      await this.getIx({
-        signer: args.signer,
-        token: args.token,
-        depositAmount,
-      })
-    );
-    postSuccessCacheInvalidations.push({ client: "lycToken", tokenPda: args.token });
-
-    return {
-      instructions,
-      lookupTables: this.getTxLookupTables(args.token),
-      postSuccessCacheInvalidations,
-    };
-  }
-}

package/src/client/builders/rebalanceTokenBuilder.ts

@@ -1,356 +0,0 @@
-import { BN } from "@anchor-lang/core";
-import type { Instruction } from "@solana/kit";
-import {
-  createMultiCpiRefs,
-  enumToOracleType,
-  type CpiData,
-  fromWeb3Pk,
-  getCreateAtaInstructions,
-  getCreateAtaIxIfNeeded,
-  mints,
-  requestHeapFrameIx,
-  toKitInstruction,
-  toUiAmount,
-  toWeb3AccountMeta,
-} from "common";
-import { oracle } from "oracle";
-import {
-  LeverageService,
-  type FlashRebalanceContext,
-  type FlashRebalanceResult,
-} from "lending-platforms";
-import {
-  getTokenCacheInvalidation,
-  getYieldingBankCacheInvalidation,
-  mergeLycLookupTables,
-} from "../../utils";
-import type { LongYieldCarryTransactionPlan } from "../types";
-import type { TokenLendingPositionData } from "../../models/lycToken";
-import { LongYieldCarryBuilderBase } from "./base";
-import type { RebalanceTokenIxArgs, RebalanceTokenTxArgs } from "./args";
-import { MAX_HEAP_FRAME_BYTES } from "../../constants/general";
-import { RefreshYieldingBankBuilder } from "./refreshYieldingBankBuilder";
-import { CreateCpiPlanBuilder } from "./createCpiPlanBuilder";
-
-export class RebalanceTokenBuilder extends LongYieldCarryBuilderBase<
-  RebalanceTokenIxArgs,
-  RebalanceTokenTxArgs
-> {
-  async getIx(args: RebalanceTokenIxArgs): Promise<Instruction> {
-    const tokenData = await this.account.fetchToken(args.token);
-
-    return this.program.methods
-      .rebalanceToken({
-        lpIndex: args.params.lpIndex,
-        destinationDebtOracleType: args.params.destinationDebtOracleType,
-        flashFeeAmount: args.params.flashFeeAmount,
-        repayAmount: args.params.repayAmount,
-      })
-      .accountsPartial({
-        manager: this.resolveTokenManager(tokenData.data),
-        cpiPlan: args.params.cpiPlan,
-      })
-      .remainingAccounts(args.params.remainingAccounts.map(toWeb3AccountMeta))
-      .instruction()
-      .then(toKitInstruction);
-  }
-
-  async getTx(args: RebalanceTokenTxArgs): Promise<LongYieldCarryTransactionPlan> {
-    const tokenData = await this.account.fetchToken(args.token);
-    const { lpIndex, destinationDebtMint } = args.params;
-    const position = tokenData.data.lendingPositions[lpIndex];
-    if (!position) {
-      throw new Error(`rebalance_token: no lending position at index ${lpIndex}`);
-    }
-    const txId = args.params.txId ?? `rebalance-token-${Date.now()}`;
-    const yieldingBank =
-      args.params.yieldingBank ?? (await tokenData.resolveFirstYieldingBankAddress(this.pda));
-    const lpClient = this.getLendingPlatformClient(position);
-    const pool = fromWeb3Pk(position.pool);
-    const withdrawAll = args.params.uiAmount === "all";
-    const collateralUiAmount =
-      args.params.uiAmount === "all"
-        ? toUiAmount(position.accounting.collateral, tokenData.data.collateral.decimals)
-        : args.params.uiAmount;
-
-    // Fetch source debt reserve (by address), supply reserve (by address), and
-    // destination debt reserve (by mint, since the position currently holds the old mint).
-    const [sourceDebtReserve, supplyReserve, destDebtReserve] = await Promise.all([
-      lpClient.data.fetchReserve(pool, fromWeb3Pk(position.debtReserve)),
-      lpClient.data.fetchReserve(pool, fromWeb3Pk(position.collateralReserve)),
-      lpClient.data.fetchReserveByMint(pool, destinationDebtMint),
-    ]);
-    if (!sourceDebtReserve || !supplyReserve || !destDebtReserve) {
-      throw new Error("rebalance_token: failed to fetch one or more lending-position reserves");
-    }
-
-    const manager = this.resolveTokenManager(tokenData.data);
-    const flashLoan = lpClient.getFlashLoan();
-    const userAccount = fromWeb3Pk(position.protocolUserAcc);
-
-    // Both legs operate on the same position: supply never moves, only debt mint changes.
-    const flashContext: FlashRebalanceContext = {
-      source: {
-        lendingIx: lpClient.ix,
-        supplyReserve,
-        debtReserve: sourceDebtReserve,
-        pool,
-        userAccount,
-      },
-      destination: {
-        lendingIx: lpClient.ix,
-        supplyReserve,
-        debtReserve: destDebtReserve,
-        pool,
-        userAccount,
-      },
-      flashLoan,
-      swap: this.swap,
-      user: args.token,
-      payer: manager,
-      txId,
-      environment: this.environment,
-    };
-
-    const flash = await this.buildFlashRebalanceOrSkip(flashContext, {
-      collateralUiAmount,
-      sourceTargetUtilizationRateBps: position.config.targetUtilizationRateBps,
-      destinationMaxUtilizationRateBps: this.maxPostRebalanceUtilizationBps(position),
-      swapSlippageBps: args.params.swapSlippageBps,
-      maxSwapCostBps: args.params.maxSwapCostBps,
-      maxMarketBasisBps: args.params.maxMarketBasisBps,
-      withdrawAll,
-    });
-
-    const destDebtOracleData = oracle.getOracleData(destinationDebtMint);
-    if (!destDebtOracleData) {
-      throw new Error(
-        `rebalance_token: no oracle registered for destination debt mint ${destinationDebtMint}`
-      );
-    }
-    const destDebtOracle = destDebtOracleData.oracle;
-    const destDebtOracleType = enumToOracleType(destDebtOracleData.oracleType);
-
-    const initialAccounts = await this.account.getRebalanceTokenInitialAccounts(
-      args.token,
-      yieldingBank,
-      lpIndex,
-      destDebtOracle,
-      args.params.lpPosition
-    );
-
-    // Pack all inner CPIs into one remaining-accounts pool that starts with
-    // the rebalance-token initial accounts. CPIs that reference the token,
-    // yielding bank, ATAs, or LP refresh accounts deduplicate against these
-    // fixed slots — shrinking the transaction's account list.
-    // The new debt reserve is tracked in the borrow ref (tracked[0]) so the
-    // on-chain handler can update the destination lending position's
-    // debt_reserve in place without an extra instruction parameter.
-    const cpiGroups = this.collectFlashCpiGroups(flash);
-    const {
-      accounts: remainingAccounts,
-      refsGroups,
-      lookupTables,
-    } = createMultiCpiRefs(cpiGroups.groups, {
-      initialAccounts,
-      trackAddresses: [destDebtReserve.address, destinationDebtMint],
-    });
-    const refs = cpiGroups.indices;
-    const planRefs = [
-      refsGroups[refs.sourceRepay],
-      refsGroups[refs.destinationBorrow],
-      refsGroups[refs.swap],
-    ];
-
-    const { instructions: ataCreationIxs, postSuccessCacheInvalidations: ataPostSuccess } =
-      await getCreateAtaInstructions(this.rpc, manager, remainingAccounts);
-
-    // The Kamino destination borrow CPI sets `user_destination_liquidity` to
-    // the token PDA's destination-debt ATA. When the token has never held
-    // that mint, the ATA is missing and Kamino fails with
-    // `AccountNotInitialized` (Anchor 3012). The borrow's account meta does
-    // carry an `isRequiredAta` seed, but `buildDeduplicatedPool` only
-    // preserves the first occurrence's flag — if the same address shows up
-    // earlier without seeds, the create-ATA pass above silently skips it.
-    // Add an explicit idempotent create here so the destination debt ATA is
-    // guaranteed to exist before the rebalance ix runs.
-    // TODO: fix `buildDeduplicatedPool` to merge `isRequiredAta` flags
-    // across duplicate occurrences instead of keeping only the first, then
-    // remove this per-builder workaround. We resolve the mint's
-    // token program through the same `mints` registry Kamino's
-    // `reserveInteractionDetails` uses (kamino.ts → `liquidityMintTokenProgram`)
-    // so the ATA address we create matches the one Kamino derives.
-    const destDebtMintInfo = mints.get(destinationDebtMint);
-    if (!destDebtMintInfo) {
-      throw new Error(
-        `RebalanceTokenBuilder: destination debt mint ${destinationDebtMint} not found in mint registry`
-      );
-    }
-    const { instruction: destDebtAtaIx, postSuccessCacheInvalidations: destDebtAtaPostSuccess } =
-      await getCreateAtaIxIfNeeded(
-        this.rpc,
-        manager,
-        destinationDebtMint,
-        args.token,
-        destDebtMintInfo.tokenProgram
-      );
-
-    // The on-chain handler calls `verify_price_is_fresh` on the bank, so we
-    // only need to prepend a refresh when the cached `lastRefreshedTs` is
-    // outside the staleness window.
-    const yieldingBankAccount = await this.account.fetchYieldingBank(yieldingBank);
-    const refreshYieldingBankInstructions = yieldingBankAccount.isStale
-      ? (
-          await new RefreshYieldingBankBuilder(this.context).getTx({
-            signer: manager,
-            yieldingBank,
-          })
-        ).instructions
-      : [];
-
-    // For a full-position move (`withdrawAll`), send Kamino's `u64::MAX`
-    // "repay all" sentinel so the on-chain `RepayObligationLiquidityV2` CPI
-    // clears the obligation's actual debt exactly — interest accrual between
-    // the off-chain snapshot and bundle landing can't leave dust that trips
-    // `NetValueRemainingTooSmall` (klend error 6092). The flash-borrow is
-    // over-borrowed by 5 bps in `LeverageService.buildFlashRebalance` to
-    // cover that drift; the post-repay surplus is swept into the yielding
-    // bank.
-    //
-    // For a partial rebalance, the flash-borrow only covers `sourceRepay`
-    // (sized to bring source utilization back to target) — sending
-    // `u64::MAX` would tell Kamino to repay the full obligation debt and
-    // the ATA would underfund the SPL transfer (custom 0x1 insufficient
-    // funds). Repay exactly what we flash-borrowed so the ATA balance
-    // matches the requested CPI amount.
-    const repayAllSentinel = lpClient.getRepayAllSentinel();
-    if (withdrawAll && !repayAllSentinel) {
-      throw new Error(
-        "RebalanceTokenBuilder: source lending platform does not expose a repay-all sentinel; cannot build a withdrawAll rebalance"
-      );
-    }
-    const repayAmount =
-      withdrawAll && repayAllSentinel ? repayAllSentinel : flash.flashBorrowAmountBaseUnits;
-    const cpiPlanCreatedTs = new BN(Math.floor(Date.now() / 1000));
-    const [cpiPlan] = await this.pda.deriveCpiPlanPda(
-      args.token,
-      BigInt(cpiPlanCreatedTs.toString())
-    );
-    const createCpiPlanIx = await new CreateCpiPlanBuilder(this.context).getIx({
-      manager,
-      cpiPlan,
-      params: {
-        uniqueId: args.token,
-        createdTs: cpiPlanCreatedTs,
-        refs: planRefs,
-      },
-    });
-    const rebalanceIx = await this.getIx({
-      token: args.token,
-      params: {
-        lpIndex,
-        destinationDebtOracleType: destDebtOracleType,
-        flashFeeAmount: flash.flashFeeBaseUnits,
-        repayAmount,
-        cpiPlan,
-        remainingAccounts,
-      },
-    });
-
-    const mergedLookupTables = mergeLycLookupTables(
-      this.context.environment,
-      args.token,
-      lookupTables ?? []
-    );
-    const preambleInstructions = [
-      ...flash.preInstructions,
-      ...ataCreationIxs,
-      ...(destDebtAtaIx ? [destDebtAtaIx] : []),
-      ...refreshYieldingBankInstructions,
-    ];
-
-    // The flash group must ride atomically in one tx — Kamino's flash-borrow
-    // introspects its own tx's instructions sysvar to find the matching
-    // flash-repay (`flash_ixs.rs:NoFlashRepayFound`). We also need its
-    // position inside that tx to be predictable so the `borrowInstructionIndex`
-    // we encode here matches what Kamino sees at runtime. Marking the group
-    // as one indivisible segment AND forcing it to start a fresh bin pins
-    // the borrow at index 1 (after the heap-frame ix at index 0), regardless
-    // of how the preamble packs.
-    const flashBorrowIxIndex = 1;
-    const flashRepayIx = await LeverageService.buildFlashRepayIx(
-      flashContext,
-      flash,
-      flashBorrowIxIndex
-    );
-    const flashGroup = [
-      requestHeapFrameIx(MAX_HEAP_FRAME_BYTES),
-      flash.flashBorrowIx,
-      rebalanceIx,
-      flashRepayIx,
-    ];
-
-    // Each preamble ix is its own segment (length 1), followed by the CPI plan
-    // creation, followed by the flash cycle as one indivisible segment of
-    // length 4. Scope refresh-price instructions must remain first in their tx,
-    // so the CPI plan creation cannot precede lending-platform pre-instructions.
-    const segmentLengths = [...preambleInstructions.map(() => 1), 1, flashGroup.length];
-    const flashSegmentIndex = preambleInstructions.length + 1;
-
-    return {
-      instructions: [...preambleInstructions, createCpiPlanIx, ...flashGroup],
-      lookupTables: mergedLookupTables,
-      segmentLengths,
-      freshBinSegments: [flashSegmentIndex],
-      postSuccessCacheInvalidations: [
-        getTokenCacheInvalidation(args.token),
-        getYieldingBankCacheInvalidation(yieldingBank),
-        ...ataPostSuccess,
-        ...destDebtAtaPostSuccess,
-        ...flash.postSuccessCacheInvalidations,
-      ],
-    };
-  }
-
-  private maxPostRebalanceUtilizationBps(position: TokenLendingPositionData): number {
-    return (
-      position.config.targetUtilizationRateBps + position.config.maxDeviationAboveTargetUtilBps
-    );
-  }
-
-  private async buildFlashRebalanceOrSkip(
-    context: FlashRebalanceContext,
-    params: Parameters<typeof LeverageService.buildFlashRebalance>[1]
-  ): Promise<FlashRebalanceResult> {
-    return await LeverageService.buildFlashRebalance(context, params);
-  }
-
-  private collectFlashCpiGroups(flash: FlashRebalanceResult): {
-    groups: CpiData[][];
-    indices: {
-      sourceRepay: number;
-      destinationBorrow: number;
-      swap: number;
-    };
-  } {
-    // Each op's prereqs (reserve + obligation refreshes) stay bundled with
-    // that op. Kamino marks both the obligation AND any written reserves
-    // stale after a write op, so the next op's RefreshObligation needs all
-    // its referenced reserves re-refreshed before it can pass — we can't
-    // dedup `RefreshReserve` CPIs across bundles, even within a single slot.
-    const groups: CpiData[][] = [];
-    const indices = {} as {
-      sourceRepay: number;
-      destinationBorrow: number;
-      swap: number;
-    };
-    indices.sourceRepay = groups.length;
-    groups.push(flash.sourceRepayCpis);
-    indices.destinationBorrow = groups.length;
-    groups.push(flash.destinationBorrowCpis);
-    indices.swap = groups.length;
-    groups.push(flash.swapCpis);
-
-    return { groups, indices };
-  }
-}

package/src/client/builders/rebalanceYieldingBankBuilder.ts

@@ -1,109 +0,0 @@
-import type { Instruction } from "@solana/kit";
-import type { LongYieldCarryTransactionPlan } from "../types";
-import { LongYieldCarryBuilderBase } from "./base";
-import type { RebalanceYieldingBankIxArgs, RebalanceYieldingBankTxArgs } from "./args";
-import {
-  SYSTEM_PROGRAM_META,
-  type CpiData,
-  createCpiRefs,
-  getCreateAtaInstructions,
-  toKitInstruction,
-  toWeb3AccountMeta,
-} from "common";
-import { getYieldingBankCacheInvalidation } from "../../utils";
-import { CreateYieldingBankAllocationBuilder } from "./createYieldingBankAllocationBuilder";
-
-export class RebalanceYieldingBankBuilder extends LongYieldCarryBuilderBase<
-  RebalanceYieldingBankIxArgs,
-  RebalanceYieldingBankTxArgs
-> {
-  async getIx(args: RebalanceYieldingBankIxArgs): Promise<Instruction> {
-    const bankData = await this.account.fetchYieldingBank(args.yieldingBank);
-    return this.program.methods
-      .rebalanceYieldingBank(args.params.ixRefs)
-      .accountsPartial({
-        manager: this.resolveYieldingBankManager(bankData.data),
-        yieldingBank: args.yieldingBank,
-      })
-      .remainingAccounts(args.params.remainingAccounts.map(toWeb3AccountMeta))
-      .instruction()
-      .then(toKitInstruction);
-  }
-
-  async getTx(args: RebalanceYieldingBankTxArgs): Promise<LongYieldCarryTransactionPlan> {
-    const bankData = await this.account.fetchYieldingBank(args.yieldingBank);
-    const manager = this.resolveYieldingBankManager(bankData.data);
-    const resolvedCpiData: CpiData[] = [...(args.params.cpiData ?? [])];
-    if (args.params.swaps?.length) {
-      const swapCpiData = await Promise.all(
-        args.params.swaps.map(async (swap) => {
-          const swapClient = swap.swapClient ?? this.swap;
-          const quote = await swapClient.getQuote({
-            inputMint: swap.inputMint,
-            outputMint: swap.outputMint,
-            amount: swap.amount,
-            slippageBps: swap.slippageBps ?? 50,
-          });
-          return swapClient.getSwapCpiData(quote, args.yieldingBank, { payer: manager });
-        })
-      );
-      resolvedCpiData.push(...swapCpiData);
-    }
-
-    const { externalLiquiditySources, postSuccessCacheInvalidations: refreshCacheInvalidations } =
-      await this.externalLiquidityResolver.resolveYieldingBankRefreshExternalLiquidity(
-        this.account,
-        args.yieldingBank,
-        resolvedCpiData
-      );
-    const oracleAccounts = await this.account.getYieldingBankRefreshAccounts(
-      args.yieldingBank,
-      args.params.newAllocation?.config,
-      externalLiquiditySources
-    );
-    const {
-      accounts: remainingAccounts,
-      refs: ixRefs,
-      lookupTables,
-    } = createCpiRefs(resolvedCpiData, {
-      initialAccounts: [...oracleAccounts, SYSTEM_PROGRAM_META],
-    });
-    const preamble: Instruction[] = [];
-    if (args.params.newAllocation) {
-      preamble.push(
-        await new CreateYieldingBankAllocationBuilder(this.context).getIx({
-          yieldingBank: args.yieldingBank,
-          config: args.params.newAllocation.config,
-        })
-      );
-    }
-    const { instructions, postSuccessCacheInvalidations } = await getCreateAtaInstructions(
-      this.rpc,
-      manager,
-      remainingAccounts
-    );
-    const swapPreInstructions = resolvedCpiData.flatMap((cpi) => cpi.preInstructions ?? []);
-
-    return {
-      instructions: [
-        ...swapPreInstructions,
-        ...instructions,
-        ...preamble,
-        await this.getIx({
-          yieldingBank: args.yieldingBank,
-          params: {
-            ixRefs,
-            remainingAccounts,
-          },
-        }),
-      ],
-      lookupTables: this.getTxLookupTables(undefined, lookupTables ?? []),
-      postSuccessCacheInvalidations: [
-        getYieldingBankCacheInvalidation(args.yieldingBank),
-        ...resolvedCpiData.flatMap((cpi) => cpi.postSuccessCacheInvalidations ?? []),
-        ...refreshCacheInvalidations,
-        ...postSuccessCacheInvalidations,
-      ],
-    };
-  }
-}