@kestrelfi/lyc-sdk 1.0.1 → 1.0.3

package/dist/chunk-GOW6CARW.mjs

@@ -0,0 +1,3969 @@
+import {
+  CpiTypes,
+  DAYS_PER_YEAR,
+  DEFAULT_PUBLIC_KEY,
+  DataCache,
+  ENVIRONMENT,
+  IX_SYSVAR_META,
+  LOCALNET_URL,
+  PRICE_STALENESS_SECONDS,
+  RENT_SYSVAR_META,
+  SYSTEM_PROGRAM_META,
+  U64_MAX_BN,
+  accountExists,
+  applyFeeCeil,
+  createRpcWithFailover,
+  createSignerFromAddress,
+  currentUnixSeconds,
+  dedupeOrderedAddresses,
+  fetchWithRetry,
+  fromUiAmount,
+  fromWeb3Pk,
+  getAtaAddress,
+  getCreateAtaIxIfNeeded,
+  getRpcUrl,
+  getSlot,
+  mints,
+  numToU64Bytes,
+  oracle,
+  sum,
+  toCustomAccountMeta,
+  toUiAmount
+} from "./chunk-2T23QQCX.mjs";
+
+// ../../shared/lending-platforms/src/services/client/kamino.ts
+import { Obligation } from "@kamino-finance/klend-sdk";
+
+// ../../shared/lending-platforms/src/services/client/lpClientBase.ts
+var LendingPlatformClientBase = class {
+  constructor(rpcUrl, rpcUrls = [rpcUrl]) {
+    this.rpc = createRpcWithFailover(rpcUrls);
+  }
+  applyPostSuccessCacheInvalidations(invalidations) {
+    this.ix.applyPostSuccessCacheInvalidations(invalidations);
+  }
+};
+
+// ../../shared/lending-platforms/src/data/platform/kamino.ts
+import {
+  KaminoMarket,
+  DEFAULT_RECENT_SLOT_DURATION_MS,
+  PROGRAM_ID as PROGRAM_ID2,
+  DEFAULT_PUBLIC_KEY as DEFAULT_PUBLIC_KEY2
+} from "@kamino-finance/klend-sdk";
+import { Scope as Scope2 } from "@kamino-finance/scope-sdk";
+import { Farms } from "@kamino-finance/farms-sdk";
+
+// ../../shared/lending-platforms/src/constants/cache.ts
+var LENDING_PLATFORM_DATA_CACHE_CATEGORY_POOL = "pool";
+var LENDING_PLATFORM_DATA_CACHE_CATEGORY_RESERVE = "reserve";
+var LENDING_PLATFORM_DATA_CACHE_CATEGORY_USER_ACCOUNT = "userAccount";
+
+// ../../shared/lending-platforms/src/data/platform/lpDataBase.ts
+var LendingPlatformData = class {
+  constructor(rpcUrl, cacheTtlConfig, rpcUrls = [rpcUrl]) {
+    this.poolCatKey = LENDING_PLATFORM_DATA_CACHE_CATEGORY_POOL;
+    this.reserveCatKey = LENDING_PLATFORM_DATA_CACHE_CATEGORY_RESERVE;
+    this.userAccountCatKey = LENDING_PLATFORM_DATA_CACHE_CATEGORY_USER_ACCOUNT;
+    this.rpc = createRpcWithFailover(rpcUrls);
+    this.cache = new DataCache(cacheTtlConfig);
+  }
+  clearCache() {
+    this.cache.clearAllCache();
+  }
+  clearCacheEntry(category, id) {
+    this.cache.clearCacheEntry(category, id);
+  }
+  /** Returns the current slot, cached to reduce RPC calls */
+  async getSlot() {
+    const { data } = await this.cache.getDataOrThrow(
+      async () => await getSlot(this.rpc),
+      "slot",
+      "slot"
+    );
+    return data;
+  }
+};
+
+// ../../shared/lending-platforms/src/constants/kamino.ts
+import { address } from "@solana/kit";
+var KAMINO_FARMS_PROGRAM_ID = address("FarmsPZpWu9i7Kky8tPN37rs2TpmMrAZrC7S7vJa91Hr");
+var KAMINO_SCOPE_PROGRAM_ID = address("HFn8GnPADiny6XqUoWE8uRPPxb29ikn4yTuPa9MF2fWJ");
+var KAMINO_MAIN_MARKET = address("7u3HeHxYDLhnCoErrtycNokbQYbWGzLs6JSDqGAv5PfF");
+var SOL_RESERVE = address("d4A2prbA2whesmvHaL88BH6Ewn5N4bTSU2Ze8P6Bc4Q");
+var USDC_RESERVE = address("D6q6wuQSrifJKZYpR1M8R4YawnLDtDsMmWM1NbBmgJ59");
+var KAMINO_ACCOUNTS = {
+  [KAMINO_MAIN_MARKET]: [
+    {
+      address: SOL_RESERVE,
+      mintSymbol: "SOL"
+    },
+    {
+      address: address("37Jk2zkz23vkAYBT66HM2gaqJuNg2nYLsCreQAVt5MWK"),
+      mintSymbol: "cbBTC"
+    },
+    {
+      address: address("febGYTnFX4GbSGoFHFeJXUHgNaK53fB23uDins9Jp1E"),
+      mintSymbol: "wETH"
+    },
+    {
+      address: address("DGQZWCY17gGtBUgdaFs1VreJWsodkjFxndPsskwFKGpp"),
+      mintSymbol: "JupSOL"
+    },
+    {
+      address: address("CkgQnPbuHHwSv2mNdAKH79TKSqC6jsyttK9yh4MPH6z3"),
+      mintSymbol: "dfdvSOL"
+    },
+    {
+      address: USDC_RESERVE,
+      mintSymbol: "USDC"
+    },
+    {
+      address: address("2gc9Dm1eB6UgVYFBUN9bWks6Kes9PbWSaPaa9DqyvEiN"),
+      mintSymbol: "PYUSD"
+    },
+    {
+      address: address("ApQkX32ULJUzszZDe986aobLDLMNDoGQK8tRm6oD6SsA"),
+      mintSymbol: "CASH"
+    },
+    {
+      address: address("ESCkPWKHmgNE7Msf77n9yzqJd5kQVWWGy3o5Mgxhvavp"),
+      mintSymbol: "USDG"
+    },
+    {
+      address: address("BHUi32TrEsfN2U821G4FprKrR4hTeK4LCWtA3BFetuqA"),
+      mintSymbol: "USDS"
+    },
+    {
+      address: address("H3t6qZ1JkguCNTi9uzVKqQ7dvt2cum4XiXWom6Gn5e5S"),
+      mintSymbol: "USDT"
+    }
+  ],
+  /// xStocks Market
+  [address("5wJeMrUYECGq41fxRESKALVcHnNX26TAWy4W98yULsua")]: [
+    {
+      address: address("2jerdAXR8r2B6z3P7P6VgSiePQX7wqcpbEqdDbm8mgeB"),
+      mintSymbol: "QQQx"
+    },
+    {
+      address: address("UvXjBuC7YZYaGB9Rn1PpBD1GySmjzunXgE8Zev9ua8d"),
+      mintSymbol: "SPYx"
+    },
+    {
+      address: address("97zoywd8mPZsGTg8q1wdD2Wgkdrs2tqusp1Qqcxbyj7E"),
+      mintSymbol: "USDC"
+    }
+  ]
+  // Bitcoin Market
+  // [address("GMqmFygF5iSm5nkckYU6tieggFcR42SyjkkhK5rswFRs")]: [
+  //   {
+  //     address: address("2Xd86oYAuhiKtQMVJBuWvJYxrSippreb46PmehGszpPQ"),
+  //     mintSymbol: "wBTC"
+  //   },
+  //   {
+  //     address: address("9FRZvAsjDJ6WM8BJ2S45h9PoDCLAq8DNY9zZDX7MyGzT"),
+  //     mintSymbol: "USDC"
+  //   }
+  // ]
+};
+
+// ../../shared/lending-platforms/src/constants/lendingPosition.ts
+var MAX_LENDING_POSITION_UPPER_UTIL_BPS = 10500;
+
+// ../../shared/lending-platforms/src/utils/accounts.ts
+function getEligiblePools(mintSymbol) {
+  const needle = mintSymbol.toUpperCase();
+  const pools = [];
+  for (const pool of Object.keys(KAMINO_ACCOUNTS)) {
+    const reserves = KAMINO_ACCOUNTS[pool];
+    if (reserves.some((r) => r.mintSymbol.toUpperCase() === needle)) {
+      pools.push(pool);
+    }
+  }
+  return pools;
+}
+
+// ../../shared/lending-platforms/src/utils/cache.ts
+function getLendingUserAccountCacheInvalidation(userAccount) {
+  return {
+    client: "kamino",
+    category: LENDING_PLATFORM_DATA_CACHE_CATEGORY_USER_ACCOUNT,
+    id: userAccount
+  };
+}
+
+// ../../shared/lending-platforms/src/utils/kamino.ts
+import {
+  calculateCurrentRewardPerToken,
+  SECONDS_IN_A_DAY
+} from "@kamino-finance/farms-sdk";
+import { BN } from "@anchor-lang/core";
+import { LendingMarket, PROGRAM_ID } from "@kamino-finance/klend-sdk";
+import Decimal from "decimal.js";
+async function fetchExtraFarms() {
+  const cdnRes = await fetchWithRetry("https://cdn.kamino.finance/resources.json");
+  const allResources = await cdnRes.json();
+  return allResources["mainnet-beta"]["extraFarms"];
+}
+function calculateRewardAPY(reserveMint, rewardInfo, totalStakedRaw, stakedTokenDecimals, exchangeRate, rewardMintPrice, requiresPairReserve) {
+  let totalStaked = new Decimal(toUiAmount(BigInt(totalStakedRaw), stakedTokenDecimals));
+  if (!requiresPairReserve) {
+    totalStaked = totalStaked.div(exchangeRate);
+  }
+  if (totalStaked.isZero()) return 0;
+  const rewardPerTokenPerSecond = calculateCurrentRewardPerToken(
+    rewardInfo,
+    new Decimal(currentUnixSeconds())
+  );
+  if (!rewardPerTokenPerSecond) return 0;
+  const divisor = new Decimal(10).pow(new Decimal(rewardInfo.rewardsPerSecondDecimals.toString())).mul(new Decimal(10).pow(new Decimal(rewardInfo.token.decimals.toString())));
+  const adjustedRewardPerToken = new Decimal(rewardPerTokenPerSecond).div(divisor);
+  let dailyRewards = adjustedRewardPerToken.mul(SECONDS_IN_A_DAY);
+  if (mints.get(rewardInfo.token.mint)?.assetType !== "Stablecoin" && rewardInfo.token.mint !== reserveMint) {
+    dailyRewards = dailyRewards.mul(new Decimal(rewardMintPrice));
+  }
+  const dailyRate = dailyRewards.div(totalStaked);
+  const apy = Decimal.pow(dailyRate.plus(1), DAYS_PER_YEAR).minus(1);
+  return apy.toNumber();
+}
+function liquidityToCollateral(reserveData, liquidityBaseUnits) {
+  const exchangeRate = reserveData.rawData.getEstimatedCollateralExchangeRate(reserveData.slot, 0).toNumber();
+  return Math.floor(liquidityBaseUnits * exchangeRate);
+}
+
+// ../../shared/lending-platforms/src/utils/math.ts
+function clampUnitInterval(x) {
+  if (x <= 0) return 0;
+  if (x >= 1) return 1;
+  return x;
+}
+function assertLtv(ltv) {
+  if (!(ltv > 0) || ltv > 1) {
+    throw new RangeError("ltv must be in (0, 1] (e.g. 0.8 for 80% max LTV)");
+  }
+}
+function assertLiquidationThreshold(t) {
+  if (!(t > 0) || t > 1) {
+    throw new RangeError("liquidationThreshold must be in (0, 1] (e.g. 0.85)");
+  }
+}
+function maxLtvUtilBeforeCollUsdMultiplierInternal(params) {
+  const {
+    collateralUsdMultiplier: mult,
+    ltv,
+    liquidationThreshold,
+    targetMaxBorrowUtilizationAfter = 1
+  } = params;
+  assertLtv(ltv);
+  if (!(mult > 0)) {
+    throw new RangeError("collateralUsdMultiplier must be positive");
+  }
+  if (liquidationThreshold !== void 0) {
+    assertLiquidationThreshold(liquidationThreshold);
+    return clampUnitInterval(mult * liquidationThreshold / ltv);
+  }
+  if (!(targetMaxBorrowUtilizationAfter > 0) || targetMaxBorrowUtilizationAfter > 1) {
+    throw new RangeError(
+      "targetMaxBorrowUtilizationAfter must be in (0, 1] (1 = 100% of borrow limit)"
+    );
+  }
+  return clampUnitInterval(mult * targetMaxBorrowUtilizationAfter);
+}
+function maxLtvUtilBeforeCollDrawdown(params) {
+  if (!(params.drawdownPercent >= 0)) {
+    throw new RangeError("drawdownPercent must be non-negative (e.g. 30 for a 30% drop)");
+  }
+  const collateralUsdMultiplier = 1 - params.drawdownPercent / 100;
+  if (!(collateralUsdMultiplier > 0)) {
+    throw new RangeError(
+      "drawdownPercent must be less than 100 so collateral USD remains positive"
+    );
+  }
+  return maxLtvUtilBeforeCollUsdMultiplierInternal({
+    collateralUsdMultiplier,
+    ltv: params.ltv,
+    targetMaxBorrowUtilizationAfter: params.targetMaxBorrowUtilizationAfter,
+    liquidationThreshold: params.liquidationThreshold
+  });
+}
+function ltvUtilAfterCollateralPricePctChg(currentLtvUtilization, collateralPricePctChg) {
+  if (!(currentLtvUtilization >= 0) || currentLtvUtilization > 1) {
+    throw new RangeError("currentLtvUtilization must be in [0, 1]");
+  }
+  const mult = 1 + collateralPricePctChg / 100;
+  if (!(mult > 0)) {
+    throw new RangeError(
+      "collateralPricePctChg must be greater than -100 so collateral USD stays positive"
+    );
+  }
+  return currentLtvUtilization / mult;
+}
+function ltvUtilDeltaBelowTargForRallyPct(targetLtvUtilization, rallyPercentPositive) {
+  if (!(targetLtvUtilization > 0) || targetLtvUtilization > 1) {
+    throw new RangeError("targetLtvUtilization must be in (0, 1]");
+  }
+  if (!Number.isFinite(rallyPercentPositive) || rallyPercentPositive <= 0) {
+    throw new RangeError("rallyPercentPositive must be finite and positive");
+  }
+  const after = ltvUtilAfterCollateralPricePctChg(targetLtvUtilization, rallyPercentPositive);
+  return targetLtvUtilization - after;
+}
+
+// ../../shared/lending-platforms/src/utils/scope.ts
+import { Scope } from "@kamino-finance/scope-sdk";
+var ORACLE_TYPE_MOST_RECENT_OF = 28;
+var ORACLE_TYPE_CAPPED_FLOORED = 33;
+var MOST_RECENT_OF_UNUSED = 512;
+function collectTokenDependencies(token, mappings, result, depth = 0) {
+  if (result.has(token) || depth > 5) return;
+  const isValidDep = (dep2) => dep2 !== void 0 && dep2 !== token && dep2 < mappings.priceInfoAccounts.length && mappings.priceInfoAccounts[dep2] !== DEFAULT_PUBLIC_KEY;
+  const recurse = (dep2) => collectTokenDependencies(dep2, mappings, result, depth + 1);
+  if (mappings.priceTypes[token] === ORACLE_TYPE_MOST_RECENT_OF) {
+    const raw = mappings.generic[token];
+    if (raw?.length >= 8) {
+      for (let i = 0; i < 4; i++) {
+        const src = raw[i * 2] | raw[i * 2 + 1] << 8;
+        if (src !== MOST_RECENT_OF_UNUSED && isValidDep(src)) {
+          recurse(src);
+        }
+      }
+    }
+  } else if (mappings.priceTypes[token] === ORACLE_TYPE_CAPPED_FLOORED) {
+    const raw = mappings.generic[token];
+    if (raw?.length >= 7) {
+      const sourceEntry = raw[0] | raw[1] << 8;
+      if (isValidDep(sourceEntry)) recurse(sourceEntry);
+      if (raw[2] === 1) {
+        const capEntry = raw[3] | raw[4] << 8;
+        if (isValidDep(capEntry)) recurse(capEntry);
+      }
+      const floorOffset = raw[2] === 1 ? 5 : 3;
+      if (raw[floorOffset] === 1) {
+        const floorEntry = raw[floorOffset + 1] | raw[floorOffset + 2] << 8;
+        if (isValidDep(floorEntry)) recurse(floorEntry);
+      }
+    }
+  }
+  const dep = mappings.refPrice[token];
+  if (isValidDep(dep)) {
+    recurse(dep);
+  }
+  result.add(token);
+}
+
+// ../../shared/lending-platforms/src/data/platform/kamino.ts
+import Decimal2 from "decimal.js";
+var KaminoData = class extends LendingPlatformData {
+  constructor(rpcUrl, cacheConfig, rpcUrls = [rpcUrl]) {
+    const ttlConfig = {
+      defaultTtlMs: 9e4,
+      categoryTtlMs: {
+        ...cacheConfig?.categoryTtlMs,
+        markets: 6e4 * 5,
+        farms: 6e4 * 5,
+        extraFarms: Number.MAX_SAFE_INTEGER,
+        scopeOraclePrices: 3e4,
+        scopeConfig: 6e4 * 5
+      }
+    };
+    super(rpcUrl, ttlConfig, rpcUrls);
+    this.farms = new Farms(this.rpc, KAMINO_FARMS_PROGRAM_ID);
+    this.scope = new Scope2("mainnet-beta", this.rpc);
+  }
+  platform() {
+    return 0 /* Kamino */;
+  }
+  /**
+   * Warms the market cache for the requested pools. Single-pool calls reuse the
+   * normal lazy fetch path; multi-pool calls use Kamino's batched loader.
+   */
+  async load(pools) {
+    if (pools.length === 0) return;
+    if (pools.length === 1) {
+      await this.fetchMarket(pools[0]);
+      return;
+    }
+    const { data: markets, fromCache } = await this.cache.getDataBatch(
+      async () => {
+        const marketsData = await KaminoMarket.loadMultiple(
+          this.rpc,
+          pools,
+          DEFAULT_RECENT_SLOT_DURATION_MS,
+          PROGRAM_ID2,
+          true
+        );
+        return pools.map((pool) => marketsData.get(pool) ?? null);
+      },
+      this.poolCatKey,
+      pools
+    );
+    if (!fromCache) {
+      await Promise.all(markets.map(async (market) => await market.loadReserves()));
+    }
+  }
+  /** Fetches a market by address, loading from cache if available */
+  async fetchMarket(market) {
+    const { data, fromCache } = await this.cache.getDataOrThrow(
+      async () => await KaminoMarket.load(
+        this.rpc,
+        market,
+        DEFAULT_RECENT_SLOT_DURATION_MS,
+        PROGRAM_ID2,
+        true
+      ),
+      this.poolCatKey,
+      market
+    );
+    if (!fromCache) {
+      await data.loadReserves();
+    }
+    return data;
+  }
+  /** Fetches all oracle prices for assets in the specified market */
+  async fetchPrices(pool) {
+    const market = await this.fetchMarket(pool);
+    const { data } = await this.cache.getDataOrThrow(
+      async () => await market.getAllPrices(),
+      "prices",
+      "queryAll"
+    );
+    return data;
+  }
+  /** Fetches an obligation (user position) by address */
+  async fetchObligation(market, obligation) {
+    const { data } = await this.cache.getData(
+      async () => await market.getObligationByAddress(obligation),
+      this.userAccountCatKey,
+      obligation,
+      { cacheNull: false }
+    );
+    return data;
+  }
+  /** Batch fetches farm states by their addresses */
+  async fetchFarms(farms) {
+    const { data } = await this.cache.getDataBatch(
+      async () => (await this.farms.getAllFarmStatesByPubkeys(farms)).map((x) => x.farmState),
+      "userFarms",
+      farms
+    );
+    return data;
+  }
+  async fetchExtraFarms() {
+    const { data } = await this.cache.getDataOrThrow(
+      async () => await fetchExtraFarms(),
+      "extraFarms",
+      "mainnet-beta"
+    );
+    return data;
+  }
+  /**
+   * Collects all farm incentives for a reserve, including both standard
+   * collateral/debt farms and extra paired farms from Kamino CDN config.
+   */
+  async fetchFarmsForReserve(pool, reserve) {
+    const market = await this.fetchMarket(pool);
+    const reserveData = market.getReserveByAddress(reserve);
+    if (!reserveData) {
+      throw new Error(`Unable to find reserve ${reserve}`);
+    }
+    const farms = [];
+    const farmCollateral = reserveData.state.farmCollateral;
+    const farmDebt = reserveData.state.farmDebt;
+    if (farmCollateral && farmCollateral !== DEFAULT_PUBLIC_KEY2) {
+      farms.push({ address: farmCollateral, isDebtFarm: false });
+    }
+    if (farmDebt && farmDebt !== DEFAULT_PUBLIC_KEY2) {
+      farms.push({ address: farmDebt, isDebtFarm: true });
+    }
+    const extraFarmsData = (await this.fetchExtraFarms()).filter(
+      (x) => x.collReserve === reserve || x.debtReserve === reserve
+    );
+    const extraFarmEntries = extraFarmsData.map((x) => ({
+      address: x.farm,
+      isDebtFarm: x.debtReserve === reserve
+    }));
+    const allFarmEntries = [...farms, ...extraFarmEntries];
+    const allFarmAddresses = allFarmEntries.map((f) => f.address);
+    if (!allFarmAddresses.length) {
+      return [];
+    }
+    const farmStates = await this.fetchFarms(allFarmAddresses);
+    const result = [];
+    farmStates.forEach((farmState, i) => {
+      const farmEntry = allFarmEntries[i];
+      const isExtraFarm = i >= farms.length;
+      const extraFarmIndex = i - farms.length;
+      farmState.rewardInfos.forEach((rewardInfo, rewardIndex) => {
+        if (rewardInfo.rewardsVault === DEFAULT_PUBLIC_KEY2) {
+          return;
+        }
+        result.push({
+          data: {
+            key: farmEntry.address,
+            farmState
+          },
+          rewardIndex,
+          requiresPairReserve: isExtraFarm ? extraFarmsData[extraFarmIndex].debtReserve : void 0,
+          isDebtFarm: farmEntry.isDebtFarm
+        });
+      });
+    });
+    return result;
+  }
+  async fetchUserActiveIncentives(user, specificFarm) {
+    let { data } = await this.cache.getDataOrThrow(
+      async () => {
+        return Array.from(
+          (await this.farms.getAllFarmsForUserMultiState(user, new Decimal2(currentUnixSeconds()))).values()
+        ).flat();
+      },
+      "userFarms",
+      user
+    );
+    if (specificFarm) {
+      data = data.filter((x) => x.farm === specificFarm);
+    }
+    return data;
+  }
+  async maybeFetchUserPositionInPool(pool, userPosition) {
+    const market = await this.fetchMarket(pool);
+    const obligation = await this.fetchObligation(market, userPosition);
+    return obligation ? KaminoUserPositionData.loadData(obligation) : null;
+  }
+  async fetchUserPositionsInPool(pool, userPositions) {
+    const market = await this.fetchMarket(pool);
+    const { data } = await this.cache.getDataBatch(
+      async () => await market.getMultipleObligationsByAddress(userPositions),
+      this.userAccountCatKey,
+      userPositions
+    );
+    return data.map((obligation) => KaminoUserPositionData.loadData(obligation));
+  }
+  async fetchAllUserPositionsForUserInPool(pool, user) {
+    const market = await this.fetchMarket(pool);
+    const { data } = await this.cache.getDataOrThrow(
+      async () => await market.getAllUserObligations(user, "confirmed"),
+      "obligationsBatch",
+      user
+    );
+    return data.map((obligation) => KaminoUserPositionData.loadData(obligation));
+  }
+  async fetchReserve(pool, reserve) {
+    const market = await this.fetchMarket(pool);
+    const reserveData = market.getReserveByAddress(reserve);
+    if (!reserveData) {
+      throw new Error(`Unable to find reserve ${reserve}`);
+    }
+    return this.mapReserve(market, reserveData);
+  }
+  async fetchReserveByMint(pool, mint) {
+    const market = await this.fetchMarket(pool);
+    const reserveData = market.getReserveByMint(mint);
+    if (!reserveData) {
+      throw new Error(`Unable to find reserve by mint ${mint}`);
+    }
+    return this.mapReserve(market, reserveData);
+  }
+  async mapReserve(market, reserve) {
+    return KaminoReserveData.loadData(
+      market,
+      reserve,
+      await this.fetchFarmsForReserve(market.address, reserve.address),
+      await this.fetchPrices(market.address),
+      await this.getSlot()
+    );
+  }
+  /**
+   * Fetches and caches the Scope OraclePrices account for a given price feed.
+   * @returns The deserialized OraclePrices, or null if the account doesn't exist
+   */
+  async fetchScopeOraclePrices(priceFeed) {
+    const { data } = await this.cache.getData(
+      async () => await this.scope.getSingleOraclePrices({ prices: priceFeed }),
+      "scopeOraclePrices",
+      priceFeed
+    );
+    return data;
+  }
+  /**
+   * Resolves and caches the Scope Configuration account address for a given OraclePrices account.
+   * The first call per price feed does a getProgramAccounts lookup; subsequent calls use cache.
+   */
+  async fetchScopeConfigAddress(priceFeed) {
+    const { data } = await this.cache.getDataOrThrow(
+      async () => {
+        const [configAddr] = await this.scope.getSingleFeedConfiguration({
+          prices: priceFeed
+        });
+        return configAddr;
+      },
+      "scopeConfig",
+      priceFeed
+    );
+    return data;
+  }
+};
+
+// ../../shared/lending-platforms/src/data/reserve/kamino.ts
+import {
+  isNotNullPubkey
+} from "@kamino-finance/klend-sdk";
+import Decimal4 from "decimal.js";
+
+// ../../shared/lending-platforms/src/data/incentive/incentiveBase.ts
+var TokenIncentiveBase = class {
+  constructor(address4, config) {
+    this.address = address4;
+    this.config = config;
+  }
+};
+
+// ../../shared/lending-platforms/src/data/incentive/kamino.ts
+import Decimal3 from "decimal.js";
+import { BN as BN2 } from "@anchor-lang/core";
+import {
+  calculateCurrentRewardPerToken as calculateCurrentRewardPerToken2
+} from "@kamino-finance/farms-sdk";
+var KaminoIncentiveData = class _KaminoIncentiveData extends TokenIncentiveBase {
+  /**
+   * Creates a KaminoIncentiveData instance from farm and reserve data.
+   * Determines the incentive type and calculates current exchange rates.
+   */
+  static loadData(args, reserve, prices, slot) {
+    const {
+      data: { key, farmState },
+      rewardIndex,
+      requiresPairReserve,
+      isDebtFarm
+    } = args;
+    const rewardInfo = farmState.rewardInfos[rewardIndex];
+    const data = new _KaminoIncentiveData(key, {
+      rewardMint: rewardInfo.token.mint,
+      incentiveType: isDebtFarm ? "Borrowing" /* BorrowingOnly */ : requiresPairReserve ? "Pair" /* Pair */ : "Lending" /* LendingOnly */,
+      requiresPairReserve
+    });
+    data.rawReserve = reserve;
+    data.rawFarm = farmState;
+    data.rewardInfo = farmState.rewardInfos[rewardIndex];
+    data.isDebtFarm = isDebtFarm;
+    const collateralExchangeRate = reserve.getEstimatedCollateralExchangeRate(slot, 0).toNumber();
+    const debtExchangeRate = reserve.getEstimatedCumulativeBorrowRate(slot, 0).toNumber();
+    data.exchangeRate = isDebtFarm ? debtExchangeRate : collateralExchangeRate;
+    const rewardMint = rewardInfo.token.mint;
+    const scope = prices.scope.spot[rewardMint];
+    const pyth = prices.pyth.spot[rewardMint];
+    const swb = prices.switchboard.spot[rewardMint];
+    data.rewardMintPrice = scope ? scope.price.toNumber() : pyth ? pyth.price.toNumber() : swb ? swb.price.toNumber() : 0;
+    return data;
+  }
+  /**
+   * Checks if the incentive is currently active.
+   * An incentive is active if rewards are available, the schedule has started,
+   * and there is a non-zero emission rate.
+   */
+  active() {
+    const rewardsAvailable = this.rewardInfo.rewardsAvailable.gtn(0);
+    const hasStarted = this.rewardInfo.rewardScheduleCurve.points[0].tsStart.toNumber() < currentUnixSeconds();
+    const rewardPerTokenPerSecond = calculateCurrentRewardPerToken2(
+      this.rewardInfo,
+      new Decimal3(currentUnixSeconds())
+    );
+    return rewardsAvailable && hasStarted && rewardPerTokenPerSecond > 0;
+  }
+  /** Calculates the current APY based on total staked amount and reward emission rate */
+  apy() {
+    const { totalStaked, stakedTokenDecimals } = this.getStakedTokenData();
+    return calculateRewardAPY(
+      this.rawReserve.getLiquidityMint(),
+      this.rewardInfo,
+      totalStaked.toString(),
+      stakedTokenDecimals,
+      this.exchangeRate,
+      this.rewardMintPrice,
+      Boolean(this.config.requiresPairReserve)
+    );
+  }
+  /**
+   * Simulates the APY after a hypothetical position change.
+   * Useful for calculating expected rewards before executing a transaction.
+   */
+  simulateNewAPY(args) {
+    const changeInUnderlying = this.isDebtFarm ? args.debtChange ?? 0 : args.collateralChange ?? 0;
+    if (changeInUnderlying === 0) {
+      return this.apy();
+    }
+    const { totalStaked, stakedTokenDecimals } = this.getStakedTokenData();
+    const changeInShares = changeInUnderlying / this.exchangeRate;
+    const changeInSharesRaw = new BN2(
+      Math.round(changeInShares * Math.pow(10, stakedTokenDecimals))
+    );
+    const newTotalStakedRaw = new BN2(totalStaked.toString()).add(changeInSharesRaw);
+    return calculateRewardAPY(
+      this.rawReserve.getLiquidityMint(),
+      this.rewardInfo,
+      newTotalStakedRaw.toString(),
+      stakedTokenDecimals,
+      this.exchangeRate,
+      this.rewardMintPrice,
+      Boolean(this.config.requiresPairReserve)
+    );
+  }
+  /**
+   * Returns staking metrics for APY calculation.
+   * Falls back to reserve decimals if farm token decimals are not set.
+   */
+  getStakedTokenData() {
+    return {
+      totalStaked: this.rawFarm.totalStakedAmount,
+      stakedTokenDecimals: this.rawFarm.token.decimals.toNumber() || (this.config.requiresPairReserve ? 6 : this.rawReserve.getMintDecimals())
+    };
+  }
+};
+
+// ../../shared/lending-platforms/src/data/reserve/reserveBase.ts
+var ReserveBase = class {
+  constructor(address4, mint, config, deposits, borrows, state, incentives) {
+    this.address = address4;
+    this.mint = mint;
+    this.config = config;
+    this.deposits = deposits;
+    this.borrows = borrows;
+    this.state = state;
+    this.incentives = incentives;
+    this.createdAt = Date.now();
+  }
+  normalizeLtvPct(ltvPct) {
+    return ltvPct <= 1 ? ltvPct : ltvPct / 100;
+  }
+  /** Returns the cached price, or undefined if stale */
+  get mintPrice() {
+    if (this.mint.price === void 0) {
+      return void 0;
+    }
+    const ageMs = Date.now() - this.createdAt;
+    if (ageMs > PRICE_STALENESS_SECONDS * 1e3) {
+      return void 0;
+    }
+    return this.mint.price;
+  }
+  /** Returns the cached EMA price, or undefined if stale/missing */
+  get mintEmaPrice() {
+    if (this.mint.emaPrice === void 0) {
+      return void 0;
+    }
+    const ageMs = Date.now() - this.createdAt;
+    if (ageMs > PRICE_STALENESS_SECONDS * 1e3) {
+      return void 0;
+    }
+    return this.mint.emaPrice;
+  }
+  /**
+   * Returns the reserve LTV in decimal form, where `0.5 = 50%`.
+   */
+  get ltvPct() {
+    return this.normalizeLtvPct(this.config.ltvPct);
+  }
+  /**
+   * Returns e-mode configs with `ltvPct` normalized to decimal form, where
+   * `0.5 = 50%`.
+   */
+  get emodes() {
+    return this.config.emodes?.map((emode) => ({
+      ...emode,
+      ltvPct: this.normalizeLtvPct(emode.ltvPct)
+    }));
+  }
+  utilizationRatePct() {
+    return this.state.utilizationRatePct;
+  }
+  /** Returns borrowable liquidity, accounting for both available balance and borrow limits, in UI amount (e.g. 1.234) */
+  liquidityAvailable() {
+    return Math.min(this.state.availableLiquidity, this.borrows.limit - this.borrows.totalAmount);
+  }
+  /**
+   * Returns the total supply APY including base rate and eligible supply-side
+   * incentives (types `LendingOnly` and `Pair`). Borrow-side incentives are
+   * excluded here — they reward borrowers, not lenders.
+   * @param usingDebtReserve - When specified, includes paired incentives requiring this debt reserve
+   */
+  supplyAPY(usingDebtReserve) {
+    return this.deposits.apy + this.sumEligibleIncentivesAPY("supply", usingDebtReserve);
+  }
+  /**
+   * Returns the effective borrow APY (base rate minus eligible borrow-side
+   * incentive rebates, i.e. `BorrowingOnly`). Lender-side incentives are
+   * excluded — they are paid to lenders and do not offset borrower cost.
+   * @param usingSupplyReserve - When specified, includes paired incentives requiring this collateral
+   */
+  borrowAPY(usingSupplyReserve) {
+    return this.borrows.apy - this.sumEligibleIncentivesAPY("borrow", usingSupplyReserve);
+  }
+  /** Sums APY from incentives eligible for the given side and paired reserve */
+  sumEligibleIncentivesAPY(side, usingPairReserve) {
+    return sum(this.getEligibleIncentives(side, usingPairReserve).map((x) => x.apy()));
+  }
+  /** Sums the new simulated APY from incentives eligible for the given side and paired reserve */
+  simulateNewEligbleIncentivesAPY(args, side, usingPairReserve) {
+    return sum(
+      this.getEligibleIncentives(side, usingPairReserve).map((x) => x.simulateNewAPY(args))
+    );
+  }
+  /**
+   * Filters incentives eligible for the given side (supply vs borrow) and
+   * paired reserve.
+   *
+   * Side filter:
+   * - `supply`: `LendingOnly` and `Pair` (collateral-farm incentives,
+   *   optionally gated on a specific debt reserve).
+   * - `borrow`: `BorrowingOnly` (debt-farm incentives, optionally gated on a
+   *   specific collateral reserve via `requiresPairReserve`).
+   *
+   * Pair filter: incentives with `requiresPairReserve` only apply when that
+   * reserve matches the caller's pair.
+   */
+  getEligibleIncentives(side, usingPairReserve) {
+    return (this.incentives ?? []).filter((x) => {
+      const sideMatches = side === "borrow" ? x.config.incentiveType === "Borrowing" /* BorrowingOnly */ : x.config.incentiveType !== "Borrowing" /* BorrowingOnly */;
+      if (!sideMatches) return false;
+      return !x.config.requiresPairReserve || x.config.requiresPairReserve === usingPairReserve;
+    });
+  }
+  canDeposit(amount) {
+    return amount <= this.deposits.limit;
+  }
+  canBorrow(amount) {
+    return amount <= this.borrows.limit;
+  }
+};
+
+// ../../shared/lending-platforms/src/data/reserve/kamino.ts
+var KaminoReserveData = class _KaminoReserveData extends ReserveBase {
+  /**
+   * Creates a KaminoReserveData instance from raw SDK types.
+   * Extracts and normalizes configuration, rates, limits, and incentives.
+   */
+  static loadData(market, reserve, reserveFarms, prices, slot) {
+    const stats = reserve.stats;
+    const state = reserve.state;
+    const config = state.config;
+    const mintDecimals = reserve.getMintDecimals();
+    const price = reserve.getOracleMarketPrice().toNumber();
+    const allElevationGroups = config.elevationGroups.map((id) => market.getElevationGroup(id)).filter(
+      (group) => group !== void 0 && group.debtReserve !== reserve.address && group.maxReservesAsCollateral === 1
+    );
+    const data = new _KaminoReserveData(
+      reserve.address,
+      {
+        mint: reserve.getLiquidityMint(),
+        mintDecimals,
+        mintTokenProgram: reserve.getLiquidityTokenProgram(),
+        price
+      },
+      {
+        ltvPct: stats.loanToValue,
+        liquidationThresholdPct: stats.liquidationThreshold,
+        borrowFeePct: reserve.getBorrowFee().toNumber(),
+        flashLoanFeePct: reserve.getFlashLoanFee().toNumber(),
+        emodes: allElevationGroups.map((x) => ({
+          id: x.id,
+          debtReserve: x.debtReserve,
+          ltvPct: x.ltvPct,
+          liquidationThresholdPct: x.liquidationThresholdPct
+        }))
+      },
+      {
+        totalAmount: reserve.getDepositTvl().toNumber() / price,
+        limit: toUiAmount(config.depositLimit, mintDecimals),
+        apy: reserve.totalSupplyAPY(slot)
+      },
+      {
+        totalAmount: reserve.getBorrowTvl().toNumber() / price,
+        limit: toUiAmount(config.borrowLimit, mintDecimals),
+        apy: reserve.totalBorrowAPY(slot)
+      },
+      {
+        utilizationRatePct: reserve.calculateUtilizationRatio(),
+        availableLiquidity: toUiAmount(
+          BigInt(reserve.getLiquidityAvailableAmount().toFixed(0)),
+          mintDecimals
+        )
+      },
+      reserveFarms.map((x) => KaminoIncentiveData.loadData(x, reserve, prices, slot)).filter((x) => x.active() || [state.farmCollateral, state.farmDebt].includes(x.address))
+    );
+    data.rawData = reserve;
+    data.slot = slot;
+    return data;
+  }
+  /** Checks if TWAP price validation is enabled for this reserve */
+  isTwapEnabled() {
+    return this.rawData.state.config.tokenInfo.maxTwapDivergenceBps.toNumber() > 0;
+  }
+  /**
+   * Determines if the reserve's on-chain price data is stale and needs refreshing.
+   */
+  requiresRefresh() {
+    return true;
+  }
+  /**
+   * Returns all configured oracle account addresses for this reserve.
+   * Only includes accounts that are actually enabled.
+   */
+  getOracleAccounts() {
+    const tokenInfo = this.rawData.state.config.tokenInfo;
+    const pythAccount = tokenInfo.pythConfiguration.price;
+    const switchboardPrice = tokenInfo.switchboardConfiguration.priceAggregator;
+    const switchboardTwap = tokenInfo.switchboardConfiguration.twapAggregator;
+    const scope = tokenInfo.scopeConfiguration.priceFeed;
+    const pythEnabled = isNotNullPubkey(pythAccount);
+    const switchboardEnabled = isNotNullPubkey(switchboardPrice);
+    const switchboardTwapEnabled = switchboardEnabled && this.isTwapEnabled() && isNotNullPubkey(switchboardTwap);
+    const scopeEnabled = isNotNullPubkey(scope);
+    return {
+      pythPrice: pythEnabled ? pythAccount : void 0,
+      switchboardPrice: switchboardEnabled ? switchboardPrice : void 0,
+      switchboardTwap: switchboardTwapEnabled ? switchboardTwap : void 0,
+      scope: scopeEnabled ? scope : void 0
+    };
+  }
+  /**
+   * Simulates the supply APY after a position balance change.
+   * Uses the SDK's calcSimulatedSupplyAPR which accounts for utilization changes.
+   */
+  simulateNewSupplyAPY(args, usingDebtReserve) {
+    const collateralChange = args.collateralChange ?? 0;
+    if (!collateralChange) {
+      return this.supplyAPY(usingDebtReserve);
+    }
+    const simulatedAPR = this.rawData.calcSimulatedSupplyAPR(
+      new Decimal4(fromUiAmount(collateralChange, this.mint.mintDecimals).toNumber()),
+      collateralChange > 0 ? "deposit" : "withdraw",
+      this.slot,
+      0
+    );
+    return simulatedAPR + this.simulateNewEligbleIncentivesAPY(args, "supply", usingDebtReserve);
+  }
+  /**
+   * Simulates the borrow APY after a position balance change.
+   * Uses the SDK's calcSimulatedBorrowAPR which accounts for utilization changes.
+   */
+  simulateNewBorrowAPY(args, usingSupplyReserve) {
+    const debtChange = args.debtChange ?? 0;
+    if (!debtChange) {
+      return this.borrowAPY(usingSupplyReserve);
+    }
+    const simulatedAPR = this.rawData.calcSimulatedBorrowAPR(
+      new Decimal4(fromUiAmount(debtChange, this.mint.mintDecimals).toNumber()),
+      debtChange > 0 ? "borrow" : "repay",
+      this.slot,
+      0
+    );
+    return simulatedAPR - this.simulateNewEligbleIncentivesAPY(args, "borrow", usingSupplyReserve);
+  }
+  canWithdraw(amount) {
+    const capCapacity = this.rawData.getDepositWithdrawalCapCapacity();
+    const capCurrent = this.rawData.getDepositWithdrawalCapCurrent(this.slot);
+    return this.hasCapacity(amount, capCapacity, capCurrent);
+  }
+  canBorrow(amount) {
+    const capCapacity = this.rawData.getDebtWithdrawalCapCapacity();
+    const capCurrent = this.rawData.getDebtWithdrawalCapCurrent(this.slot);
+    return amount <= this.borrows.limit && this.hasCapacity(amount, capCapacity, capCurrent);
+  }
+  hasCapacity(amount, capCapacity, capCurrent) {
+    if (!capCapacity.isZero()) {
+      const remainingCap = toUiAmount(
+        BigInt(capCapacity.minus(capCurrent).toFixed(0)),
+        this.mint.mintDecimals
+      );
+      if (amount > remainingCap) {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+
+// ../../shared/lending-platforms/src/data/userPosition/kamino.ts
+import { BN as BN4 } from "@anchor-lang/core";
+
+// ../../shared/lending-platforms/src/data/userPosition/userPositionBase.ts
+import { BN as BN3 } from "@anchor-lang/core";
+var UserPositionBase = class {
+  constructor(address4, utilizationRate, deposits, borrows, ltv, liquidationThreshold, borrowLimitUsd) {
+    this.address = address4;
+    this.utilizationRate = utilizationRate;
+    this.deposits = deposits;
+    this.borrows = borrows;
+    this.ltv = ltv;
+    this.liquidationThreshold = liquidationThreshold;
+    this.borrowLimitUsd = borrowLimitUsd;
+  }
+  /** Aggregate borrowed USD for headroom; prefers per-borrow breakdown when present. */
+  userPositionBorrowedValueUsd() {
+    const fromBorrows = this.borrows.reduce((sum2, borrow) => sum2 + borrow.valueUsd, 0);
+    if (fromBorrows > 0) {
+      return fromBorrows;
+    }
+    if (this.borrowLimitUsd !== void 0 && this.utilizationRate > 0) {
+      return this.borrowLimitUsd * this.utilizationRate;
+    }
+    return 0;
+  }
+  /**
+   * Max additional debt UI amount before the platform rejects the borrow.
+   * Uses obligation `borrowLimitUsd − borrowedUsd`, floored to base units with a
+   * one-unit buffer so simulation-time refresh cannot overshoot. Returns `undefined`
+   * when `borrowLimitUsd` was not set by the platform loader.
+   */
+  getMaxAdditionalBorrowUiAmount(debtPriceUsd, debtDecimals) {
+    if (this.borrowLimitUsd === void 0) {
+      return void 0;
+    }
+    const borrowedValueUsd = this.userPositionBorrowedValueUsd();
+    const headroomUsd = Math.max(0, this.borrowLimitUsd - borrowedValueUsd);
+    if (headroomUsd <= 0 || !(debtPriceUsd > 0)) {
+      return 0;
+    }
+    const headroomUi = headroomUsd / debtPriceUsd;
+    const maxBaseUnits = fromUiAmount(headroomUi, debtDecimals);
+    const safeBaseUnits = BN3.max(maxBaseUnits.subn(1), new BN3(0));
+    return toUiAmount(safeBaseUnits, debtDecimals);
+  }
+};
+
+// ../../shared/lending-platforms/src/data/userPosition/kamino.ts
+var KaminoUserPositionData = class _KaminoUserPositionData extends UserPositionBase {
+  /** Creates a KaminoUserPositionData from a raw KaminoObligation */
+  static loadData(obligation) {
+    const deposits = [];
+    obligation.deposits.forEach((deposit, mint) => {
+      deposits.push({
+        reserve: deposit.reserveAddress,
+        mint,
+        amount: new BN4(deposit.amount.toFixed(0)),
+        valueUsd: deposit.marketValueRefreshed.toNumber()
+      });
+    });
+    const borrows = [];
+    obligation.borrows.forEach((borrow, mint) => {
+      borrows.push({
+        reserve: borrow.reserveAddress,
+        mint,
+        amount: new BN4(borrow.amount.toFixed(0)),
+        valueUsd: borrow.marketValueRefreshed.toNumber()
+      });
+    });
+    const borrowedValueUsd = obligation.refreshedStats.userTotalBorrow.toNumber();
+    const borrowLimitUsd = obligation.refreshedStats.borrowLimit.toNumber();
+    const utilizationRate = borrowLimitUsd > 0 ? borrowedValueUsd / borrowLimitUsd : 0;
+    const data = new _KaminoUserPositionData(
+      obligation.obligationAddress,
+      utilizationRate,
+      deposits,
+      borrows,
+      void 0,
+      void 0,
+      borrowLimitUsd
+    );
+    data.rawData = obligation;
+    return data;
+  }
+  /**
+   * Determines if the obligation needs a refresh_obligation instruction.
+   */
+  requiresRefresh() {
+    return true;
+  }
+};
+
+// ../../shared/lending-platforms/src/data/instructions/kamino.ts
+import { BN as BN5 } from "@anchor-lang/core";
+import { address as address2, getAddressEncoder } from "@solana/kit";
+import { Scope as Scope3 } from "@kamino-finance/scope-sdk";
+import {
+  DEFAULT_PUBLIC_KEY as DEFAULT_PUBLIC_KEY3,
+  lendingMarketAuthPda,
+  PROGRAM_ID as PROGRAM_ID3,
+  userMetadataPda as userMetadataPda2,
+  VanillaObligation as VanillaObligation2
+} from "@kamino-finance/klend-sdk";
+
+// ../../shared/lending-platforms/src/data/instructions/lpInstructionsBase.ts
+var LpInstructionsBase = class {
+  constructor(rpc, rpcUrl, data, accounts) {
+    /** Tracks which reserves (and their pools/roles) are involved in each transaction */
+    this.txReserves = /* @__PURE__ */ new Map();
+    /**
+     * Per-txId per-obligation set of debt reserves that the caller has flagged
+     * as being fully repaid earlier in the same transaction. Subsequent
+     * `RefreshObligation` builds for that obligation must NOT include these
+     * reserves in the borrow accounts list — by execution time the borrow row
+     * has been removed from the obligation, and Kamino's `handler_refresh_obligation`
+     * checks the passed account count against the live obligation state and
+     * fails with `InvalidAccountInput` (klend error 6006) on a mismatch.
+     *
+     * Set via {@link markObligationDebtCleared}, read via {@link getTxObligationClearedDebt}.
+     */
+    this.txClearedDebt = /* @__PURE__ */ new Map();
+    this.rpc = rpc;
+    this.rpcUrl = rpcUrl;
+    this.data = data;
+    this.accounts = accounts;
+  }
+  emptyAccountMeta() {
+    return toCustomAccountMeta(this.programId);
+  }
+  clearCacheEntry(category, id) {
+    this.data.clearCacheEntry(category, id);
+  }
+  getCacheInvalidation(invalidation) {
+    return {
+      client: "kamino",
+      ...invalidation
+    };
+  }
+  applyPostSuccessCacheInvalidations(invalidations) {
+    for (const invalidation of invalidations) {
+      if (invalidation.client !== "kamino") {
+        continue;
+      }
+      this.clearCacheEntry(invalidation.category, invalidation.id);
+    }
+  }
+  getCpiData(cpiType, accounts, data, programId, postSuccessCacheInvalidations) {
+    return {
+      programId: programId ?? this.programId,
+      cpiType,
+      data,
+      accounts,
+      lookupTables: [this.lookupTable],
+      postSuccessCacheInvalidations
+    };
+  }
+  createSplitOperationCpiData(prerequisiteCpis, cpis) {
+    return {
+      prerequisiteCpis,
+      cpis,
+      allCpis: [...prerequisiteCpis, ...cpis]
+    };
+  }
+  buildLendingOperationCpiBundle(cpiData) {
+    return {
+      prerequisiteCpis: cpiData.prerequisiteCpis,
+      cpis: cpiData.cpis,
+      allCpis: [...cpiData.prerequisiteCpis, ...cpiData.cpis],
+      postSuccessCacheInvalidations: [...cpiData.prerequisiteCpis, ...cpiData.cpis].flatMap(
+        (cpi) => cpi.postSuccessCacheInvalidations ?? []
+      )
+    };
+  }
+  async getInitAndDepositCpiBundle(params, userAccountId) {
+    return this.buildLendingOperationCpiBundle(
+      await this.getInitAndDepositCpiData(params, userAccountId)
+    );
+  }
+  async getInitBorrowPositionCpiBundle(params, collReserve) {
+    return this.buildLendingOperationCpiBundle(
+      await this.getInitBorrowPositionCpiData(params, collReserve)
+    );
+  }
+  async getDepositCpiBundle(params) {
+    return this.buildLendingOperationCpiBundle(await this.getDepositCpiData(params));
+  }
+  async getWithdrawCpiBundle(params) {
+    return this.buildLendingOperationCpiBundle(await this.getWithdrawCpiData(params));
+  }
+  async getBorrowCpiBundle(params) {
+    return this.buildLendingOperationCpiBundle(await this.getBorrowCpiData(params));
+  }
+  async getRepayCpiBundle(params) {
+    return this.buildLendingOperationCpiBundle(await this.getRepayCpiData(params));
+  }
+  /**
+   * Registers a reserve as being used in a transaction.
+   * When userAccount and role are provided, also tracks the collateral/debt role
+   * for that specific user account.
+   */
+  registerTxReserve(txId, pool, reserve, userAccount, role) {
+    if (!this.txReserves.has(txId)) {
+      this.txReserves.set(txId, /* @__PURE__ */ new Map());
+    }
+    const txMap = this.txReserves.get(txId);
+    if (!txMap.has(reserve)) {
+      txMap.set(reserve, { pool, userAccounts: /* @__PURE__ */ new Map() });
+    }
+    if (userAccount && role) {
+      const entry = txMap.get(reserve);
+      if (!entry.userAccounts.has(userAccount)) {
+        entry.userAccounts.set(userAccount, /* @__PURE__ */ new Set());
+      }
+      entry.userAccounts.get(userAccount).add(role);
+    }
+  }
+  /**
+   * Returns the collateral and debt reserves registered in the tx cache
+   * for a specific user account (obligation).
+   */
+  getTxUserAccountReserves(txId, userAccount) {
+    const collateral = [];
+    const debt = [];
+    const txMap = this.txReserves.get(txId);
+    if (!txMap) return { collateral, debt };
+    for (const [reserve, info] of txMap) {
+      const roles = info.userAccounts.get(userAccount);
+      if (roles?.has("collateral")) collateral.push(reserve);
+      if (roles?.has("debt")) debt.push(reserve);
+    }
+    return { collateral, debt };
+  }
+  /**
+   * Mark that `reserve` will be fully repaid for `userAccount` earlier in the
+   * `txId` flow, so subsequent obligation-refresh builders drop it from the
+   * borrow accounts they emit. Call after building a "repay all" CPI; it has
+   * no effect on the repay itself.
+   */
+  markObligationDebtCleared(txId, userAccount, reserve) {
+    if (!this.txClearedDebt.has(txId)) {
+      this.txClearedDebt.set(txId, /* @__PURE__ */ new Map());
+    }
+    const obligationMap = this.txClearedDebt.get(txId);
+    if (!obligationMap.has(userAccount)) {
+      obligationMap.set(userAccount, /* @__PURE__ */ new Set());
+    }
+    obligationMap.get(userAccount).add(reserve);
+  }
+  /** Returns the set of debt reserves marked cleared for `(txId, userAccount)`. */
+  getTxObligationClearedDebt(txId, userAccount) {
+    return this.txClearedDebt.get(txId)?.get(userAccount) ?? /* @__PURE__ */ new Set();
+  }
+  /**
+   * Clears the transaction cache for a given transaction or all transactions.
+   * Call after finishing building a transaction to free memory.
+   */
+  clearTransactionCache(txId) {
+    if (txId) {
+      this.txReserves.delete(txId);
+      this.txClearedDebt.delete(txId);
+    } else {
+      this.txReserves.clear();
+      this.txClearedDebt.clear();
+    }
+  }
+  /**
+   * Returns prerequisite CPIs needed before reading refreshed account state for
+   * a batch of lending positions outside a normal deposit/withdraw/borrow/repay
+   * flow.
+   */
+  async getPrerequisiteCpisForRefresh(_targets) {
+    return [];
+  }
+  /**
+   * Returns CPI data for initializing a lending position end-to-end: the user
+   * account itself plus any per-reserve accessory accounts (e.g. Kamino
+   * obligation farm user states for the collateral and debt reserves). Called
+   * at position-creation time so subsequent deposit/borrow flows don't need
+   * to init these inline.
+   *
+   * Default: delegates to {@link getInitUserAccountCpiData}. Platforms with
+   * per-reserve accessory accounts override this to add their inits.
+   */
+  async getInitLendingPositionCpiData(params) {
+    return this.getInitUserAccountCpiData(
+      params.pool,
+      params.user,
+      params.payer,
+      params.userAccountId
+    );
+  }
+};
+
+// ../../shared/lending-platforms/src/data/instructions/kamino.ts
+import { TOKEN_PROGRAM_ADDRESS } from "@solana-program/token";
+import { getTreasuryVaultPDA } from "@kamino-finance/farms-sdk";
+var KaminoInstructions = class extends LpInstructionsBase {
+  constructor(rpc, rpcUrl, data, accounts) {
+    super(rpc, rpcUrl, data, accounts);
+    this.programId = PROGRAM_ID3;
+    this.lookupTable = address2("bzdjSeDDPEdsGpK73oevQ87x4Sm6QRsnzupPLQEaFFN");
+  }
+  clearTransactionCache(txId) {
+    super.clearTransactionCache(txId);
+  }
+  // ================ CPI Data ================
+  getUserAccountCacheInvalidations(userAccount) {
+    return [
+      this.getCacheInvalidation({
+        category: this.data.userAccountCatKey,
+        id: userAccount
+      })
+    ];
+  }
+  async getInitUserMetadataCpiData(user, payer, userLookupTable) {
+    const [userMetadataAddress] = await userMetadataPda2(user, this.programId);
+    if (await accountExists(this.rpc, userMetadataAddress)) return;
+    return this.getCpiData(
+      CpiTypes.K_INIT_USER_METADATA,
+      [
+        toCustomAccountMeta(user, false, void 0, true),
+        toCustomAccountMeta(payer, true, void 0, true),
+        toCustomAccountMeta(userMetadataAddress, true),
+        this.emptyAccountMeta(),
+        RENT_SYSVAR_META,
+        SYSTEM_PROGRAM_META
+      ],
+      new Uint8Array(getAddressEncoder().encode(userLookupTable ?? DEFAULT_PUBLIC_KEY3))
+    );
+  }
+  async getInitLendingPositionCpiData(params) {
+    const userInit = await this.getInitUserAccountCpiData(
+      params.pool,
+      params.user,
+      params.payer,
+      params.userAccountId
+    );
+    const obligation = await this.accounts.getUserAccountAddress(
+      params.pool,
+      params.user,
+      params.userAccountId
+    );
+    const farmCpis = [];
+    const farmTargets = [
+      [params.collateralReserve, "collateral"],
+      [params.debtReserve, "debt"]
+    ];
+    for (const [reserve, mode] of farmTargets) {
+      const reserveData = await this.data.fetchReserve(params.pool, reserve);
+      const reserveFarm = mode === "collateral" ? reserveData.rawData.state.farmCollateral : reserveData.rawData.state.farmDebt;
+      if (!reserveFarm || reserveFarm === DEFAULT_PUBLIC_KEY3) continue;
+      const farmAccounts = await this.accounts.getFarmAccounts(
+        params.pool,
+        reserve,
+        obligation,
+        mode
+      );
+      if (await accountExists(this.rpc, farmAccounts.userFarm.address)) continue;
+      farmCpis.push(
+        await this.getInitObligationFarmsForReserveCpiData(
+          params.user,
+          params.payer,
+          obligation,
+          params.pool,
+          reserve,
+          mode
+        )
+      );
+    }
+    return this.createSplitOperationCpiData(userInit.prerequisiteCpis, [
+      ...userInit.cpis,
+      ...farmCpis
+    ]);
+  }
+  async getInitUserAccountCpiData(pool, user, payer, id, userLookupTable) {
+    const market = await this.data.fetchMarket(pool);
+    const obligationPda = await this.accounts.getUserAccountAddress(pool, user, id);
+    const userMetadataAddress = await this.accounts.getUserMetadataAddress(user);
+    const tag = VanillaObligation2.tag;
+    const initMetadataCpi = await this.getInitUserMetadataCpiData(user, payer, userLookupTable);
+    const obligationAlreadyInit = await accountExists(this.rpc, obligationPda);
+    return this.createSplitOperationCpiData(
+      [],
+      [
+        ...initMetadataCpi ? [initMetadataCpi] : [],
+        ...obligationAlreadyInit ? [] : [
+          this.getCpiData(
+            CpiTypes.K_INIT_OBLIGATION,
+            [
+              toCustomAccountMeta(user),
+              toCustomAccountMeta(payer, true),
+              toCustomAccountMeta(obligationPda, true),
+              toCustomAccountMeta(market.address),
+              toCustomAccountMeta(DEFAULT_PUBLIC_KEY3),
+              toCustomAccountMeta(DEFAULT_PUBLIC_KEY3),
+              toCustomAccountMeta(userMetadataAddress),
+              RENT_SYSVAR_META,
+              SYSTEM_PROGRAM_META
+            ],
+            new Uint8Array([tag, id])
+          )
+        ]
+      ]
+    );
+  }
+  async getInitObligationFarmsForReserveCpiData(user, payer, obligation, pool, reserve, farmMode) {
+    const farmAccounts = await this.accounts.getFarmAccounts(pool, reserve, obligation, farmMode);
+    return this.getCpiData(
+      CpiTypes.K_INIT_USER_FARM,
+      [
+        toCustomAccountMeta(payer, true),
+        toCustomAccountMeta(user),
+        toCustomAccountMeta(obligation, true),
+        toCustomAccountMeta((await lendingMarketAuthPda(pool))[0]),
+        toCustomAccountMeta(reserve, true),
+        farmAccounts.farm,
+        farmAccounts.userFarm,
+        toCustomAccountMeta(pool),
+        toCustomAccountMeta(KAMINO_FARMS_PROGRAM_ID),
+        RENT_SYSVAR_META,
+        SYSTEM_PROGRAM_META
+      ],
+      new Uint8Array([farmMode === "collateral" ? 0 : 1])
+    );
+  }
+  /**
+   * Returns CPI accounts for refreshing a reserve's state.
+   * Includes the market, reserve, and all configured oracle accounts.
+   */
+  async getRefreshReserveCpiData(pool, reserve) {
+    const reserveData = await this.data.fetchReserve(pool, reserve);
+    const oracleAccounts = reserveData.getOracleAccounts();
+    return this.getCpiData(
+      CpiTypes.K_REFRESH_RESERVE,
+      [
+        toCustomAccountMeta(reserve, true),
+        toCustomAccountMeta(pool),
+        ...Object.values(oracleAccounts).map(
+          (x) => x === void 0 ? this.emptyAccountMeta() : toCustomAccountMeta(x)
+        )
+      ],
+      new Uint8Array()
+    );
+  }
+  async getRefreshObligationCpiData(txId, pool, obligation) {
+    const obligationData = await this.data.maybeFetchUserPositionInPool(pool, obligation);
+    const cached = this.getTxUserAccountReserves(txId, obligation);
+    const cleared = this.getTxObligationClearedDebt(txId, obligation);
+    const collateralReserves = [
+      .../* @__PURE__ */ new Set([...obligationData?.deposits.map((x) => x.reserve) ?? [], ...cached.collateral])
+    ];
+    const debtReserves = [
+      .../* @__PURE__ */ new Set([...obligationData?.borrows.map((x) => x.reserve) ?? [], ...cached.debt])
+    ].filter((r) => !cleared.has(r));
+    return this.getCpiData(
+      CpiTypes.K_REFRESH_OBLIGATION,
+      [
+        toCustomAccountMeta(pool),
+        toCustomAccountMeta(obligation, true),
+        ...collateralReserves.map((x) => toCustomAccountMeta(x)),
+        ...debtReserves.map((x) => toCustomAccountMeta(x))
+      ],
+      new Uint8Array()
+    );
+  }
+  getRefreshObligationCpiDataFromReserves({
+    pool,
+    userAccount,
+    collateralReserves,
+    debtReserves
+  }) {
+    return this.getCpiData(
+      CpiTypes.K_REFRESH_OBLIGATION,
+      [
+        toCustomAccountMeta(pool),
+        toCustomAccountMeta(userAccount, true),
+        ...dedupeOrderedAddresses(collateralReserves).map((x) => toCustomAccountMeta(x)),
+        ...dedupeOrderedAddresses(debtReserves).map((x) => toCustomAccountMeta(x))
+      ],
+      new Uint8Array()
+    );
+  }
+  async getPrerequisiteCpisForRefresh(targets) {
+    const reserveRefreshes = [];
+    const seenReserveRefreshes = /* @__PURE__ */ new Set();
+    const obligationRefreshes = /* @__PURE__ */ new Map();
+    for (const target of targets) {
+      for (const reserve of dedupeOrderedAddresses([
+        ...target.collateralReserves,
+        ...target.debtReserves
+      ])) {
+        const reserveRefreshKey = `${target.pool}:${reserve}`;
+        if (seenReserveRefreshes.has(reserveRefreshKey)) {
+          continue;
+        }
+        seenReserveRefreshes.add(reserveRefreshKey);
+        reserveRefreshes.push({ pool: target.pool, reserve });
+      }
+      if (target.userAccount === DEFAULT_PUBLIC_KEY3) {
+        continue;
+      }
+      const obligationKey = `${target.pool}:${target.userAccount}`;
+      if (obligationRefreshes.has(obligationKey)) {
+        continue;
+      }
+      obligationRefreshes.set(obligationKey, {
+        pool: target.pool,
+        userAccount: target.userAccount,
+        collateralReserves: dedupeOrderedAddresses(target.collateralReserves),
+        debtReserves: dedupeOrderedAddresses(target.debtReserves)
+      });
+    }
+    const prerequisiteCpis = [];
+    for (const { pool, reserve } of reserveRefreshes) {
+      prerequisiteCpis.push(await this.getRefreshReserveCpiData(pool, reserve));
+    }
+    for (const obligationRefresh of obligationRefreshes.values()) {
+      let obligationData = null;
+      try {
+        obligationData = await this.data.maybeFetchUserPositionInPool(
+          obligationRefresh.pool,
+          obligationRefresh.userAccount
+        );
+      } catch {
+        obligationData = null;
+      }
+      if (!obligationData) {
+        continue;
+      }
+      prerequisiteCpis.push(
+        this.getRefreshObligationCpiDataFromReserves({
+          pool: obligationRefresh.pool,
+          userAccount: obligationRefresh.userAccount,
+          collateralReserves: obligationData.deposits.map((deposit) => deposit.reserve),
+          debtReserves: obligationData.borrows.map((borrow) => borrow.reserve)
+        })
+      );
+    }
+    return prerequisiteCpis;
+  }
+  async getRefreshUserFarmCpiData(signer, pool, reserve, obligation, userFarm, farm, mode) {
+    const details = await this.accounts.reserveInteractionDetails(
+      signer,
+      pool,
+      reserve,
+      obligation
+    );
+    return this.getCpiData(
+      CpiTypes.K_REFRESH_USER_FARM,
+      [
+        details.signer,
+        details.obligation,
+        details.lendingMarketAuthority,
+        details.reserve,
+        toCustomAccountMeta(farm, true),
+        toCustomAccountMeta(userFarm, true),
+        details.lendingMarket,
+        details.farmsProgram,
+        RENT_SYSVAR_META,
+        SYSTEM_PROGRAM_META
+      ],
+      new Uint8Array([mode === "collateral" ? 0 : 1])
+    );
+  }
+  /**
+   * Checks if refresh CPIs are needed for the given reserve and obligation.
+   * Also registers all involved reserves in the txReserves cache for getPreInstructions.
+   *
+   * The instruction `reserve` (collateral vs debt) is also listed on the obligation;
+   * `dedupeOrderedAddresses` ensures one RefreshReserve CPI per reserve pubkey.
+   */
+  async getRefreshCpisIfNeeded(txId, pool, reserve, obligation) {
+    const cpis = [];
+    const cached = this.getTxUserAccountReserves(txId, obligation);
+    const refreshReserve = async (reserveAddr) => {
+      cpis.push(await this.getRefreshReserveCpiData(pool, reserveAddr));
+      this.registerTxReserve(txId, pool, reserveAddr);
+    };
+    const obligationData = await this.data.maybeFetchUserPositionInPool(pool, obligation);
+    if (obligationData) {
+      const needsFullObligationRefresh = obligationData.requiresRefresh() || cached.collateral.length > 0 || cached.debt.length > 0;
+      if (needsFullObligationRefresh) {
+        const additional = [
+          ...obligationData.deposits.map((d) => d.reserve),
+          ...obligationData.borrows.map((b) => b.reserve),
+          ...cached.collateral,
+          ...cached.debt
+        ];
+        for (const addr of dedupeOrderedAddresses([reserve, ...additional])) {
+          await refreshReserve(addr);
+        }
+        cpis.push(await this.getRefreshObligationCpiData(txId, pool, obligation));
+      } else {
+        await refreshReserve(reserve);
+      }
+    } else {
+      const additional = [.../* @__PURE__ */ new Set([...cached.collateral, ...cached.debt])];
+      for (const addr of dedupeOrderedAddresses([reserve, ...additional])) {
+        await refreshReserve(addr);
+      }
+      cpis.push(await this.getRefreshObligationCpiData(txId, pool, obligation));
+    }
+    return cpis;
+  }
+  async getPreInstructions(txId) {
+    const reserveEntries = this.txReserves.get(txId);
+    if (!reserveEntries) return [];
+    const SCOPE_CHAIN_END = 65535;
+    const scopeFeeds = /* @__PURE__ */ new Map();
+    if (reserveEntries) {
+      for (const [reserve, { pool }] of reserveEntries) {
+        const reserveData = await this.data.fetchReserve(pool, reserve);
+        if (!reserveData.requiresRefresh()) continue;
+        const scopeFeed = reserveData.getOracleAccounts().scope;
+        if (!scopeFeed) continue;
+        if (!scopeFeeds.has(scopeFeed)) {
+          scopeFeeds.set(scopeFeed, /* @__PURE__ */ new Set());
+        }
+        const tokens2 = scopeFeeds.get(scopeFeed);
+        const { priceChain, twapChain } = reserveData.rawData.state.config.tokenInfo.scopeConfiguration;
+        for (const chain of [priceChain, twapChain]) {
+          for (const index of chain) {
+            if (index === SCOPE_CHAIN_END) break;
+            tokens2.add(index);
+          }
+        }
+      }
+    }
+    const configTokens = /* @__PURE__ */ new Map();
+    for (const [feed, chainTokens2] of scopeFeeds) {
+      const configAddr2 = await this.data.fetchScopeConfigAddress(feed);
+      if (!configTokens.has(configAddr2)) {
+        configTokens.set(configAddr2, /* @__PURE__ */ new Set());
+      }
+      const merged = configTokens.get(configAddr2);
+      for (const t of chainTokens2) merged.add(t);
+    }
+    const scope = new Scope3("mainnet-beta", this.rpc);
+    const isLocalnet = this.rpcUrl === LOCALNET_URL;
+    const [firstEntry] = configTokens;
+    if (!firstEntry) return [];
+    const [configAddr, chainTokens] = firstEntry;
+    let tokens;
+    if (isLocalnet) {
+      const mappings = await scope.getOracleMappings({ config: address2(configAddr) });
+      const allTokens = /* @__PURE__ */ new Set();
+      for (const token of chainTokens) {
+        collectTokenDependencies(token, mappings, allTokens);
+      }
+      tokens = [...allTokens];
+    } else {
+      tokens = [...chainTokens];
+    }
+    const ix = await scope.refreshPriceListIx({ config: address2(configAddr) }, tokens);
+    return ix ? [ix] : [];
+  }
+  async getClaimIncentiveCpiData(user, payer, pool, reserve, obligation, farm, userFarm, mint) {
+    const tokenProgram = mints.get(mint)?.tokenProgram ?? TOKEN_PROGRAM_ADDRESS;
+    const reserveData = await this.data.fetchReserve(pool, reserve);
+    const [farmState] = await this.data.fetchFarms([farm]);
+    const rewardIndex = farmState.rewardInfos.findIndex((r) => r.token.mint === mint);
+    if (rewardIndex === -1) {
+      throw new Error(`Reward mint ${mint} not found on farm ${farm}`);
+    }
+    const rewardInfo = farmState.rewardInfos[rewardIndex];
+    const treasuryVault = await getTreasuryVaultPDA(
+      KAMINO_FARMS_PROGRAM_ID,
+      farmState.globalConfig,
+      mint
+    );
+    const scopePrices = farmState.scopePrices === DEFAULT_PUBLIC_KEY3 ? KAMINO_FARMS_PROGRAM_ID : farmState.scopePrices;
+    const mode = reserveData.rawData.state.farmCollateral === farm ? "collateral" : reserveData.rawData.state.farmDebt === farm ? "debt" : void 0;
+    const refreshIx = mode ? await this.getRefreshUserFarmCpiData(user, pool, reserve, obligation, userFarm, farm, mode) : void 0;
+    return [
+      ...refreshIx ? [refreshIx] : [],
+      this.getCpiData(
+        CpiTypes.K_HARVEST_REWARD,
+        [
+          toCustomAccountMeta(user, true),
+          toCustomAccountMeta(userFarm, true),
+          toCustomAccountMeta(farm, true),
+          toCustomAccountMeta(farmState.globalConfig),
+          toCustomAccountMeta(mint),
+          toCustomAccountMeta(await getAtaAddress(mint, user, tokenProgram), true, {
+            owner: user,
+            mint,
+            tokenProgram
+          }),
+          toCustomAccountMeta(rewardInfo.rewardsVault, true),
+          toCustomAccountMeta(treasuryVault, true),
+          toCustomAccountMeta(farmState.farmVaultsAuthority),
+          toCustomAccountMeta(scopePrices),
+          toCustomAccountMeta(tokenProgram)
+        ],
+        numToU64Bytes(rewardIndex),
+        KAMINO_FARMS_PROGRAM_ID
+      )
+    ];
+  }
+  async getRequestElevationGroupCpiData(elevationGroup, user, obligation, pool, txId) {
+    const obligationData = await this.data.maybeFetchUserPositionInPool(pool, obligation);
+    const cached = this.getTxUserAccountReserves(txId, obligation);
+    const cleared = this.getTxObligationClearedDebt(txId, obligation);
+    const collateralReserves = [
+      .../* @__PURE__ */ new Set([...obligationData?.deposits.map((x) => x.reserve) ?? [], ...cached.collateral])
+    ];
+    const debtReserves = [
+      .../* @__PURE__ */ new Set([...obligationData?.borrows.map((x) => x.reserve) ?? [], ...cached.debt])
+    ].filter((r) => !cleared.has(r));
+    return this.getCpiData(
+      CpiTypes.K_REQUEST_ELEVATION_GROUP,
+      [
+        toCustomAccountMeta(user),
+        toCustomAccountMeta(obligation, true),
+        toCustomAccountMeta(pool),
+        ...collateralReserves.map((x) => toCustomAccountMeta(x, true)),
+        ...debtReserves.map((x) => toCustomAccountMeta(x, true))
+      ],
+      new Uint8Array([elevationGroup])
+    );
+  }
+  async getInitAndDepositCpiData(params, userAccountId) {
+    const initCpis = [];
+    if (!await accountExists(this.rpc, params.userAccount)) {
+      initCpis.push(
+        ...(await this.getInitUserAccountCpiData(
+          params.pool,
+          params.user,
+          params.payer,
+          userAccountId
+        )).allCpis,
+        await this.getRefreshObligationCpiData(params.txId, params.pool, params.userAccount)
+      );
+    }
+    const reserveData = await this.data.fetchReserve(params.pool, params.reserve);
+    const farmCollateral = reserveData.rawData.state.farmCollateral;
+    if (farmCollateral && farmCollateral !== DEFAULT_PUBLIC_KEY3) {
+      const farmAccounts = await this.accounts.getFarmAccounts(
+        params.pool,
+        params.reserve,
+        params.userAccount,
+        "collateral"
+      );
+      if (!await accountExists(this.rpc, farmAccounts.userFarm.address)) {
+        initCpis.push(
+          await this.getInitObligationFarmsForReserveCpiData(
+            params.user,
+            params.payer,
+            params.userAccount,
+            params.pool,
+            params.reserve,
+            "collateral"
+          )
+        );
+      }
+    }
+    const depositCpis = await this.getDepositCpiData(params);
+    return this.createSplitOperationCpiData(
+      [...initCpis, ...depositCpis.prerequisiteCpis],
+      depositCpis.cpis
+    );
+  }
+  async getInitBorrowPositionCpiData(params, collReserve) {
+    const initCpis = [];
+    const reserveData = await this.data.fetchReserve(params.pool, params.reserve);
+    const farmDebt = reserveData.rawData.state.farmDebt;
+    if (farmDebt && farmDebt !== DEFAULT_PUBLIC_KEY3) {
+      const farmAccounts = await this.accounts.getFarmAccounts(
+        params.pool,
+        params.reserve,
+        params.userAccount,
+        "debt"
+      );
+      if (!await accountExists(this.rpc, farmAccounts.userFarm.address)) {
+        initCpis.push(
+          await this.getInitObligationFarmsForReserveCpiData(
+            params.user,
+            params.payer,
+            params.userAccount,
+            params.pool,
+            params.reserve,
+            "debt"
+          )
+        );
+      }
+    }
+    const debtReserveData = await this.data.fetchReserve(params.pool, params.reserve);
+    const market = await this.data.fetchMarket(params.pool);
+    const requestedBorrowBaseUnits = params.baseUnitAmount && params.baseUnitAmount !== "all" ? params.baseUnitAmount : typeof params.uiAmount === "number" ? new BN5(Math.floor(params.uiAmount * Math.pow(10, debtReserveData.mint.mintDecimals))) : void 0;
+    const collReserveData = await this.data.fetchReserve(params.pool, collReserve);
+    const availableElevationGroups = collReserveData.config.emodes?.filter(
+      (x) => x.debtReserve === params.reserve
+    );
+    if (availableElevationGroups?.length) {
+      const sortedGroups = [...availableElevationGroups].filter((g) => g.id !== void 0).sort((a, b) => b.ltvPct - a.ltvPct);
+      let selectedGroup;
+      for (const group of sortedGroups) {
+        const [available] = debtReserveData.rawData.getLiquidityAvailableForDebtReserveGivenCaps(
+          market,
+          [group.id],
+          [collReserve]
+        );
+        const hasCapacity = requestedBorrowBaseUnits ? available.gte(requestedBorrowBaseUnits.toString()) : available.gt(0);
+        if (hasCapacity) {
+          selectedGroup = group.id;
+          break;
+        }
+      }
+      if (selectedGroup !== void 0) {
+        initCpis.push(
+          ...await this.getRefreshCpisIfNeeded(
+            params.txId,
+            params.pool,
+            collReserve,
+            params.userAccount
+          )
+        );
+        initCpis.push(
+          await this.getRequestElevationGroupCpiData(
+            selectedGroup,
+            params.user,
+            params.userAccount,
+            params.pool,
+            params.txId
+          )
+        );
+      }
+    }
+    const borrowCpis = await this.getBorrowCpiData(params);
+    return this.createSplitOperationCpiData(
+      [...initCpis, ...borrowCpis.prerequisiteCpis],
+      borrowCpis.cpis
+    );
+  }
+  async getDepositCpiData(params) {
+    const refreshCpis = await this.getRefreshCpisIfNeeded(
+      params.txId,
+      params.pool,
+      params.reserve,
+      params.userAccount
+    );
+    const details = await this.accounts.reserveInteractionDetails(
+      params.user,
+      params.pool,
+      params.reserve,
+      params.userAccount,
+      typeof params.uiAmount === "number" ? params.uiAmount : void 0,
+      params.baseUnitAmount instanceof BN5 ? params.baseUnitAmount : void 0
+    );
+    const farms = await this.accounts.getFarmAccounts(
+      params.pool,
+      params.reserve,
+      params.userAccount,
+      "collateral"
+    );
+    this.registerTxReserve(
+      params.txId,
+      params.pool,
+      params.reserve,
+      params.userAccount,
+      "collateral"
+    );
+    return this.createSplitOperationCpiData(refreshCpis, [
+      this.getCpiData(
+        CpiTypes.K_DEPOSIT,
+        [
+          details.signer,
+          details.obligation,
+          details.lendingMarket,
+          details.lendingMarketAuthority,
+          details.reserve,
+          details.reserveLiquidityMint,
+          details.reserveLiquiditySupply,
+          details.reserveCollateralMint,
+          details.reserveCollateralSupply,
+          details.userLiquidityTa,
+          this.emptyAccountMeta(),
+          details.collateralMintTokenProgram,
+          details.liquidityMintTokenProgram,
+          IX_SYSVAR_META,
+          farms.userFarm,
+          farms.farm,
+          details.farmsProgram
+        ],
+        details.baseUnitAmount ? numToU64Bytes(details.baseUnitAmount) : void 0,
+        void 0,
+        this.getUserAccountCacheInvalidations(params.userAccount)
+      )
+    ]);
+  }
+  async getWithdrawCpiData(params) {
+    const refreshCpis = await this.getRefreshCpisIfNeeded(
+      params.txId,
+      params.pool,
+      params.reserve,
+      params.userAccount
+    );
+    const withdrawAll = params.uiAmount === "all" || params.baseUnitAmount === "all";
+    const details = await this.accounts.reserveInteractionDetails(
+      params.user,
+      params.pool,
+      params.reserve,
+      params.userAccount,
+      typeof params.uiAmount === "number" ? params.uiAmount : void 0,
+      params.baseUnitAmount instanceof BN5 ? params.baseUnitAmount : void 0
+    );
+    const farms = await this.accounts.getFarmAccounts(
+      params.pool,
+      params.reserve,
+      params.userAccount,
+      "collateral"
+    );
+    let collateralBytes;
+    if (withdrawAll) {
+      collateralBytes = numToU64Bytes(U64_MAX_BN);
+    } else if (details.baseUnitAmount) {
+      const reserveData = await this.data.fetchReserve(params.pool, params.reserve);
+      const collateralAmount = liquidityToCollateral(reserveData, details.baseUnitAmount.toNumber()) + 1;
+      collateralBytes = numToU64Bytes(collateralAmount);
+    }
+    this.registerTxReserve(
+      params.txId,
+      params.pool,
+      params.reserve,
+      params.userAccount,
+      "collateral"
+    );
+    return this.createSplitOperationCpiData(refreshCpis, [
+      this.getCpiData(
+        CpiTypes.K_WITHDRAW,
+        [
+          details.signer,
+          details.obligation,
+          details.lendingMarket,
+          details.lendingMarketAuthority,
+          details.reserve,
+          details.reserveLiquidityMint,
+          details.reserveCollateralSupply,
+          details.reserveCollateralMint,
+          details.reserveLiquiditySupply,
+          details.userLiquidityTa,
+          this.emptyAccountMeta(),
+          details.collateralMintTokenProgram,
+          details.liquidityMintTokenProgram,
+          IX_SYSVAR_META,
+          farms.userFarm,
+          farms.farm,
+          details.farmsProgram
+        ],
+        collateralBytes,
+        void 0,
+        this.getUserAccountCacheInvalidations(params.userAccount)
+      )
+    ]);
+  }
+  async getBorrowCpiData(params) {
+    const refreshCpis = await this.getRefreshCpisIfNeeded(
+      params.txId,
+      params.pool,
+      params.reserve,
+      params.userAccount
+    );
+    const details = await this.accounts.reserveInteractionDetails(
+      params.user,
+      params.pool,
+      params.reserve,
+      params.userAccount,
+      typeof params.uiAmount === "number" ? params.uiAmount : void 0
+    );
+    const farms = await this.accounts.getFarmAccounts(
+      params.pool,
+      params.reserve,
+      params.userAccount,
+      "debt"
+    );
+    this.registerTxReserve(params.txId, params.pool, params.reserve, params.userAccount, "debt");
+    return this.createSplitOperationCpiData(refreshCpis, [
+      this.getCpiData(
+        CpiTypes.K_BORROW,
+        [
+          details.signer,
+          details.obligation,
+          details.lendingMarket,
+          details.lendingMarketAuthority,
+          details.reserve,
+          details.reserveLiquidityMint,
+          details.reserveLiquiditySupply,
+          details.reserveFeeVault,
+          details.userLiquidityTa,
+          this.emptyAccountMeta(),
+          details.liquidityMintTokenProgram,
+          IX_SYSVAR_META,
+          farms.userFarm,
+          farms.farm,
+          details.farmsProgram
+        ],
+        details.baseUnitAmount ? numToU64Bytes(details.baseUnitAmount) : void 0,
+        void 0,
+        this.getUserAccountCacheInvalidations(params.userAccount)
+      )
+    ]);
+  }
+  async getRepayCpiData(params) {
+    this.registerTxReserve(params.txId, params.pool, params.reserve, params.userAccount, "debt");
+    const refreshCpis = await this.getRefreshCpisIfNeeded(
+      params.txId,
+      params.pool,
+      params.reserve,
+      params.userAccount
+    );
+    const details = await this.accounts.reserveInteractionDetails(
+      params.user,
+      params.pool,
+      params.reserve,
+      params.userAccount,
+      typeof params.uiAmount === "number" ? params.uiAmount : void 0
+    );
+    const farms = await this.accounts.getFarmAccounts(
+      params.pool,
+      params.reserve,
+      params.userAccount,
+      "debt"
+    );
+    const repayAmountBytes = params.full ? numToU64Bytes(U64_MAX_BN) : params.baseUnitAmount instanceof BN5 ? numToU64Bytes(params.baseUnitAmount) : details.baseUnitAmount ? numToU64Bytes(details.baseUnitAmount) : void 0;
+    return this.createSplitOperationCpiData(refreshCpis, [
+      this.getCpiData(
+        CpiTypes.K_REPAY,
+        [
+          details.signer,
+          details.obligation,
+          details.lendingMarket,
+          details.reserve,
+          details.reserveLiquidityMint,
+          details.reserveLiquiditySupply,
+          details.userLiquidityTa,
+          details.liquidityMintTokenProgram,
+          IX_SYSVAR_META,
+          farms.userFarm,
+          farms.farm,
+          details.lendingMarketAuthority,
+          details.farmsProgram
+        ],
+        repayAmountBytes,
+        void 0,
+        this.getUserAccountCacheInvalidations(params.userAccount)
+      )
+    ]);
+  }
+};
+
+// ../../shared/lending-platforms/src/data/accounts/kamino.ts
+import {
+  DEFAULT_PUBLIC_KEY as DEFAULT_PUBLIC_KEY4,
+  lendingMarketAuthPda as lendingMarketAuthPda2,
+  obligationFarmStatePda,
+  PROGRAM_ID as PROGRAM_ID4,
+  userMetadataPda as userMetadataPda3,
+  VanillaObligation as VanillaObligation3
+} from "@kamino-finance/klend-sdk";
+import { TOKEN_PROGRAM_ADDRESS as TOKEN_PROGRAM_ADDRESS2 } from "@solana-program/token";
+
+// ../../shared/lending-platforms/src/data/accounts/lpAccountsBase.ts
+var LpAccountsBase = class {
+  constructor(data) {
+    this.data = data;
+  }
+};
+
+// ../../shared/lending-platforms/src/data/accounts/kamino.ts
+var KaminoAccounts = class extends LpAccountsBase {
+  async getUserAccountAddress(pool, user, id) {
+    const market = await this.data.fetchMarket(pool);
+    const obligationType = new VanillaObligation3(market.programId, id);
+    return await obligationType.toPda(pool, user);
+  }
+  async getUserMetadataAddress(user) {
+    return (await userMetadataPda3(user, PROGRAM_ID4))[0];
+  }
+  /**
+   * Gets the obligation farm accounts for a reserve.
+   */
+  async getFarmAccounts(pool, reserve, obligation, farmMode) {
+    const emptyFarms = {
+      userFarm: toCustomAccountMeta(PROGRAM_ID4),
+      farm: toCustomAccountMeta(PROGRAM_ID4)
+    };
+    const reserveData = await this.data.fetchReserve(pool, reserve);
+    if (!reserveData) {
+      return emptyFarms;
+    }
+    const farmAddress = farmMode === "collateral" ? reserveData.rawData.state.farmCollateral : reserveData.rawData.state.farmDebt;
+    if (!farmAddress || farmAddress === DEFAULT_PUBLIC_KEY4) {
+      return emptyFarms;
+    }
+    const obligationFarmUserState = await obligationFarmStatePda(farmAddress, obligation);
+    return {
+      userFarm: toCustomAccountMeta(obligationFarmUserState, true),
+      farm: toCustomAccountMeta(farmAddress, true)
+    };
+  }
+  /**
+   * Returns the obligationFarmUserState PDA addresses for all active farms
+   * (collateral and debt) on a reserve. The farm addresses themselves live on
+   * the Kamino LUTs; only the user-specific state needs the per-token LUT.
+   */
+  async getUserFarmAddresses(pool, reserve, obligation) {
+    const addresses = [];
+    for (const mode of ["collateral", "debt"]) {
+      const { farm, userFarm } = await this.getFarmAccounts(pool, reserve, obligation, mode);
+      if (farm.address !== PROGRAM_ID4) {
+        addresses.push(userFarm.address);
+      }
+    }
+    return addresses;
+  }
+  /**
+   * Get all relevant account metas needed for interacting with the Kamino lending market.
+   */
+  async reserveInteractionDetails(user, pool, reserve, obligation, amount, baseUnitAmountOverride) {
+    const reserveData = await this.data.fetchReserve(pool, reserve);
+    const liquidityMint = reserveData.mint.mint;
+    const liquidityMintTokenProgram = reserveData.mint.mintTokenProgram;
+    const collateralMint = reserveData.rawData.state.collateral.mintPubkey;
+    const collateralMintTokenProgram = TOKEN_PROGRAM_ADDRESS2;
+    const userLiquidityTaSeeds = {
+      mint: liquidityMint,
+      owner: user,
+      tokenProgram: liquidityMintTokenProgram
+    };
+    const userLiquidityTa = await getAtaAddress(liquidityMint, user, liquidityMintTokenProgram);
+    const userCollateralTaSeeds = {
+      mint: collateralMint,
+      owner: user,
+      tokenProgram: collateralMintTokenProgram
+    };
+    const userCollateralTa = await getAtaAddress(collateralMint, user, collateralMintTokenProgram);
+    const reserveLiquiditySupply = reserveData.rawData.state.liquidity.supplyVault;
+    const reserveCollateralSupply = reserveData.rawData.state.collateral.supplyVault;
+    return {
+      baseUnitAmount: baseUnitAmountOverride !== void 0 ? baseUnitAmountOverride : amount !== void 0 ? fromUiAmount(amount, reserveData.mint.mintDecimals) : void 0,
+      signer: toCustomAccountMeta(user, true),
+      obligation: obligation ? toCustomAccountMeta(obligation, true) : void 0,
+      reserve: toCustomAccountMeta(reserve, true),
+      reserveFeeVault: toCustomAccountMeta(reserveData.rawData.state.liquidity.feeVault, true),
+      reserveLiquidityMint: toCustomAccountMeta(liquidityMint),
+      reserveLiquiditySupply: toCustomAccountMeta(reserveLiquiditySupply, true),
+      reserveCollateralMint: toCustomAccountMeta(collateralMint, true),
+      reserveCollateralSupply: toCustomAccountMeta(reserveCollateralSupply, true),
+      lendingMarket: toCustomAccountMeta(pool),
+      lendingMarketAuthority: toCustomAccountMeta((await lendingMarketAuthPda2(pool))[0]),
+      userLiquidityTa: toCustomAccountMeta(userLiquidityTa, true, userLiquidityTaSeeds),
+      userCollateralTa: toCustomAccountMeta(userCollateralTa, true, userCollateralTaSeeds),
+      liquidityMintTokenProgram: toCustomAccountMeta(liquidityMintTokenProgram),
+      collateralMintTokenProgram: toCustomAccountMeta(collateralMintTokenProgram),
+      farmsProgram: toCustomAccountMeta(KAMINO_FARMS_PROGRAM_ID)
+    };
+  }
+};
+
+// ../../shared/lending-platforms/src/services/flashLoan/kamino.ts
+import { BN as BN6 } from "@anchor-lang/core";
+import Decimal5 from "decimal.js";
+import { none } from "@solana/kit";
+import {
+  getBorrowFlashLoanInstruction,
+  getRepayFlashLoanInstruction,
+  lendingMarketAuthPda as lendingMarketAuthPda3,
+  PROGRAM_ID as PROGRAM_ID5
+} from "@kamino-finance/klend-sdk";
+
+// ../../shared/lending-platforms/src/services/flashLoan/flashLoanBase.ts
+var FlashLoanBase = class {
+  constructor(data) {
+    this.data = data;
+  }
+};
+
+// ../../shared/lending-platforms/src/services/flashLoan/kamino.ts
+function stripAccountSigners(ix) {
+  if (!ix.accounts) return ix;
+  return {
+    ...ix,
+    accounts: ix.accounts.map((account) => {
+      if (!("signer" in account)) return account;
+      const { signer: _signer, ...rest } = account;
+      return rest;
+    })
+  };
+}
+var KaminoFlashLoan = class extends FlashLoanBase {
+  async getFlashBorrowIx(params) {
+    const { reserve, lendingMarketAuthority, destinationAta } = await this.resolveSharedAccounts(params);
+    return stripAccountSigners(
+      getBorrowFlashLoanInstruction({
+        userTransferAuthority: createSignerFromAddress(params.user),
+        lendingMarketAuthority,
+        lendingMarketAddress: params.pool,
+        reserve: reserve.rawData,
+        amountLamports: new Decimal5(params.amountBaseUnits.toString()),
+        destinationAta,
+        referrerAccount: none(),
+        referrerTokenState: none(),
+        programId: PROGRAM_ID5
+      })
+    );
+  }
+  async getAvailableFlashBorrowAmount(pool, reserve) {
+    const reserveData = await this.data.fetchReserve(pool, reserve);
+    return new BN6(reserveData.rawData.getLiquidityAvailableAmount().toFixed(0));
+  }
+  async getFlashLoanFeeRate(pool, reserve) {
+    const reserveData = await this.data.fetchReserve(pool, reserve);
+    return reserveData.config.flashLoanFeePct;
+  }
+  async getFlashRepayIx(params) {
+    const { reserve, lendingMarketAuthority, destinationAta } = await this.resolveSharedAccounts(params);
+    return stripAccountSigners(
+      getRepayFlashLoanInstruction({
+        borrowIxIndex: params.borrowIxIndex,
+        userTransferAuthority: createSignerFromAddress(params.user),
+        lendingMarketAuthority,
+        lendingMarketAddress: params.pool,
+        reserve: reserve.rawData,
+        amountLamports: new Decimal5(params.amountBaseUnits.toString()),
+        userSourceLiquidity: params.userSourceLiquidity ?? destinationAta,
+        referrerAccount: none(),
+        referrerTokenState: none(),
+        programId: PROGRAM_ID5
+      })
+    );
+  }
+  async resolveSharedAccounts(params) {
+    const reserve = await this.data.fetchReserve(params.pool, params.reserve);
+    const [lendingMarketAuthority] = await lendingMarketAuthPda3(params.pool);
+    const liquidityMint = reserve.mint.mint;
+    const tokenProgram = mints.get(liquidityMint)?.tokenProgram;
+    if (!tokenProgram) {
+      throw new Error(`Unsupported liquidity mint for flash loan: ${liquidityMint}`);
+    }
+    const destinationAta = params.destinationAta ?? await getAtaAddress(liquidityMint, params.user, tokenProgram);
+    return { reserve, lendingMarketAuthority, destinationAta };
+  }
+};
+
+// ../../shared/lending-platforms/src/services/client/kamino.ts
+var KaminoClient = class extends LendingPlatformClientBase {
+  constructor(rpcUrl = getRpcUrl(ENVIRONMENT), rpcUrls = [rpcUrl]) {
+    super(rpcUrl, rpcUrls);
+    this.data = new KaminoData(rpcUrl, void 0, rpcUrls);
+    this.accounts = new KaminoAccounts(this.data);
+    this.ix = new KaminoInstructions(this.rpc, rpcUrl, this.data, this.accounts);
+  }
+  async refreshData(pools) {
+    this.data.clearCache();
+    await this.data.load(pools);
+  }
+  getFlashLoan() {
+    return new KaminoFlashLoan(this.data);
+  }
+  /**
+   * Kamino's `RepayObligationLiquidityV2` interprets `u64::MAX` as "repay
+   * the obligation's full debt for this reserve" — letting the on-chain
+   * handler clear interest-accrual dust between the off-chain quote and
+   * settlement. The flash-borrow over-borrows by a slippage buffer to fund
+   * this; the post-repay surplus is swept into the yielding bank.
+   */
+  getRepayAllSentinel() {
+    return U64_MAX_BN;
+  }
+  async getAvailableUserAccountId(pool, user, excludeUserAccounts = []) {
+    const positions = await this.data.fetchAllUserPositionsForUserInPool(pool, user);
+    const positionsByAddress = new Map(positions.map((position) => [position.address, position]));
+    const excludeSet = new Set(excludeUserAccounts);
+    for (let userAccountId = 0; ; userAccountId++) {
+      const userAccount = await this.accounts.getUserAccountAddress(pool, user, userAccountId);
+      if (excludeSet.has(userAccount)) {
+        continue;
+      }
+      const existingPosition = positionsByAddress.get(userAccount);
+      if (!existingPosition || this.isInactiveUserAccount(existingPosition)) {
+        return userAccountId;
+      }
+    }
+  }
+  /**
+   * Returns claimable rewards across all kamino farms tied to this obligation:
+   *
+   *   - **Obligation farms** (klend reserve `farmCollateral`/`farmDebt`):
+   *     UserState.owner = obligation owner (the lyc-token PDA),
+   *     UserState.delegatee = the obligation itself.
+   *   - **Direct/extra farms** (e.g. paired-reserve incentives): the lyc-token
+   *     PDA stakes directly in the farms program.
+   *     UserState.owner = UserState.delegatee = lyc-token PDA.
+   *
+   * The farms SDK filters UserStates by memcmp against `owner` (offset 48),
+   * so we query by the obligation's owner and then accept any UserState whose
+   * `delegatee` is either the obligation or the owner itself. In both cases
+   * `userFarm.userStateAddress` is the correct UserState account for the
+   * `HarvestReward` CPI; deriving via `obligationFarmStatePda` would be wrong
+   * for direct farms (different seed scheme).
+   */
+  async getOutstandingIncentives(userAccount, minUiAmount = 0, log) {
+    const obligationOwner = await this.fetchObligationOwner(userAccount);
+    if (!obligationOwner) {
+      log?.(`  [getOutstandingIncentives] no obligation owner found for ${userAccount}`);
+      return [];
+    }
+    const allOwnerFarms = await this.data.fetchUserActiveIncentives(obligationOwner);
+    log?.(
+      `  [getOutstandingIncentives] found ${allOwnerFarms.length} farm(s) owned by ${obligationOwner.slice(0, 6)}\u2026`
+    );
+    const userFarms = allOwnerFarms.filter(
+      (uf) => uf.userState.delegatee === userAccount || uf.userState.delegatee === obligationOwner
+    );
+    const filteredOut = allOwnerFarms.length - userFarms.length;
+    if (filteredOut > 0) {
+      log?.(
+        `  [getOutstandingIncentives] ${filteredOut} farm(s) skipped \u2014 delegatee matched neither userAccount (${userAccount.slice(0, 6)}\u2026) nor owner`
+      );
+    }
+    if (userFarms.length === 0) {
+      log?.(`  [getOutstandingIncentives] no matching farms for userAccount`);
+      return [];
+    }
+    const farmStates = await this.data.fetchFarms(userFarms.map((uf) => uf.farm));
+    const decimalsByFarmAndMint = /* @__PURE__ */ new Map();
+    farmStates.forEach((farmState, i) => {
+      const farm = userFarms[i].farm;
+      for (const rewardInfo of farmState.rewardInfos) {
+        decimalsByFarmAndMint.set(
+          `${farm}:${rewardInfo.token.mint}`,
+          rewardInfo.token.decimals.toNumber()
+        );
+      }
+    });
+    const incentives = [];
+    for (const userFarm of userFarms) {
+      log?.(
+        `  [getOutstandingIncentives] farm ${userFarm.farm.slice(0, 6)}\u2026  userFarm ${userFarm.userStateAddress.slice(0, 6)}\u2026  delegatee ${userFarm.userState.delegatee.slice(0, 6)}\u2026  ${userFarm.pendingRewards.length} pending reward(s)`
+      );
+      for (const reward of userFarm.pendingRewards) {
+        const amount = reward.cumulatedPendingRewards.toNumber();
+        const decimals = decimalsByFarmAndMint.get(`${userFarm.farm}:${reward.rewardTokenMint}`) ?? 0;
+        const uiAmount = amount / 10 ** decimals;
+        if (amount <= 0) {
+          log?.(`    reward ${reward.rewardTokenMint.slice(0, 6)}\u2026 \u2014 skipped (amount=0)`);
+          continue;
+        }
+        if (uiAmount < minUiAmount) {
+          log?.(
+            `    reward ${reward.rewardTokenMint.slice(0, 6)}\u2026 \u2014 skipped (uiAmount=${uiAmount.toFixed(4)} < minUiAmount=${minUiAmount})`
+          );
+          continue;
+        }
+        log?.(
+          `    reward ${reward.rewardTokenMint.slice(0, 6)}\u2026 \u2014 claimable uiAmount=${uiAmount.toFixed(4)}`
+        );
+        incentives.push({
+          mint: reward.rewardTokenMint,
+          amount,
+          decimals,
+          uiAmount,
+          claimAccounts: {
+            farm: userFarm.farm,
+            userFarm: userFarm.userStateAddress
+          }
+        });
+      }
+    }
+    return incentives;
+  }
+  /**
+   * Reads the klend obligation account and returns its `owner` field (the
+   * authority that opened the obligation — for LYC this is the lyc-token PDA).
+   * Returns null when the account doesn't exist on-chain (stale protocolUserAcc).
+   */
+  async fetchObligationOwner(userAccount) {
+    const obligation = await Obligation.fetch(this.rpc, userAccount);
+    return obligation ? obligation.owner : null;
+  }
+  isInactiveUserAccount(position) {
+    return [...position.deposits, ...position.borrows].every((entry) => entry.amount.isZero());
+  }
+};
+
+// ../../shared/lending-platforms/src/services/leverage/leverageService.ts
+import { BN as BN8 } from "@anchor-lang/core";
+
+// ../../shared/jupiter-helpers/src/constants.ts
+import { address as address3 } from "@solana/kit";
+var JUPITER_V6_PROGRAM_ID = address3(
+  "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"
+);
+var JUPITER_API_URL = "https://lite-api.jup.ag";
+var DEFAULT_SLIPPAGE_BPS = 500;
+var LOCAL_TEST_MAX_ACCOUNTS = 20;
+var LOCAL_TEST_EXCLUDED_DEXES = ["GoonFi", "HumidiFi", "TesseraV", "1DEX", "Aquifer"];
+var ALWAYS_EXCLUDED_DEXES = ["Riptide"];
+
+// ../../shared/jupiter-helpers/src/api.ts
+import { getBase64Encoder, getTransactionDecoder } from "@solana/kit";
+import { createJupiterApiClient } from "@jup-ag/api";
+async function getJupiterQuote(params) {
+  const jupiterApi = createJupiterApiClient({ basePath: JUPITER_API_URL });
+  const amount = typeof params.amount === "bigint" ? Number(params.amount) : params.amount;
+  const request = {
+    inputMint: params.inputMint,
+    outputMint: params.outputMint,
+    amount,
+    slippageBps: params.slippageBps ?? DEFAULT_SLIPPAGE_BPS,
+    swapMode: params.swapMode,
+    maxAccounts: params.maxAccounts,
+    dexes: params.dexes,
+    // When `dexes` is set it acts as a whitelist and `excludeDexes` is irrelevant.
+    // Otherwise the caller's exclusions are merged with the global list.
+    excludeDexes: params.dexes ? void 0 : [.../* @__PURE__ */ new Set([...ALWAYS_EXCLUDED_DEXES, ...params.excludeDexes ?? []])],
+    onlyDirectRoutes: params.onlyDirectRoutes
+  };
+  try {
+    return await jupiterApi.quoteGet(request);
+  } catch (err) {
+    throw await enrichJupiterHttpError(err, request);
+  }
+}
+async function enrichJupiterHttpError(err, request) {
+  if (!(err instanceof Error) || !("response" in err)) {
+    return err instanceof Error ? err : new Error(String(err));
+  }
+  const res = err.response;
+  if (!res || res.ok || typeof res.text !== "function") {
+    return err;
+  }
+  let body = "";
+  try {
+    body = (await res.text()).slice(0, 2e3);
+  } catch {
+    body = "<failed to read response body>";
+  }
+  return new Error(
+    `Jupiter quoteGet http=${res.status} ${res.statusText} request=${JSON.stringify(request)} body=${body} (was: ${err.message})`
+  );
+}
+async function buildJupiterSwapTransaction(params) {
+  const jupiterApi = createJupiterApiClient({ basePath: JUPITER_API_URL });
+  const swapResult = await jupiterApi.swapPost({
+    swapRequest: {
+      quoteResponse: params.quote,
+      userPublicKey: params.userPublicKey,
+      wrapAndUnwrapSol: params.wrapAndUnwrapSol ?? false,
+      // Default false for CPI
+      dynamicComputeUnitLimit: params.dynamicComputeUnitLimit ?? true
+    }
+  });
+  const base64Encoder = getBase64Encoder();
+  const transactionBytes = base64Encoder.encode(swapResult.swapTransaction);
+  const transactionDecoder = getTransactionDecoder();
+  return transactionDecoder.decode(transactionBytes);
+}
+
+// ../../shared/jupiter-helpers/src/extract.ts
+import {
+  decompileTransactionMessageFetchingLookupTables,
+  getCompiledTransactionMessageDecoder
+} from "@solana/kit";
+async function extractJupiterInstruction(transaction, rpc, jupiterProgramId = JUPITER_V6_PROGRAM_ID) {
+  const messageDecoder = getCompiledTransactionMessageDecoder();
+  const compiledMessage = messageDecoder.decode(transaction.messageBytes);
+  const lookupTables = ("addressTableLookups" in compiledMessage ? compiledMessage.addressTableLookups ?? [] : []).map((lookup) => lookup.lookupTableAddress);
+  const decompiledMessage = await decompileTransactionMessageFetchingLookupTables(
+    compiledMessage,
+    rpc
+  );
+  const jupiterIx = decompiledMessage.instructions.find(
+    (ix) => ix.programAddress === jupiterProgramId
+  );
+  if (!jupiterIx) {
+    throw new Error("Jupiter instruction not found in transaction");
+  }
+  const accounts = (jupiterIx.accounts ?? []).map(
+    (account) => ({
+      address: account.address,
+      role: account.role
+    })
+  );
+  return {
+    data: new Uint8Array(jupiterIx.data ?? []),
+    accounts,
+    lookupTables
+  };
+}
+
+// ../../shared/jupiter-helpers/src/routePreInstructions.ts
+async function getJupiterRoutePreInstructions(rpc, quote, user, payer) {
+  const intermediate = /* @__PURE__ */ new Set();
+  for (const step of quote.routePlan ?? []) {
+    intermediate.add(step.swapInfo.inputMint);
+    intermediate.add(step.swapInfo.outputMint);
+  }
+  intermediate.delete(quote.inputMint);
+  intermediate.delete(quote.outputMint);
+  if (!intermediate.size) {
+    return { instructions: [], postSuccessCacheInvalidations: [] };
+  }
+  const tokenProgramByMint = /* @__PURE__ */ new Map();
+  const unknown = [];
+  for (const mint of intermediate) {
+    const info = mints.get(mint);
+    if (info) {
+      tokenProgramByMint.set(mint, info.tokenProgram);
+    } else {
+      unknown.push(mint);
+    }
+  }
+  if (unknown.length) {
+    const resp = await rpc.getMultipleAccounts(unknown, { encoding: "base64" }).send();
+    for (let i = 0; i < unknown.length; i += 1) {
+      const acct = resp.value[i];
+      if (!acct) {
+        throw new Error(
+          `getJupiterRoutePreInstructions: route mint ${unknown[i]} not found on-chain`
+        );
+      }
+      tokenProgramByMint.set(unknown[i], acct.owner);
+    }
+  }
+  const instructions = [];
+  const postSuccessCacheInvalidations = [];
+  for (const mint of intermediate) {
+    const tokenProgram = tokenProgramByMint.get(mint);
+    const result = await getCreateAtaIxIfNeeded(rpc, payer, mint, user, tokenProgram);
+    if (result.instruction) {
+      instructions.push(result.instruction);
+      postSuccessCacheInvalidations.push(...result.postSuccessCacheInvalidations);
+    }
+  }
+  return { instructions, postSuccessCacheInvalidations };
+}
+
+// ../../shared/jupiter-helpers/src/client.ts
+var JupiterSwapClient = class {
+  /**
+   * Creates a new Jupiter swap client.
+   *
+   * @param rpc - Solana RPC client for resolving address lookup tables
+   * @param config - Optional default quote policy applied to every Jupiter quote
+   */
+  constructor(rpc, config = {}) {
+    this.rpc = rpc;
+    this.config = config;
+    /**
+     * Empty lists mean any route for aggregate routing (Jupiter quotes arbitrary
+     * pairs via the API).
+     */
+    this.inputMints = [];
+    this.outputMints = [];
+    this.routeAnchorMints = [];
+  }
+  /**
+   * Get a swap quote from Jupiter.
+   *
+   * @param params - Quote parameters
+   * @returns Normalized swap quote with Jupiter's QuoteResponse as rawQuote
+   */
+  async getQuote(params) {
+    const excludeDexes = params.excludeDexes?.length ? [.../* @__PURE__ */ new Set([...this.config.quoteDefaults?.excludeDexes ?? [], ...params.excludeDexes])] : void 0;
+    const rawQuote = await getJupiterQuote({
+      ...this.config.quoteDefaults ?? {},
+      inputMint: params.inputMint,
+      outputMint: params.outputMint,
+      amount: params.amount,
+      slippageBps: params.slippageBps,
+      ...params.maxAccounts !== void 0 ? { maxAccounts: params.maxAccounts } : {},
+      ...params.onlyDirectRoutes !== void 0 ? { onlyDirectRoutes: params.onlyDirectRoutes } : {},
+      ...excludeDexes ? { excludeDexes } : {}
+    });
+    return {
+      inputMint: params.inputMint,
+      outputMint: params.outputMint,
+      inputAmount: BigInt(rawQuote.inAmount),
+      outputAmount: BigInt(rawQuote.outAmount),
+      priceImpactPct: Number(rawQuote.priceImpactPct ?? 0),
+      rawQuote
+    };
+  }
+  /**
+   * Use Jupiter `ExactOut` quoting: desired output is `minOutputAmount`; reject if implied
+   * input exceeds `maxInputAmount`.
+   */
+  async getQuoteCoveringMinOutput(params) {
+    const need = params.minOutputAmount;
+    if (need <= BigInt(0)) {
+      throw new Error("getQuoteCoveringMinOutput: minOutputAmount must be positive");
+    }
+    const maxIn = params.maxInputAmount;
+    if (maxIn <= BigInt(0)) {
+      throw new Error("getQuoteCoveringMinOutput: maxInputAmount must be positive");
+    }
+    if (need > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new Error("getQuoteCoveringMinOutput: minOutputAmount exceeds Number.MAX_SAFE_INTEGER");
+    }
+    const rawQuote = await getJupiterQuote({
+      ...this.config.quoteDefaults ?? {},
+      inputMint: params.inputMint,
+      outputMint: params.outputMint,
+      amount: Number(need),
+      slippageBps: params.slippageBps,
+      swapMode: "ExactOut"
+    });
+    const inAmt = BigInt(rawQuote.inAmount);
+    const outAmt = BigInt(rawQuote.outAmount);
+    if (inAmt > maxIn) {
+      throw new Error(
+        "Jupiter getQuoteCoveringMinOutput: exact-out route needs more input than maxInputAmount"
+      );
+    }
+    if (outAmt < need) {
+      throw new Error("Jupiter getQuoteCoveringMinOutput: quoted output is below minOutputAmount");
+    }
+    return {
+      inputMint: params.inputMint,
+      outputMint: params.outputMint,
+      inputAmount: inAmt,
+      outputAmount: outAmt,
+      priceImpactPct: Number(rawQuote.priceImpactPct ?? 0),
+      rawQuote
+    };
+  }
+  /**
+   * Build Jupiter swap instruction for CPI.
+   *
+   * This fetches a swap transaction from Jupiter API, decompiles it,
+   * and extracts the instruction data and accounts needed for CPI.
+   *
+   * @param quote - Quote from getQuote()
+   * @param userPublicKey - Address executing the swap (typically a PDA)
+   * @param options - Swap options
+   * @returns Instruction data, accounts, and Jupiter program ID
+   */
+  async getSwapCpiData(quote, userPublicKey, options) {
+    const transaction = await buildJupiterSwapTransaction({
+      quote: quote.rawQuote,
+      userPublicKey,
+      wrapAndUnwrapSol: options?.wrapAndUnwrapSol ?? false
+    });
+    const { data, accounts, lookupTables } = await extractJupiterInstruction(transaction, this.rpc);
+    let preInstructions;
+    let preInvalidations;
+    if (options?.payer) {
+      const result = await getJupiterRoutePreInstructions(
+        this.rpc,
+        quote.rawQuote,
+        userPublicKey,
+        options.payer
+      );
+      if (result.instructions.length) {
+        preInstructions = result.instructions;
+        preInvalidations = result.postSuccessCacheInvalidations;
+      }
+    }
+    return {
+      cpiType: CpiTypes.JUPITER_SWAP,
+      data,
+      accounts,
+      programId: JUPITER_V6_PROGRAM_ID,
+      lookupTables,
+      ...preInstructions ? { preInstructions } : {},
+      ...preInvalidations ? { postSuccessCacheInvalidations: preInvalidations } : {}
+    };
+  }
+};
+
+// ../../shared/jupiter-helpers/src/sizeExactInForMinOutput.ts
+var ExactInQuoteExceedsMaxInputError = class extends Error {
+  constructor(inputAmount, maxInputAmount) {
+    super(
+      `sizeExactInForMinOutput: sized input (${inputAmount}) exceeds maxInputAmount (${maxInputAmount})`
+    );
+    this.inputAmount = inputAmount;
+    this.maxInputAmount = maxInputAmount;
+    this.name = "ExactInQuoteExceedsMaxInputError";
+  }
+};
+async function sizeExactInForMinOutput(swap, params) {
+  const {
+    inputMint,
+    outputMint,
+    minOutputAmount,
+    maxInputAmount,
+    slippageBps,
+    safetyBufferBps = 0,
+    onlyDirectRoutes,
+    maxAccounts,
+    excludeDexes
+  } = params;
+  if (minOutputAmount <= 0n) {
+    throw new Error("sizeExactInForMinOutput: minOutputAmount must be positive");
+  }
+  if (maxInputAmount <= 0n) {
+    throw new Error("sizeExactInForMinOutput: maxInputAmount must be positive");
+  }
+  if (slippageBps < 0 || slippageBps >= 1e4) {
+    throw new Error("sizeExactInForMinOutput: slippageBps must be in [0, 10000)");
+  }
+  if (safetyBufferBps < 0) {
+    throw new Error("sizeExactInForMinOutput: safetyBufferBps must be non-negative");
+  }
+  if (minOutputAmount > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new Error("sizeExactInForMinOutput: minOutputAmount exceeds Number.MAX_SAFE_INTEGER");
+  }
+  const probeQuote = await swap.getQuote({
+    inputMint,
+    outputMint,
+    amount: Number(minOutputAmount),
+    slippageBps,
+    onlyDirectRoutes,
+    maxAccounts,
+    excludeDexes
+  });
+  if (probeQuote.outputAmount <= 0n || probeQuote.inputAmount <= 0n) {
+    throw new Error("sizeExactInForMinOutput: probe quote returned non-positive amounts");
+  }
+  const slippageBpsBig = BigInt(slippageBps);
+  const safetyBpsBig = BigInt(safetyBufferBps);
+  const sizingNumer = minOutputAmount * probeQuote.inputAmount * (10000n + safetyBpsBig);
+  const sizingDenom = probeQuote.outputAmount * (10000n - slippageBpsBig);
+  const inputAmount = (sizingNumer + sizingDenom - 1n) / sizingDenom;
+  if (inputAmount > maxInputAmount) {
+    throw new ExactInQuoteExceedsMaxInputError(inputAmount, maxInputAmount);
+  }
+  if (inputAmount > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new Error("sizeExactInForMinOutput: sized input exceeds Number.MAX_SAFE_INTEGER");
+  }
+  const quote = await swap.getQuote({
+    inputMint,
+    outputMint,
+    amount: Number(inputAmount),
+    slippageBps,
+    onlyDirectRoutes,
+    maxAccounts,
+    excludeDexes
+  });
+  const worstCaseOutputAmount = quote.outputAmount * (10000n - slippageBpsBig) / 10000n;
+  if (worstCaseOutputAmount < minOutputAmount) {
+    throw new Error(
+      `sizeExactInForMinOutput: real-quote worst-case output (${worstCaseOutputAmount}) does not cover minOutputAmount (${minOutputAmount}) \u2014 likely price impact at sized input diverged from probe spot rate; raise safetyBufferBps`
+    );
+  }
+  return { quote, inputAmount, worstCaseOutputAmount };
+}
+
+// ../../shared/lending-platforms/src/services/lendingPosition/lendingPositionManager.ts
+import { BN as BN7 } from "@anchor-lang/core";
+
+// ../../shared/lending-platforms/src/services/reservesManager.ts
+var ReservesManager = class {
+  constructor(supplyReserve, debtReserve, environment) {
+    this.supplyReserve = supplyReserve;
+    this.debtReserve = debtReserve;
+    this.environment = environment;
+    this.cache = new DataCache();
+  }
+  /** Max LTV ratio (0-1), using e-mode override when the pair qualifies */
+  get maxLtv() {
+    const emode = this.supplyReserve.emodes?.find(
+      (e) => e.debtReserve === this.debtReserve.address
+    );
+    return emode?.ltvPct ?? this.supplyReserve.ltvPct;
+  }
+  /**
+   * Returns supply and debt token prices.
+   * Uses reserve-embedded prices when available, otherwise fetches from oracle and caches the result.
+   */
+  async prices() {
+    const { data } = await this.cache.getDataOrThrow(
+      async () => {
+        const supplyRealtimePrice = this.supplyReserve.mintPrice;
+        const debtRealtimePrice = this.debtReserve.mintPrice;
+        const supplyEmaPrice = this.supplyReserve.mintEmaPrice;
+        const debtEmaPrice = this.debtReserve.mintEmaPrice;
+        const realtimeMintsToFetch = [
+          ...supplyRealtimePrice === void 0 ? [this.supplyReserve.mint.mint] : [],
+          ...debtRealtimePrice === void 0 ? [this.debtReserve.mint.mint] : []
+        ];
+        const emaMintsToFetch = [
+          ...supplyEmaPrice === void 0 ? [this.supplyReserve.mint.mint] : [],
+          ...debtEmaPrice === void 0 ? [this.debtReserve.mint.mint] : []
+        ];
+        const [realtime, ema] = await Promise.all([
+          realtimeMintsToFetch.length ? oracle.fetchPrices(realtimeMintsToFetch, "realtime", void 0, this.environment) : {},
+          emaMintsToFetch.length ? oracle.fetchPrices(emaMintsToFetch, "ema", void 0, this.environment) : {}
+        ]);
+        return {
+          supply: {
+            realtimePrice: supplyRealtimePrice ?? realtime[this.supplyReserve.mint.mint],
+            emaPrice: supplyEmaPrice ?? ema[this.supplyReserve.mint.mint]
+          },
+          debt: {
+            realtimePrice: debtRealtimePrice ?? realtime[this.debtReserve.mint.mint],
+            emaPrice: debtEmaPrice ?? ema[this.debtReserve.mint.mint]
+          }
+        };
+      },
+      "prices",
+      `${this.supplyReserve.mint.mint}:${this.debtReserve.mint.mint}`
+    );
+    return data;
+  }
+  /**
+   * Net APY for the lending & borrowing position.
+   * Accounts for eligible incentives based on the paired reserve relationship.
+   */
+  get netAPY() {
+    return this.supplyReserve.supplyAPY(this.debtReserve.address) - this.debtReserve.borrowAPY();
+  }
+  /**
+   * Simulates net APY after hypothetical position changes.
+   * Accounts for eligible incentives based on the paired reserve relationship.
+   */
+  simulateNetAPY(args) {
+    return this.supplyReserve.simulateNewSupplyAPY(
+      args.find((x) => Boolean(x.collateralChange)) ?? { collateralChange: 0 },
+      this.debtReserve.address
+    ) - this.debtReserve.simulateNewBorrowAPY(
+      args.find((x) => Boolean(x.debtChange)) ?? { debtChange: 0 }
+    );
+  }
+  /** Current LTV utilization rate in basis points (0-10000) given USD position values */
+  calcLtvUtilizationRateBps(supplyUsd, debtUsd) {
+    if (supplyUsd <= 0) return 0;
+    return debtUsd / (supplyUsd * this.maxLtv) * 1e4;
+  }
+  /**
+   * Calculates the USD debt adjustment needed to reach a target LTV utilization rate.
+   * Positive result = boost (increase leverage), negative = deleverage.
+   */
+  async calcDebtAdjustmentUsd(uiSupplyAmount, uiDebtAmount, targetLtvUtilizationRateBps, options = {}) {
+    const { supply: supplyPrice, debt: debtPrice } = await this.prices();
+    let supplyUsd = uiSupplyAmount * supplyPrice.realtimePrice;
+    let debtUsd = uiDebtAmount * debtPrice.realtimePrice;
+    const maxLtv = this.maxLtv;
+    const targetUtilizationRate = targetLtvUtilizationRateBps / 1e4;
+    const flFee = this.debtReserve.config.flashLoanFeePct / 100;
+    const lpBorrowFee = this.debtReserve.config.borrowFeePct / 100;
+    const positionChangeMode = options.positionChangeMode ?? "levered";
+    const currentLtvUtilizationRate = supplyUsd > 0 ? debtUsd / (supplyUsd * maxLtv) : 0;
+    const isBoost = currentLtvUtilizationRate < targetUtilizationRate;
+    if (isBoost) {
+      supplyUsd = uiSupplyAmount * (supplyPrice.emaPrice ?? supplyPrice.realtimePrice);
+      debtUsd = uiDebtAmount * (debtPrice.emaPrice ?? debtPrice.realtimePrice);
+    }
+    if (positionChangeMode === "debtOnly") {
+      const targetDebtDeltaUsd = targetUtilizationRate * maxLtv * supplyUsd - debtUsd;
+      return isBoost ? targetDebtDeltaUsd / (1 + lpBorrowFee) : targetDebtDeltaUsd;
+    }
+    return isBoost ? (targetUtilizationRate * maxLtv * supplyUsd - debtUsd) / (1 + lpBorrowFee + flFee - targetUtilizationRate * maxLtv) : (targetUtilizationRate * maxLtv * supplyUsd - debtUsd) / (1 - targetUtilizationRate * maxLtv * (1 + flFee));
+  }
+};
+
+// ../../shared/lending-platforms/src/services/lendingPosition/lendingPositionManager.ts
+var LendingPositionManager = class {
+  constructor(lpData, pool, userAccount, collateralReserve, debtReserve, environment) {
+    this.lpData = lpData;
+    this.pool = pool;
+    this.userAccount = userAccount;
+    this.reservesManager = new ReservesManager(collateralReserve, debtReserve, environment);
+  }
+  /**
+   * Calculates the UI debt amount change needed to reach the target LTV utilization
+   * rate. Positive values indicate borrowing; negative values indicate repaying.
+   */
+  async calcDebtChangeAmount(targetUtilizationRateBps) {
+    const state = await this.getPositionState("realtime");
+    if (!state) return 0;
+    return this.calcDebtChangeAmountFromState(state, targetUtilizationRateBps);
+  }
+  /**
+   * Fetch current supply and debt position amounts in UI units.
+   */
+  async getLendingPositionAmounts() {
+    const state = await this.getPositionState("realtime");
+    if (!state) return { supplyUiAmount: 0, debtUiAmount: 0 };
+    const supplyPrice = state.prices.supply.realtimePrice;
+    const debtPrice = state.prices.debt.realtimePrice;
+    return {
+      supplyUiAmount: supplyPrice > 0 ? state.supplyUsd / supplyPrice : 0,
+      debtUiAmount: debtPrice > 0 ? state.debtUsd / debtPrice : 0
+    };
+  }
+  /**
+   * Calculates the utilization rate the source position must reach before a
+   * collateral withdrawal so that, after the withdrawal, the position lands at
+   * the desired target utilization rate.
+   *
+   * Units:
+   * - current supply USD = supplied collateral before withdrawal
+   * - withdrawn USD = collateral requested for the rebalance move
+   * - post-withdraw target = desired utilization after collateral leaves the LP
+   *
+   * Formula:
+   * pre_withdraw_target = post_withdraw_target * (current_supply - withdrawn) / current_supply
+   *
+   * The result is floored to stay conservatively at or below the requested
+   * post-withdraw target once integer basis-point rounding is applied.
+   */
+  async calcPreWithdrawalTargetUtilizationRateBps(withdrawUiCollateralAmount, postWithdrawalTargetUtilizationRateBps) {
+    const state = await this.getPositionState("realtime");
+    if (!state) return 0;
+    return this.calcPreWithdrawalTargetUtilizationRateBpsFromState(
+      state,
+      withdrawUiCollateralAmount,
+      postWithdrawalTargetUtilizationRateBps
+    );
+  }
+  /**
+   * Calculates the UI debt amount change needed before a collateral withdrawal
+   * so that the position lands at the desired utilization rate after the
+   * withdrawal completes.
+   */
+  async calcDebtChangeAmountForCollateralWithdrawal(withdrawUiCollateralAmount, postWithdrawalTargetUtilizationRateBps) {
+    const state = await this.getPositionState("realtime");
+    if (!state) return 0;
+    const preWithdrawalTargetUtilizationRateBps = this.calcPreWithdrawalTargetUtilizationRateBpsFromState(
+      state,
+      withdrawUiCollateralAmount,
+      postWithdrawalTargetUtilizationRateBps
+    );
+    return this.calcDebtChangeAmountFromState(state, preWithdrawalTargetUtilizationRateBps);
+  }
+  /**
+   * Calculates the utilization rate after withdrawing collateral while leaving
+   * debt unchanged.
+   */
+  async calcPostWithdrawalUtilizationRateBps(withdrawUiCollateralAmount) {
+    const state = await this.getPositionState("realtime");
+    if (!state) return 0;
+    return this.calcPostWithdrawalUtilizationRateBpsFromState(state, withdrawUiCollateralAmount);
+  }
+  /**
+   * For burn-token liquidity management: checks that a withdrawal of
+   * `collateralWithdrawalUiAmount` (collateral mint UI units) leaves strictly
+   * positive supplied collateral, matching the pre-withdraw math used in
+   * {@link calcPreWithdrawalTargetUtilizationRateBps}.
+   *
+   * Returns realtime LTV utilization in basis points when eligible; null when the
+   * obligation is missing, has no supply, prices are invalid, or the withdrawal
+   * would consume the full (or more than the full) collateral position.
+   */
+  async getBurnUnwindEligibility(collateralWithdrawalUiAmount) {
+    if (!(collateralWithdrawalUiAmount > 0)) {
+      return null;
+    }
+    const state = await this.getPositionState("realtime");
+    if (!state) {
+      return null;
+    }
+    const collateralPrice = state.prices.supply.realtimePrice;
+    if (!(collateralPrice > 0)) {
+      return null;
+    }
+    const withdrawnCollateralUsd = collateralWithdrawalUiAmount * collateralPrice;
+    if (!(withdrawnCollateralUsd < state.supplyUsd)) {
+      return null;
+    }
+    const utilizationRateBps = this.reservesManager.calcLtvUtilizationRateBps(
+      state.supplyUsd,
+      state.debtUsd
+    );
+    return { utilizationRateBps };
+  }
+  /**
+   * Returns the collateral price levels that would place the position exactly on
+   * its lower and upper utilization trigger bands.
+   *
+   * The lower-band trigger uses EMA pricing (to mirror boost-trigger semantics),
+   * while the upper-band trigger uses realtime pricing (to mirror unwind-trigger
+   * semantics).
+   */
+  async getCollateralPriceTriggerBand(params) {
+    const [lower, upper] = await Promise.all([
+      this.getCollateralPriceTriggerLevel("ema", params.lowerTargetUtilizationRateBps),
+      this.getCollateralPriceTriggerLevel("realtime", params.upperTargetUtilizationRateBps)
+    ]);
+    return { lower, upper };
+  }
+  async getUtilizationRatesBps() {
+    const [realtimeState, emaState] = await Promise.all([
+      this.getPositionState("realtime"),
+      this.getPositionState("ema")
+    ]);
+    if (!realtimeState || !emaState) {
+      return null;
+    }
+    return {
+      realtime: this.reservesManager.calcLtvUtilizationRateBps(
+        realtimeState.supplyUsd,
+        realtimeState.debtUsd
+      ),
+      ema: this.reservesManager.calcLtvUtilizationRateBps(emaState.supplyUsd, emaState.debtUsd)
+    };
+  }
+  async getUtilizationPrices() {
+    const [realtimeState, emaState] = await Promise.all([
+      this.getPositionState("realtime"),
+      this.getPositionState("ema")
+    ]);
+    if (!realtimeState || !emaState) {
+      return null;
+    }
+    return {
+      realtime: {
+        collateral: this.selectPrice(realtimeState.prices.supply, "realtime"),
+        debt: this.selectPrice(realtimeState.prices.debt, "realtime")
+      },
+      ema: {
+        collateral: this.selectPrice(emaState.prices.supply, "ema"),
+        debt: this.selectPrice(emaState.prices.debt, "ema")
+      }
+    };
+  }
+  async getInspectMetrics(params) {
+    const [utilizationRateBps, utilizationPrices, triggerBand] = await Promise.all([
+      this.getUtilizationRatesBps(),
+      this.getUtilizationPrices(),
+      this.getCollateralPriceTriggerBand(params)
+    ]);
+    if (!utilizationRateBps || !utilizationPrices) {
+      return null;
+    }
+    return { utilizationRateBps, utilizationPrices, triggerBand };
+  }
+  async getPositionState(mode) {
+    const position = await this.lpData.maybeFetchUserPositionInPool(this.pool, this.userAccount);
+    if (!position) return null;
+    const prices = await this.reservesManager.prices();
+    const { supplyUsd, debtUsd } = this.calcPositionSupplyDebtUsd(position, prices, mode);
+    return { prices, supplyUsd, debtUsd };
+  }
+  calcPositionSupplyDebtUsd(position, prices, mode) {
+    const { supplyReserve, debtReserve } = this.reservesManager;
+    const deposit = position.deposits.find((d) => d.reserve === supplyReserve.address);
+    const borrow = position.borrows.find((b) => b.reserve === debtReserve.address);
+    const supplyAmount = deposit ? toUiAmount(deposit.amount, supplyReserve.mint.mintDecimals) : 0;
+    const debtAmount = borrow ? toUiAmount(borrow.amount, debtReserve.mint.mintDecimals) : 0;
+    return {
+      supplyUsd: supplyAmount * this.selectPrice(prices.supply, mode).value,
+      debtUsd: debtAmount * this.selectPrice(prices.debt, mode).value
+    };
+  }
+  selectPrice(price, mode) {
+    if (mode === "realtime") {
+      return { value: price.realtimePrice, source: "realtime" };
+    }
+    if (price.emaPrice != null) {
+      return { value: price.emaPrice, source: "ema" };
+    }
+    return { value: price.realtimePrice, source: "ema_fallback_realtime" };
+  }
+  async getCollateralPriceTriggerLevel(mode, targetUtilizationRateBps) {
+    this.assertValidTriggerBandUtilizationRateBps(
+      targetUtilizationRateBps,
+      "targetUtilizationRateBps"
+    );
+    if (targetUtilizationRateBps === 0) {
+      return void 0;
+    }
+    const state = await this.getPositionState(mode);
+    if (!state) {
+      return void 0;
+    }
+    const currentCollateralPrice = mode === "ema" ? state.prices.supply.emaPrice ?? state.prices.supply.realtimePrice : state.prices.supply.realtimePrice;
+    if (currentCollateralPrice <= 0 || state.debtUsd < 0 || this.reservesManager.maxLtv <= 0) {
+      return void 0;
+    }
+    const uiSupplyAmount = state.supplyUsd / currentCollateralPrice;
+    if (uiSupplyAmount <= 0) {
+      return void 0;
+    }
+    const triggerCollateralPrice = this.calcCollateralPriceForTargetUtilization(
+      state.debtUsd,
+      uiSupplyAmount,
+      targetUtilizationRateBps
+    );
+    if (!Number.isFinite(triggerCollateralPrice) || triggerCollateralPrice < 0) {
+      return void 0;
+    }
+    return {
+      currentCollateralPrice,
+      triggerCollateralPrice,
+      targetUtilizationRateBps,
+      priceMode: mode,
+      priceChangePct: (triggerCollateralPrice - currentCollateralPrice) / currentCollateralPrice * 100
+    };
+  }
+  /**
+   * Solve for collateral price at a target utilization:
+   * utilization = debtUsd / (collateralAmount * collateralPrice * maxLtv).
+   */
+  calcCollateralPriceForTargetUtilization(debtUsd, uiSupplyAmount, targetUtilizationRateBps) {
+    const targetUtilizationRate = targetUtilizationRateBps / 1e4;
+    return debtUsd / (uiSupplyAmount * this.reservesManager.maxLtv * targetUtilizationRate);
+  }
+  async calcDebtChangeAmountFromState(state, targetUtilizationRateBps) {
+    this.assertValidUtilizationRateBps(targetUtilizationRateBps, "targetUtilizationRateBps");
+    if (state.prices.debt.realtimePrice <= 0) {
+      throw new Error("Debt reserve realtime price must be positive");
+    }
+    if (state.prices.supply.realtimePrice <= 0) {
+      throw new Error("Collateral reserve realtime price must be positive");
+    }
+    const debtAdjustmentUsd = await this.reservesManager.calcDebtAdjustmentUsd(
+      state.supplyUsd / state.prices.supply.realtimePrice,
+      state.debtUsd / state.prices.debt.realtimePrice,
+      targetUtilizationRateBps,
+      { positionChangeMode: "debtOnly" }
+    );
+    const debtChangeUiAmount = debtAdjustmentUsd / state.prices.debt.realtimePrice;
+    const debtDecimals = this.reservesManager.debtReserve.mint.mintDecimals;
+    let quantizedUiAmount = this.quantizeDebtChangeUiAmount(debtChangeUiAmount, debtDecimals);
+    if (quantizedUiAmount > 0) {
+      quantizedUiAmount = await this.capPositiveBorrowToProtocolHeadroom(quantizedUiAmount, state);
+    }
+    return debtChangeUiAmount < 0 ? -quantizedUiAmount : quantizedUiAmount;
+  }
+  /**
+   * Quantize to the debt mint's base-unit precision. Borrows floor; repays round
+   * away from zero so deleveraging does not undershoot.
+   */
+  quantizeDebtChangeUiAmount(debtChangeUiAmount, debtDecimals) {
+    if (debtChangeUiAmount === 0) return 0;
+    const absUi = Math.abs(debtChangeUiAmount);
+    if (debtChangeUiAmount > 0) {
+      if (!(absUi > 0)) return 0;
+      const flooredBaseUnits = new BN7(Math.floor(absUi * Math.pow(10, debtDecimals)));
+      return toUiAmount(flooredBaseUnits, debtDecimals);
+    }
+    const roundedAmount = fromUiAmount(absUi, debtDecimals);
+    let repayUi = toUiAmount(roundedAmount, debtDecimals);
+    if (repayUi < absUi) {
+      repayUi = toUiAmount(roundedAmount.addn(1), debtDecimals);
+    }
+    return repayUi;
+  }
+  /** Cap positive borrows to obligation headroom when the platform exposes it. */
+  async capPositiveBorrowToProtocolHeadroom(requestedUiAmount, state) {
+    const debtDecimals = this.reservesManager.debtReserve.mint.mintDecimals;
+    const position = await this.lpData.maybeFetchUserPositionInPool(this.pool, this.userAccount);
+    if (!position) {
+      return requestedUiAmount;
+    }
+    const maxUi = position.getMaxAdditionalBorrowUiAmount(
+      state.prices.debt.realtimePrice,
+      debtDecimals
+    );
+    if (maxUi === void 0) {
+      return requestedUiAmount;
+    }
+    return Math.min(requestedUiAmount, maxUi);
+  }
+  calcPreWithdrawalTargetUtilizationRateBpsFromState(state, withdrawUiCollateralAmount, postWithdrawalTargetUtilizationRateBps) {
+    if (withdrawUiCollateralAmount <= 0) {
+      throw new Error("withdrawUiCollateralAmount must be greater than zero");
+    }
+    this.assertValidUtilizationRateBps(
+      postWithdrawalTargetUtilizationRateBps,
+      "postWithdrawalTargetUtilizationRateBps"
+    );
+    const collateralPrice = state.prices.supply.realtimePrice;
+    if (collateralPrice <= 0) {
+      throw new Error("Collateral reserve realtime price must be positive");
+    }
+    const withdrawnCollateralUsd = withdrawUiCollateralAmount * collateralPrice;
+    if (withdrawnCollateralUsd >= state.supplyUsd) {
+      throw new Error("withdrawUiCollateralAmount exceeds the current supplied collateral");
+    }
+    const preWithdrawalTargetUtilizationRateBps = Math.floor(
+      postWithdrawalTargetUtilizationRateBps * (state.supplyUsd - withdrawnCollateralUsd) / state.supplyUsd
+    );
+    return Math.max(
+      0,
+      Math.min(postWithdrawalTargetUtilizationRateBps, preWithdrawalTargetUtilizationRateBps)
+    );
+  }
+  calcPostWithdrawalUtilizationRateBpsFromState(state, withdrawUiCollateralAmount) {
+    if (withdrawUiCollateralAmount <= 0) {
+      throw new Error("withdrawUiCollateralAmount must be greater than zero");
+    }
+    const collateralPrice = state.prices.supply.realtimePrice;
+    if (collateralPrice <= 0) {
+      throw new Error("Collateral reserve realtime price must be positive");
+    }
+    const withdrawnCollateralUsd = withdrawUiCollateralAmount * collateralPrice;
+    if (withdrawnCollateralUsd >= state.supplyUsd) {
+      throw new Error("withdrawUiCollateralAmount exceeds the current supplied collateral");
+    }
+    return this.reservesManager.calcLtvUtilizationRateBps(
+      state.supplyUsd - withdrawnCollateralUsd,
+      state.debtUsd
+    );
+  }
+  assertValidUtilizationRateBps(value, field) {
+    if (!Number.isFinite(value) || value < 0 || value > 1e4) {
+      throw new Error(`${field} must be between 0 and 10000`);
+    }
+  }
+  /**
+   * Unwind/boost trigger bands may exceed 100% LTV utilization (up to 10_500 bps
+   * on-chain). Debt-sizing paths still use {@link assertValidUtilizationRateBps}.
+   */
+  assertValidTriggerBandUtilizationRateBps(value, field) {
+    if (!Number.isFinite(value) || value < 0 || value > MAX_LENDING_POSITION_UPPER_UTIL_BPS) {
+      throw new Error(`${field} must be between 0 and ${MAX_LENDING_POSITION_UPPER_UTIL_BPS}`);
+    }
+  }
+};
+
+// ../../shared/lending-platforms/src/services/leverage/leverageService.ts
+var DECREASE_LEVERAGE_SWAP_BUFFER_BPS = 5;
+var DECREASE_LEVERAGE_SWAP_SLIPPAGE_BPS = 40;
+var DECREASE_LEVERAGE_SWAP_MAX_ACCOUNTS = 30;
+var FLASH_REBALANCE_SWAP_MAX_ACCOUNTS = 25;
+var FlashRebalanceSwapCostExceededError = class extends Error {
+  constructor(reason, executionCostBps, marketBasisBps, limitBps, inputAmount, outputAmount) {
+    super(
+      `LeverageService.buildFlashRebalance: swap ${reason} exceeds ${limitBps} bps (execution cost ${executionCostBps.toFixed(2)} bps, market basis ${marketBasisBps.toFixed(2)} bps, in=${inputAmount} out=${outputAmount})`
+    );
+    this.reason = reason;
+    this.executionCostBps = executionCostBps;
+    this.marketBasisBps = marketBasisBps;
+    this.limitBps = limitBps;
+    this.inputAmount = inputAmount;
+    this.outputAmount = outputAmount;
+    this.name = "FlashRebalanceSwapCostExceededError";
+  }
+};
+var LeverageService = class {
+  /**
+   * Calculate the borrow amount needed to reach the target utilization rate,
+   * then build the borrow CPIs.
+   */
+  static async buildIncreaseLeverage(ctx, params) {
+    const reserves = new ReservesManager(ctx.supplyReserve, ctx.debtReserve, ctx.environment);
+    const mode = params.mode ?? "debtOnly";
+    const debtAdjustmentUsd = await reserves.calcDebtAdjustmentUsd(
+      params.currentSupplyUiAmount,
+      params.currentDebtUiAmount,
+      params.targetUtilizationRateBps,
+      { positionChangeMode: mode }
+    );
+    const prices = await reserves.prices();
+    const borrowUiAmount = Math.abs(debtAdjustmentUsd / prices.debt.realtimePrice);
+    const borrowBaseUnits = fromUiAmount(borrowUiAmount, ctx.debtReserve.mint.mintDecimals);
+    const { prerequisiteCpis, cpis, postSuccessCacheInvalidations } = await ctx.lendingIx.getBorrowCpiBundle({
+      user: ctx.user,
+      payer: ctx.payer,
+      pool: ctx.pool,
+      reserve: ctx.debtReserve.address,
+      userAccount: ctx.userAccount,
+      uiAmount: borrowUiAmount,
+      txId: ctx.txId
+    });
+    const preInstructions = await ctx.lendingIx.getPreInstructions(ctx.txId);
+    return {
+      borrowUiAmount,
+      borrowBaseUnits,
+      prerequisiteCpis,
+      borrowCpis: cpis,
+      preInstructions,
+      postSuccessCacheInvalidations
+    };
+  }
+  /**
+   * Calculate the repay amount needed to reach the target utilization rate,
+   * build the repay CPIs, and assemble CPI groups with an optional swap
+   * prepended when the caller's debt-token balance is insufficient.
+   *
+   * The returned `repayUiAmount` is always non-negative. When the position is
+   * already at or below the target, the amount is zero and the CPI list is
+   * sized for a zero repay.
+   */
+  static async buildDecreaseLeverage(ctx, params) {
+    const reserves = new ReservesManager(ctx.supplyReserve, ctx.debtReserve, ctx.environment);
+    const mode = params.mode ?? "debtOnly";
+    const debtAdjustmentUsd = await reserves.calcDebtAdjustmentUsd(
+      params.currentSupplyUiAmount,
+      params.currentDebtUiAmount,
+      params.targetUtilizationRateBps,
+      { positionChangeMode: mode }
+    );
+    const prices = await reserves.prices();
+    const debtDecimals = ctx.debtReserve.mint.mintDecimals;
+    const repayUiAmount = Math.abs(debtAdjustmentUsd / prices.debt.realtimePrice);
+    const calculatedRepayBaseUnits = fromUiAmount(repayUiAmount, debtDecimals);
+    const repayBaseUnits = params.repayBaseUnitsOverride ?? calculatedRepayBaseUnits;
+    const { prerequisiteCpis, cpis } = await ctx.lendingIx.getRepayCpiData({
+      user: ctx.user,
+      payer: ctx.payer,
+      pool: ctx.pool,
+      reserve: ctx.debtReserve.address,
+      userAccount: ctx.userAccount,
+      txId: ctx.txId,
+      ...params.repayBaseUnitsOverride ? { baseUnitAmount: repayBaseUnits } : {}
+    });
+    const preInstructions = await ctx.lendingIx.getPreInstructions(ctx.txId);
+    const swapRequired = params.swapContext !== void 0;
+    const assembledCpis = await this.assembleDecreaseLeverageCpis(
+      repayBaseUnits,
+      cpis,
+      params.swapContext
+    );
+    return {
+      repayUiAmount,
+      repayBaseUnits,
+      prerequisiteCpis,
+      repayCpis: cpis,
+      cpiDataGroups: assembledCpis.cpiDataGroups,
+      swapRequired,
+      preInstructions: [...preInstructions, ...assembledCpis.preInstructions]
+    };
+  }
+  /**
+   * Assemble repay CPI groups, prepending a swap group whenever the bank is
+   * configured to source the debt mint via a swap. The on-chain handler
+   * decides whether to actually invoke the swap (via `perform_swap`) based on
+   * runtime balances; building it unconditionally keeps the tx resilient when
+   * the bank's debt-token balance changes between build and send.
+   */
+  static async assembleDecreaseLeverageCpis(repayBaseUnits, repayCpis, swapContext) {
+    if (!swapContext) {
+      return { cpiDataGroups: [repayCpis], preInstructions: [] };
+    }
+    const swapCpiData = await this.quoteDebtTopUpSwap(swapContext, repayBaseUnits);
+    return {
+      cpiDataGroups: [[swapCpiData], repayCpis],
+      preInstructions: swapCpiData.preInstructions ?? []
+    };
+  }
+  /**
+   * Quote a swap that converts a source asset into the debt mint,
+   * covering at least `shortfall` base units.
+   */
+  static async quoteDebtTopUpSwap(ctx, shortfall) {
+    const need = BigInt(shortfall.toString());
+    if (need <= 0n) {
+      throw new Error("LeverageService.quoteDebtTopUpSwap: shortfall must be positive");
+    }
+    if (ctx.sourceBalanceBaseUnits <= 0n) {
+      throw new Error("LeverageService.quoteDebtTopUpSwap: source balance is zero");
+    }
+    const { quote } = await sizeExactInForMinOutput(ctx.swap, {
+      inputMint: ctx.sourceMint,
+      outputMint: ctx.debtMint,
+      minOutputAmount: need,
+      maxInputAmount: ctx.sourceBalanceBaseUnits,
+      slippageBps: ctx.slippageBps ?? DECREASE_LEVERAGE_SWAP_SLIPPAGE_BPS,
+      safetyBufferBps: DECREASE_LEVERAGE_SWAP_BUFFER_BPS,
+      maxAccounts: DECREASE_LEVERAGE_SWAP_MAX_ACCOUNTS,
+      excludeDexes: ctx.excludeDexes
+    });
+    return ctx.swap.getSwapCpiData(quote, ctx.swapTarget, { payer: ctx.payer });
+  }
+  /**
+   * Build a flash-loan-wrapped rebalance that moves collateral between two
+   * lending positions without decreasing any carry positions.
+   *
+   * The flow assembled here (inside a single transaction):
+   *   1. Top-level: flash-borrow source debt mint into the user's ATA.
+   *   2. CPI: repay flash-borrowed amount on source → frees collateral.
+   *   3. CPI: withdraw `collateralUiAmount` from source.
+   *   4. CPI: deposit that collateral on destination.
+   *   5. CPI: borrow destination debt mint (sized slightly above the swap
+   *      input needed to produce the flash repay, so post-slippage output
+   *      still covers it).
+   *   6. CPI: exact-in swap destination debt → source debt; the entire borrow
+   *      is consumed and worst-case output is at least the flash repay amount.
+   *   7. Top-level: flash-repay source debt mint.
+   *
+   * The exact-in over-borrow leaves a small **source-debt** excess in the
+   * token PDA's ATA after the swap; the on-chain handler sweeps this excess
+   * into the yielding bank before the top-level flash repay so exactly
+   * `flashRepayAmountBaseUnits` remains for the repay.
+   */
+  static async buildFlashRebalance(ctx, params) {
+    if (ctx.source.debtReserve.mint.mint === ctx.destination.debtReserve.mint.mint) {
+      throw new Error(
+        "LeverageService.buildFlashRebalance: source and destination debt mints must differ"
+      );
+    }
+    const sourceDebtMint = ctx.source.debtReserve.address;
+    const sourceDebtLiqMint = ctx.source.debtReserve.mint.mint;
+    const sourceDebtDecimals = ctx.source.debtReserve.mint.mintDecimals;
+    const destDebtLiqMint = ctx.destination.debtReserve.mint.mint;
+    const destDebtDecimals = ctx.destination.debtReserve.mint.mintDecimals;
+    const sourceRepayBaseUnits = await this.calcSourceRepayForWithdraw(ctx, params);
+    if (sourceRepayBaseUnits.lten(0)) {
+      throw new Error(
+        "LeverageService.buildFlashRebalance: source repay amount must be positive \u2014 use the simple rebalance path when no flash loan is needed"
+      );
+    }
+    const sourceRepayUiAmount = toUiAmount(sourceRepayBaseUnits, sourceDebtDecimals);
+    const flashFeeRate = await ctx.flashLoan.getFlashLoanFeeRate(ctx.source.pool, sourceDebtMint);
+    const SOURCE_REPAY_OVERBORROW_BPS = 5n;
+    const sourceRepayBigInt = BigInt(sourceRepayBaseUnits.toString());
+    const flashBorrowBigInt = params.withdrawAll ? sourceRepayBigInt + sourceRepayBigInt * SOURCE_REPAY_OVERBORROW_BPS / 10000n : sourceRepayBigInt;
+    const flashFeeBigInt = applyFeeCeil(flashBorrowBigInt, flashFeeRate);
+    const flashRepayBigInt = flashBorrowBigInt + flashFeeBigInt;
+    const flashBorrowAmountBaseUnits = new BN8(flashBorrowBigInt.toString());
+    const flashFeeBaseUnits = new BN8(flashFeeBigInt.toString());
+    const flashRepayAmountBaseUnits = new BN8(flashRepayBigInt.toString());
+    const reserveBorrowCapacityBaseUnits = BigInt(
+      fromUiAmount(
+        ctx.destination.debtReserve.borrows.limit - ctx.destination.debtReserve.borrows.totalAmount,
+        destDebtDecimals
+      ).toString()
+    );
+    const utilizationBorrowCapacityBaseUnits = await this.calcDestinationBorrowCapacityForDeposit(
+      ctx,
+      { ...params, collateralUiAmount: 0 }
+    );
+    const maxDestinationBorrowBaseUnits = [
+      params.maxDestinationBorrowBaseUnits,
+      reserveBorrowCapacityBaseUnits,
+      utilizationBorrowCapacityBaseUnits
+    ].filter((amount) => amount !== void 0).reduce((min, amount) => amount < min ? amount : min);
+    if (maxDestinationBorrowBaseUnits <= 0n) {
+      throw new Error(
+        "LeverageService.buildFlashRebalance: destination reserve has no available borrow capacity"
+      );
+    }
+    const { quote: swapQuote } = await sizeExactInForMinOutput(ctx.swap, {
+      inputMint: destDebtLiqMint,
+      outputMint: sourceDebtLiqMint,
+      minOutputAmount: flashRepayBigInt,
+      maxInputAmount: maxDestinationBorrowBaseUnits,
+      slippageBps: params.swapSlippageBps ?? 15,
+      safetyBufferBps: params.swapBufferBps ?? 5,
+      maxAccounts: FLASH_REBALANCE_SWAP_MAX_ACCOUNTS
+    });
+    if (params.maxSwapCostBps !== void 0 || params.maxMarketBasisBps !== void 0) {
+      const [sourcePrices, destPrices] = await Promise.all([
+        new ReservesManager(
+          ctx.source.supplyReserve,
+          ctx.source.debtReserve,
+          ctx.environment
+        ).prices(),
+        new ReservesManager(
+          ctx.destination.supplyReserve,
+          ctx.destination.debtReserve,
+          ctx.environment
+        ).prices()
+      ]);
+      const fairOutPerIn = destPrices.debt.realtimePrice / sourcePrices.debt.realtimePrice;
+      if (!Number.isFinite(fairOutPerIn) || fairOutPerIn <= 0) {
+        throw new Error(
+          `LeverageService.buildFlashRebalance: invalid oracle prices for swap cost check (source=${sourcePrices.debt.realtimePrice} dest=${destPrices.debt.realtimePrice})`
+        );
+      }
+      const inUi = Number(swapQuote.inputAmount) / Math.pow(10, destDebtDecimals);
+      const outUi = Number(swapQuote.outputAmount) / Math.pow(10, sourceDebtDecimals);
+      const executionCostBps = (1 - outUi / inUi / fairOutPerIn) * 1e4;
+      const marketBasisBps = (1 - fairOutPerIn) * 1e4;
+      if (params.maxSwapCostBps !== void 0 && executionCostBps > params.maxSwapCostBps) {
+        throw new FlashRebalanceSwapCostExceededError(
+          "execution-cost",
+          executionCostBps,
+          marketBasisBps,
+          params.maxSwapCostBps,
+          swapQuote.inputAmount,
+          swapQuote.outputAmount
+        );
+      }
+      if (params.maxMarketBasisBps !== void 0 && Math.abs(marketBasisBps) > params.maxMarketBasisBps) {
+        throw new FlashRebalanceSwapCostExceededError(
+          "market-basis",
+          executionCostBps,
+          marketBasisBps,
+          params.maxMarketBasisBps,
+          swapQuote.inputAmount,
+          swapQuote.outputAmount
+        );
+      }
+    }
+    const swapCpi = await ctx.swap.getSwapCpiData(swapQuote, ctx.user, { payer: ctx.payer });
+    const destinationBorrowBaseUnits = new BN8(swapQuote.inputAmount.toString());
+    const destinationBorrowUiAmount = toUiAmount(destinationBorrowBaseUnits, destDebtDecimals);
+    const sourceRepay = await ctx.source.lendingIx.getRepayCpiData({
+      user: ctx.user,
+      payer: ctx.payer,
+      pool: ctx.source.pool,
+      reserve: sourceDebtMint,
+      userAccount: ctx.source.userAccount,
+      txId: ctx.txId
+    });
+    if (params.withdrawAll) {
+      ctx.source.lendingIx.markObligationDebtCleared(
+        ctx.txId,
+        ctx.source.userAccount,
+        sourceDebtMint
+      );
+    }
+    const destBorrow = await ctx.destination.lendingIx.getInitBorrowPositionCpiBundle(
+      {
+        user: ctx.user,
+        payer: ctx.payer,
+        pool: ctx.destination.pool,
+        reserve: ctx.destination.debtReserve.address,
+        userAccount: ctx.destination.userAccount,
+        uiAmount: destinationBorrowUiAmount,
+        txId: ctx.txId
+      },
+      ctx.destination.supplyReserve.address
+    );
+    const userSourceDebtAta = await getAtaAddress(
+      sourceDebtLiqMint,
+      ctx.user,
+      ctx.source.debtReserve.mint.mintTokenProgram
+    );
+    const flashBorrowIx = await ctx.flashLoan.getFlashBorrowIx({
+      user: ctx.payer,
+      pool: ctx.source.pool,
+      reserve: sourceDebtMint,
+      amountBaseUnits: flashBorrowAmountBaseUnits,
+      destinationAta: userSourceDebtAta
+    });
+    const sourceIx = ctx.source.lendingIx;
+    const destIx = ctx.destination.lendingIx;
+    const sourcePreInstructions = await sourceIx.getPreInstructions(ctx.txId);
+    const lendingPreInstructions = sourceIx === destIx ? sourcePreInstructions : [...sourcePreInstructions, ...await destIx.getPreInstructions(ctx.txId)];
+    const swapPreInstructions = swapCpi.preInstructions ?? [];
+    const preInstructions = [...lendingPreInstructions, ...swapPreInstructions];
+    const postSuccessCacheInvalidations = [
+      ...destBorrow.postSuccessCacheInvalidations,
+      ...swapCpi.postSuccessCacheInvalidations ?? []
+    ];
+    return {
+      flashBorrowAmountBaseUnits,
+      flashRepayAmountBaseUnits,
+      flashFeeBaseUnits,
+      sourceRepayUiAmount,
+      destinationBorrowUiAmount,
+      flashBorrowIx,
+      sourceRepayCpis: [...sourceRepay.prerequisiteCpis, ...sourceRepay.cpis],
+      destinationBorrowCpis: [...destBorrow.prerequisiteCpis, ...destBorrow.cpis],
+      swapCpis: [swapCpi],
+      preInstructions,
+      postSuccessCacheInvalidations
+    };
+  }
+  /**
+   * Build the top-level flash-repay instruction for a previously-built flash
+   * rebalance, given the final transaction index of its `flashBorrowIx`.
+   *
+   * Split from {@link buildFlashRebalance} because `borrowIxIndex` depends on
+   * the caller's full tx layout (pre-instructions + heap frame + ATA creations
+   * + flash-borrow position), which in turn depends on the ATA list derived
+   * from the plan's `remainingAccounts` — a chicken-and-egg the caller resolves
+   * by assembling the preamble before calling this.
+   */
+  static async buildFlashRepayIx(ctx, plan, borrowIxIndex) {
+    const userSourceDebtAta = await getAtaAddress(
+      ctx.source.debtReserve.mint.mint,
+      ctx.user,
+      ctx.source.debtReserve.mint.mintTokenProgram
+    );
+    return ctx.flashLoan.getFlashRepayIx({
+      user: ctx.payer,
+      pool: ctx.source.pool,
+      reserve: ctx.source.debtReserve.address,
+      amountBaseUnits: plan.flashBorrowAmountBaseUnits,
+      borrowIxIndex,
+      userSourceLiquidity: userSourceDebtAta
+    });
+  }
+  static async calcSourceRepayForWithdraw(ctx, params) {
+    const manager = new LendingPositionManager(
+      ctx.source.lendingIx.data,
+      ctx.source.pool,
+      ctx.source.userAccount,
+      ctx.source.supplyReserve,
+      ctx.source.debtReserve,
+      ctx.environment
+    );
+    if (params.withdrawAll) {
+      const { debtUiAmount } = await manager.getLendingPositionAmounts();
+      return fromUiAmount(debtUiAmount, ctx.source.debtReserve.mint.mintDecimals);
+    }
+    const debtChangeUi = await manager.calcDebtChangeAmountForCollateralWithdrawal(
+      params.collateralUiAmount,
+      params.sourceTargetUtilizationRateBps
+    );
+    const repayUi = Math.max(0, -debtChangeUi);
+    return fromUiAmount(repayUi, ctx.source.debtReserve.mint.mintDecimals);
+  }
+  static async calcDestinationBorrowCapacityForDeposit(ctx, params) {
+    if (params.destinationMaxUtilizationRateBps === void 0) {
+      return void 0;
+    }
+    const manager = new LendingPositionManager(
+      ctx.destination.lendingIx.data,
+      ctx.destination.pool,
+      ctx.destination.userAccount,
+      ctx.destination.supplyReserve,
+      ctx.destination.debtReserve,
+      ctx.environment
+    );
+    const current = await manager.getLendingPositionAmounts();
+    const reserves = new ReservesManager(
+      ctx.destination.supplyReserve,
+      ctx.destination.debtReserve,
+      ctx.environment
+    );
+    const debtAdjustmentUsd = await reserves.calcDebtAdjustmentUsd(
+      current.supplyUiAmount + params.collateralUiAmount,
+      current.debtUiAmount,
+      params.destinationMaxUtilizationRateBps,
+      { positionChangeMode: "debtOnly" }
+    );
+    const prices = await reserves.prices();
+    if (debtAdjustmentUsd <= 0) {
+      return 0n;
+    }
+    const debtUiAmount = debtAdjustmentUsd / prices.debt.realtimePrice;
+    return BigInt(
+      fromUiAmount(debtUiAmount, ctx.destination.debtReserve.mint.mintDecimals).toString()
+    );
+  }
+};
+
+// src/constants/configs/carryTradePresets.ts
+var VOLATILITY_REGIMES = ["lowVol", "highVol"];
+function isVolatilityRegime(s) {
+  return VOLATILITY_REGIMES.includes(s);
+}
+var STOCK_INDEX_PRESETS = {
+  lowVol: {
+    drawdownPctFromTargetToLiq: 8,
+    drawdownPctFromUnwindToLiq: 5,
+    maxPriceChangeUpPercent: 2
+  },
+  highVol: {
+    drawdownPctFromTargetToLiq: 11,
+    drawdownPctFromUnwindToLiq: 7,
+    maxPriceChangeUpPercent: 3
+  }
+};
+var BTC_CARRY_PRESETS = {
+  lowVol: {
+    drawdownPctFromTargetToLiq: 12,
+    drawdownPctFromUnwindToLiq: 8,
+    maxPriceChangeUpPercent: 6
+  },
+  highVol: {
+    drawdownPctFromTargetToLiq: 14,
+    drawdownPctFromUnwindToLiq: 10,
+    maxPriceChangeUpPercent: 8
+  }
+};
+var ETH_CARRY_PRESETS = {
+  lowVol: {
+    drawdownPctFromTargetToLiq: 14,
+    drawdownPctFromUnwindToLiq: 10,
+    maxPriceChangeUpPercent: 7
+  },
+  highVol: {
+    drawdownPctFromTargetToLiq: 17,
+    drawdownPctFromUnwindToLiq: 12,
+    maxPriceChangeUpPercent: 10
+  }
+};
+var SOL_CARRY_PRESETS = {
+  lowVol: {
+    drawdownPctFromTargetToLiq: 16,
+    drawdownPctFromUnwindToLiq: 12,
+    maxPriceChangeUpPercent: 8
+  },
+  highVol: {
+    drawdownPctFromTargetToLiq: 19,
+    drawdownPctFromUnwindToLiq: 14,
+    maxPriceChangeUpPercent: 11
+  }
+};
+var LST_CARRY_PRESETS = {
+  lowVol: {
+    drawdownPctFromTargetToLiq: 19,
+    drawdownPctFromUnwindToLiq: 10,
+    maxPriceChangeUpPercent: 8
+  },
+  highVol: {
+    drawdownPctFromTargetToLiq: 22,
+    drawdownPctFromUnwindToLiq: 12,
+    maxPriceChangeUpPercent: 11
+  }
+};
+var LARGE_CAP_ALT_CARRY_PRESETS = {
+  lowVol: {
+    drawdownPctFromTargetToLiq: 22,
+    drawdownPctFromUnwindToLiq: 16,
+    maxPriceChangeUpPercent: 8
+  },
+  highVol: {
+    drawdownPctFromTargetToLiq: 25,
+    drawdownPctFromUnwindToLiq: 18,
+    maxPriceChangeUpPercent: 10
+  }
+};
+var SMALL_CAP_ALT_CARRY_PRESETS = {
+  lowVol: {
+    drawdownPctFromTargetToLiq: 26,
+    drawdownPctFromUnwindToLiq: 22,
+    maxPriceChangeUpPercent: 10
+  },
+  highVol: {
+    drawdownPctFromTargetToLiq: 29,
+    drawdownPctFromUnwindToLiq: 24,
+    maxPriceChangeUpPercent: 12
+  }
+};
+var ASSET_PRESETS = {
+  WBTC: { presets: BTC_CARRY_PRESETS, defaultRegime: "lowVol" },
+  CBBTC: { presets: BTC_CARRY_PRESETS, defaultRegime: "lowVol" },
+  WETH: { presets: ETH_CARRY_PRESETS, defaultRegime: "lowVol" },
+  SOL: { presets: SOL_CARRY_PRESETS, defaultRegime: "lowVol" },
+  JUPSOL: { presets: LST_CARRY_PRESETS, defaultRegime: "lowVol" },
+  JITOSOL: { presets: LST_CARRY_PRESETS, defaultRegime: "lowVol" },
+  DFDVSOL: { presets: LST_CARRY_PRESETS, defaultRegime: "lowVol" },
+  SPYX: { presets: STOCK_INDEX_PRESETS, defaultRegime: "lowVol" },
+  QQQX: { presets: STOCK_INDEX_PRESETS, defaultRegime: "lowVol" },
+  LARGE_CAP: { presets: LARGE_CAP_ALT_CARRY_PRESETS, defaultRegime: "lowVol" },
+  SMALL_CAP: { presets: SMALL_CAP_ALT_CARRY_PRESETS, defaultRegime: "highVol" }
+};
+function resolvePresets(collateralSymbol) {
+  return ASSET_PRESETS[collateralSymbol.toUpperCase()];
+}
+
+// src/services/carry/carryAllocationConfig.ts
+var MAX_TARGET_UTILIZATION_RATE_BPS = 1e4;
+var MAX_LENDING_POSITION_UPPER_UTIL_BPS2 = 10500;
+var MIN_DEVIATION_ABOVE_TARGET_UTIL_BPS = 200;
+function clampLendingPositionConfigBps(config) {
+  let { targetUtilizationRateBps, maxDeviationAboveTargetUtilBps, maxDeviationBelowTargetUtilBps } = config;
+  if (!Number.isInteger(targetUtilizationRateBps) || targetUtilizationRateBps <= 0) {
+    throw new Error("targetUtilizationRateBps must be a positive integer");
+  }
+  for (const [name, v] of [
+    ["maxDeviationAboveTargetUtilBps", maxDeviationAboveTargetUtilBps],
+    ["maxDeviationBelowTargetUtilBps", maxDeviationBelowTargetUtilBps]
+  ]) {
+    if (!Number.isInteger(v) || v < 0) {
+      throw new Error(`${name} must be a non-negative integer`);
+    }
+  }
+  targetUtilizationRateBps = Math.min(targetUtilizationRateBps, MAX_TARGET_UTILIZATION_RATE_BPS);
+  maxDeviationAboveTargetUtilBps = Math.min(
+    maxDeviationAboveTargetUtilBps,
+    MAX_LENDING_POSITION_UPPER_UTIL_BPS2 - targetUtilizationRateBps
+  );
+  if (targetUtilizationRateBps <= maxDeviationBelowTargetUtilBps) {
+    throw new Error("targetUtilizationRateBps must be greater than maxDeviationBelowTargetUtilBps");
+  }
+  return {
+    targetUtilizationRateBps,
+    maxDeviationAboveTargetUtilBps,
+    maxDeviationBelowTargetUtilBps
+  };
+}
+function computeCarryLendingAllocationConfig(params) {
+  const {
+    drawdownPctFromTargetToLiq,
+    drawdownPctFromUnwindToLiq,
+    maxPriceChangeUpPercent,
+    maxLtv,
+    liquidationThreshold
+  } = params;
+  if (!Number.isFinite(drawdownPctFromTargetToLiq) || drawdownPctFromTargetToLiq <= 0 || drawdownPctFromTargetToLiq >= 100) {
+    throw new RangeError("drawdownPctFromTargetToLiq must be in (0, 100)");
+  }
+  if (!Number.isFinite(drawdownPctFromUnwindToLiq) || drawdownPctFromUnwindToLiq < 0 || drawdownPctFromUnwindToLiq >= 100) {
+    throw new RangeError("drawdownPctFromUnwindToLiq must be in [0, 100)");
+  }
+  if (drawdownPctFromUnwindToLiq >= drawdownPctFromTargetToLiq) {
+    throw new RangeError(
+      "drawdownPctFromUnwindToLiq must be less than drawdownPctFromTargetToLiq (unwind trigger is closer to liquidation than target)"
+    );
+  }
+  if (!Number.isFinite(maxPriceChangeUpPercent) || maxPriceChangeUpPercent <= 0) {
+    throw new RangeError("maxPriceChangeUpPercent must be finite and positive");
+  }
+  const targetDecimal = maxLtvUtilBeforeCollDrawdown({
+    drawdownPercent: drawdownPctFromTargetToLiq,
+    ltv: maxLtv,
+    liquidationThreshold
+  });
+  let targetUtilizationRateBps = Math.min(
+    Math.floor(targetDecimal * 1e4),
+    MAX_TARGET_UTILIZATION_RATE_BPS
+  );
+  if (targetUtilizationRateBps <= 0) {
+    throw new RangeError(
+      "Computed target utilization rounds to zero; reduce drawdownPctFromTargetToLiq or check maxLtv / liquidationThreshold"
+    );
+  }
+  const unwindTriggerDecimal = maxLtvUtilBeforeCollDrawdown({
+    drawdownPercent: drawdownPctFromUnwindToLiq,
+    ltv: maxLtv,
+    liquidationThreshold
+  });
+  const unwindTriggerBps = Math.floor(unwindTriggerDecimal * 1e4);
+  let maxDeviationAboveTargetUtilBps = Math.min(
+    unwindTriggerBps - targetUtilizationRateBps,
+    MAX_LENDING_POSITION_UPPER_UTIL_BPS2 - targetUtilizationRateBps
+  );
+  if (maxDeviationAboveTargetUtilBps < MIN_DEVIATION_ABOVE_TARGET_UTIL_BPS) {
+    maxDeviationAboveTargetUtilBps = MIN_DEVIATION_ABOVE_TARGET_UTIL_BPS;
+    targetUtilizationRateBps = Math.min(
+      targetUtilizationRateBps,
+      MAX_LENDING_POSITION_UPPER_UTIL_BPS2 - MIN_DEVIATION_ABOVE_TARGET_UTIL_BPS
+    );
+  }
+  const t = targetUtilizationRateBps / 1e4;
+  const maxBelowDecimal = ltvUtilDeltaBelowTargForRallyPct(t, maxPriceChangeUpPercent);
+  const maxDeviationBelowTargetUtilBps = Math.floor(maxBelowDecimal * 1e4);
+  return clampLendingPositionConfigBps({
+    targetUtilizationRateBps,
+    maxDeviationAboveTargetUtilBps,
+    maxDeviationBelowTargetUtilBps
+  });
+}
+function computeConfigForCollateral(args) {
+  const { collateralMint, collateralReserve, debtReserve } = args;
+  const mintInfo = mints.get(collateralMint);
+  const symbol = mintInfo?.symbol ?? String(collateralMint);
+  const entry = resolvePresets(symbol);
+  if (!entry) {
+    throw new Error(
+      `computeConfigForCollateral: no carry preset found for collateral "${symbol}" (${collateralMint})`
+    );
+  }
+  const regime = args.regime ?? entry.defaultRegime;
+  const preset = entry.presets[regime];
+  const rm = new ReservesManager(collateralReserve, debtReserve);
+  const pct = collateralReserve.config.liquidationThresholdPct;
+  const liquidationThreshold = pct <= 1 ? pct : pct / 100;
+  return computeCarryLendingAllocationConfig({
+    ...preset,
+    maxLtv: rm.maxLtv,
+    liquidationThreshold
+  });
+}
+
+// src/services/carry/lycLendingPositionManager.ts
+var LycLendingPositionManager = class _LycLendingPositionManager extends LendingPositionManager {
+  constructor(lpData, lendingPosition, collateralReserve, debtReserve, environment) {
+    super(
+      lpData,
+      fromWeb3Pk(lendingPosition.pool),
+      fromWeb3Pk(lendingPosition.protocolUserAcc),
+      collateralReserve,
+      debtReserve,
+      environment
+    );
+    this.lendingPosition = lendingPosition;
+  }
+  static async create(lpData, lendingPosition, environment) {
+    const pool = fromWeb3Pk(lendingPosition.pool);
+    const [collateralReserve, debtReserve] = await Promise.all([
+      lpData.fetchReserve(pool, fromWeb3Pk(lendingPosition.collateralReserve)),
+      lpData.fetchReserve(pool, fromWeb3Pk(lendingPosition.debtReserve))
+    ]);
+    if (!collateralReserve || !debtReserve) {
+      throw new Error("Failed to fetch reserves");
+    }
+    return new _LycLendingPositionManager(
+      lpData,
+      lendingPosition,
+      collateralReserve,
+      debtReserve,
+      environment
+    );
+  }
+  /**
+   * Derives `targetUtilizationRateBps` and carry trigger deviations from drawdown-to-liquidation
+   * buffers and a rally percentage, using this pair's {@link ReservesManager.maxLtv} and the
+   * collateral reserve's **base** `liquidationThresholdPct` (normalized to a decimal).
+   *
+   * For custom `maxLtv` / `liquidationThreshold` (e.g. e-mode liquidation threshold), call
+   * {@link computeCarryLendingAllocationConfig} directly.
+   */
+  getLendingAllocationConfigFromPriceBands(params) {
+    const pct = this.reservesManager.supplyReserve.config.liquidationThresholdPct;
+    const liquidationThreshold = pct <= 1 ? pct : pct / 100;
+    return computeCarryLendingAllocationConfig({
+      ...params,
+      maxLtv: this.reservesManager.maxLtv,
+      liquidationThreshold
+    });
+  }
+  /**
+   * Returns true when the current LTV utilization (valued at EMA prices) has
+   * fallen far enough below the target that the position should be boosted.
+   */
+  async shouldIncreaseCarryPosition() {
+    const state = await this.getPositionState("ema");
+    if (!state) return false;
+    const { supplyUsd, debtUsd } = state;
+    if (supplyUsd <= 0) return false;
+    const currentUtilBps = this.reservesManager.calcLtvUtilizationRateBps(supplyUsd, debtUsd);
+    return currentUtilBps <= this.lendingPosition.config.targetUtilizationRateBps - this.lendingPosition.config.maxDeviationBelowTargetUtilBps;
+  }
+  /**
+   * Returns true when the current LTV utilization (valued at realtime prices) has
+   * risen far enough above the target that the position should be unwound.
+   */
+  async shouldDecreaseCarryPosition() {
+    const state = await this.getPositionState("realtime");
+    if (!state) return false;
+    const { supplyUsd, debtUsd } = state;
+    const currentUtilBps = this.reservesManager.calcLtvUtilizationRateBps(supplyUsd, debtUsd);
+    return currentUtilBps >= this.lendingPosition.config.targetUtilizationRateBps + this.lendingPosition.config.maxDeviationAboveTargetUtilBps;
+  }
+  async calcDebtChangeAmount(targetUtilizationRateBps = this.lendingPosition.config.targetUtilizationRateBps) {
+    return super.calcDebtChangeAmount(targetUtilizationRateBps);
+  }
+  async calcPreWithdrawalTargetUtilizationRateBps(withdrawUiCollateralAmount, postWithdrawalTargetUtilizationRateBps = this.lendingPosition.config.targetUtilizationRateBps) {
+    return super.calcPreWithdrawalTargetUtilizationRateBps(
+      withdrawUiCollateralAmount,
+      postWithdrawalTargetUtilizationRateBps
+    );
+  }
+  async calcDebtChangeAmountForCollateralWithdrawal(withdrawUiCollateralAmount, postWithdrawalTargetUtilizationRateBps = this.lendingPosition.config.targetUtilizationRateBps) {
+    return super.calcDebtChangeAmountForCollateralWithdrawal(
+      withdrawUiCollateralAmount,
+      postWithdrawalTargetUtilizationRateBps
+    );
+  }
+  async getCollateralPriceTriggerBand() {
+    return super.getCollateralPriceTriggerBand(this.configTriggerBandBps());
+  }
+  async getInspectMetrics() {
+    return super.getInspectMetrics(this.configTriggerBandBps());
+  }
+  configTriggerBandBps() {
+    const {
+      targetUtilizationRateBps,
+      maxDeviationBelowTargetUtilBps,
+      maxDeviationAboveTargetUtilBps
+    } = this.lendingPosition.config;
+    return {
+      lowerTargetUtilizationRateBps: targetUtilizationRateBps - maxDeviationBelowTargetUtilBps,
+      upperTargetUtilizationRateBps: targetUtilizationRateBps + maxDeviationAboveTargetUtilBps
+    };
+  }
+};
+
+export {
+  KAMINO_MAIN_MARKET,
+  getEligiblePools,
+  getLendingUserAccountCacheInvalidation,
+  KaminoClient,
+  LOCAL_TEST_MAX_ACCOUNTS,
+  LOCAL_TEST_EXCLUDED_DEXES,
+  JupiterSwapClient,
+  ExactInQuoteExceedsMaxInputError,
+  FlashRebalanceSwapCostExceededError,
+  LeverageService,
+  VOLATILITY_REGIMES,
+  isVolatilityRegime,
+  STOCK_INDEX_PRESETS,
+  BTC_CARRY_PRESETS,
+  ETH_CARRY_PRESETS,
+  SOL_CARRY_PRESETS,
+  LST_CARRY_PRESETS,
+  LARGE_CAP_ALT_CARRY_PRESETS,
+  SMALL_CAP_ALT_CARRY_PRESETS,
+  ASSET_PRESETS,
+  resolvePresets,
+  MAX_TARGET_UTILIZATION_RATE_BPS,
+  MAX_LENDING_POSITION_UPPER_UTIL_BPS2 as MAX_LENDING_POSITION_UPPER_UTIL_BPS,
+  MIN_DEVIATION_ABOVE_TARGET_UTIL_BPS,
+  clampLendingPositionConfigBps,
+  computeCarryLendingAllocationConfig,
+  computeConfigForCollateral,
+  LycLendingPositionManager
+};
+//# sourceMappingURL=chunk-GOW6CARW.mjs.map