@kestrelfi/lyc-sdk 1.0.1

package/src/client/builders/mintTokenBuilder.ts

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

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

@@ -0,0 +1,109 @@
+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,
+      ],
+    };
+  }
+}