@gearbox-protocol/sdk 13.0.0-beta.3 → 13.0.0-beta.5

package/dist/esm/common-utils/utils/creditAccount/debt.js

@@ -0,0 +1,43 @@
+import {
+  PERCENTAGE_FACTOR,
+  PRICE_DECIMALS_POW,
+  WAD_DECIMALS_POW
+} from "../../../sdk/index.js";
+import { BigIntMath } from "../bigintMath.js";
+import { PriceUtils } from "../priceMath.js";
+function calcMaxDebtIncrease(healthFactor, debt, underlyingLT, minHf = Number(PERCENTAGE_FACTOR)) {
+  const result = debt * BigInt(healthFactor - minHf) / BigInt(minHf - underlyingLT);
+  return BigIntMath.max(0n, result);
+}
+function calcMaxLendingDebt({
+  assets,
+  liquidationThresholds,
+  underlyingToken,
+  prices,
+  tokensList,
+  targetHF = PERCENTAGE_FACTOR
+}) {
+  const assetsLTMoney = assets.reduce(
+    (acc, { token: tokenAddress, balance: amount }) => {
+      const tokenDecimals = tokensList[tokenAddress]?.decimals || 18;
+      const lt = liquidationThresholds[tokenAddress] || 0n;
+      const price = prices[tokenAddress] || 0n;
+      const tokenMoney = PriceUtils.calcTotalPrice(
+        price,
+        amount,
+        tokenDecimals
+      );
+      const tokenLtMoney = tokenMoney * lt;
+      return acc + tokenLtMoney;
+    },
+    0n
+  );
+  const underlyingPrice = prices[underlyingToken] || 0n;
+  const underlyingDecimals = tokensList[underlyingToken]?.decimals || 18;
+  const max = underlyingPrice > 0 ? assetsLTMoney * 10n ** BigInt(underlyingDecimals) / underlyingPrice / targetHF / 10n ** BigInt(WAD_DECIMALS_POW - PRICE_DECIMALS_POW) : 0n;
+  return max;
+}
+export {
+  calcMaxDebtIncrease,
+  calcMaxLendingDebt
+};

package/dist/esm/common-utils/utils/creditAccount/getTimeToLiquidation.js

@@ -0,0 +1,18 @@
+import {
+  PERCENTAGE_DECIMALS,
+  PERCENTAGE_FACTOR,
+  SECONDS_PER_YEAR
+} from "../../../sdk/index.js";
+function getTimeToLiquidation({
+  healthFactor,
+  totalBorrowRate_debt
+}) {
+  if (healthFactor <= PERCENTAGE_FACTOR || totalBorrowRate_debt === 0n)
+    return null;
+  const HF_1 = BigInt(healthFactor) - PERCENTAGE_FACTOR;
+  const brPerYear = BigInt(SECONDS_PER_YEAR) * PERCENTAGE_FACTOR * PERCENTAGE_DECIMALS / totalBorrowRate_debt;
+  return HF_1 * brPerYear * 1000n / PERCENTAGE_FACTOR;
+}
+export {
+  getTimeToLiquidation
+};

package/dist/esm/common-utils/utils/creditAccount/index.js

@@ -0,0 +1,9 @@
+export * from "./calcHealthFactor.js";
+export * from "./calcQuotaBorrowRate.js";
+export * from "./calcQuotaBorrowRate.js";
+export * from "./calcRelativeBaseBorrowRate.js";
+export * from "./debt.js";
+export * from "./getTimeToLiquidation.js";
+export * from "./liquidationPrice.js";
+export * from "./quotaUtils.js";
+export * from "./sort.js";

package/dist/esm/common-utils/utils/creditAccount/liquidationPrice.js

@@ -0,0 +1,23 @@
+import { PERCENTAGE_FACTOR, PRICE_DECIMALS, WAD } from "../../../sdk/index.js";
+function liquidationPrice({
+  liquidationThresholds,
+  debt,
+  underlyingToken,
+  targetToken,
+  assets,
+  tokensList
+}) {
+  const underlyingDecimals = tokensList[underlyingToken]?.decimals || 18;
+  const { balance: underlyingBalance = 0n } = assets[underlyingToken] || {};
+  const ltUnderlying = liquidationThresholds[underlyingToken] || 0n;
+  const effectiveDebt = (debt - underlyingBalance * ltUnderlying / PERCENTAGE_FACTOR) * WAD / 10n ** BigInt(underlyingDecimals);
+  const targetDecimals = tokensList[targetToken]?.decimals || 18;
+  const { balance: targetBalance = 0n } = assets[targetToken] || {};
+  const effectiveTargetBalance = targetBalance * WAD / 10n ** BigInt(targetDecimals);
+  const lpLT = liquidationThresholds[targetToken] || 0n;
+  if (targetBalance <= 0n || lpLT <= 0n) return 0n;
+  return effectiveDebt * PRICE_DECIMALS * PERCENTAGE_FACTOR / (effectiveTargetBalance * lpLT);
+}
+export {
+  liquidationPrice
+};

package/dist/esm/common-utils/utils/creditAccount/quotaUtils.js

@@ -0,0 +1,125 @@
+import {
+  MIN_INT96,
+  PERCENTAGE_FACTOR
+} from "../../../sdk/index.js";
+import { BigIntMath } from "../bigintMath.js";
+function roundUpQuota(quotaChange) {
+  return quotaChange !== MIN_INT96 ? quotaChange / PERCENTAGE_FACTOR * PERCENTAGE_FACTOR : quotaChange;
+}
+function calcRecommendedQuota({
+  amount,
+  debt,
+  lt,
+  quotaReserve
+}) {
+  const recommendedBaseQuota = BigIntMath.min(
+    debt,
+    amount * lt / PERCENTAGE_FACTOR
+  );
+  const recommendedQuota = recommendedBaseQuota * (PERCENTAGE_FACTOR + quotaReserve) / PERCENTAGE_FACTOR;
+  return roundUpQuota(recommendedQuota);
+}
+function calcDefaultQuota({
+  amount,
+  lt,
+  quotaReserve
+}) {
+  const recommendedBaseQuota = amount * lt / PERCENTAGE_FACTOR;
+  const recommendedQuota = recommendedBaseQuota * (PERCENTAGE_FACTOR + quotaReserve) / PERCENTAGE_FACTOR;
+  return roundUpQuota(recommendedQuota);
+}
+function calcQuotaUpdate(props) {
+  const { quotas, initialQuotas, maxDebt, allowedToSpend, allowedToObtain } = props;
+  const quotaDecrease = Object.keys(allowedToSpend).reduce((acc, token) => {
+    const ch = getSingleQuotaChange(token, 0n, props);
+    if (ch && ch.balance < 0) acc[ch.token] = ch;
+    return acc;
+  }, {});
+  const quotaCap = roundUpQuota(maxDebt * 2n);
+  const quotaBought = Object.values(initialQuotas).reduce(
+    (sum, q) => sum + roundUpQuota(q?.quota || 0n),
+    0n
+  );
+  const quotaReduced = Object.values(quotaDecrease).reduce((sum, q) => {
+    const quotaBalance = q.balance || 0n;
+    const safeBalance = quotaBalance === MIN_INT96 ? BigIntMath.neg(roundUpQuota(initialQuotas[q.token]?.quota || 0n)) : quotaBalance;
+    return sum + safeBalance;
+  }, 0n);
+  const maxQuotaIncrease = roundUpQuota(
+    BigIntMath.max(quotaCap - (quotaBought + quotaReduced), 0n)
+  );
+  const quotaIncrease = Object.keys(allowedToObtain).reduce((acc, token) => {
+    const ch = getSingleQuotaChange(token, maxQuotaIncrease, props);
+    if (ch && ch.balance > 0) acc[ch.token] = ch;
+    return acc;
+  }, {});
+  const quotaChange = {
+    ...quotaDecrease,
+    ...quotaIncrease
+  };
+  const desiredQuota = Object.values(quotas).reduce(
+    (acc, cmQuota) => {
+      const { token, isActive } = cmQuota;
+      const { quota: initialQuota = 0n } = initialQuotas[token] || {};
+      if (!isActive) {
+        acc[token] = {
+          balance: initialQuota,
+          token
+        };
+      } else {
+        const change = quotaChange[token]?.balance || 0n;
+        const quotaAfter = change === MIN_INT96 ? 0n : initialQuota + change;
+        acc[token] = {
+          balance: quotaAfter,
+          token
+        };
+      }
+      return acc;
+    },
+    {}
+  );
+  return {
+    desiredQuota,
+    quotaDecrease: Object.values(quotaDecrease),
+    quotaIncrease: Object.values(quotaIncrease)
+  };
+}
+function getSingleQuotaChange(token, unsafeMaxQuotaIncrease, props) {
+  const { isActive = false } = props.quotas[token] || {};
+  const { quota: unsafeInitialQuota = 0n } = props.initialQuotas[token] || {};
+  if (!isActive) {
+    return void 0;
+  }
+  const assetAfter = props.assetsAfterUpdate[token];
+  const { amountInTarget = 0n } = assetAfter || {};
+  const lt = props.liquidationThresholds[token] || 0n;
+  const maxQuotaIncrease = roundUpQuota(unsafeMaxQuotaIncrease);
+  const initialQuota = roundUpQuota(unsafeInitialQuota);
+  const defaultQuota = props.calcModification?.type === "recommendedQuota" && props.calcModification.debt > 0 ? calcRecommendedQuota({
+    lt,
+    quotaReserve: props.quotaReserve,
+    amount: amountInTarget,
+    debt: props.calcModification.debt
+  }) : calcDefaultQuota({
+    lt,
+    quotaReserve: props.quotaReserve,
+    amount: amountInTarget
+  });
+  const unsafeQuotaChange = roundUpQuota(defaultQuota - initialQuota);
+  const quotaChange = unsafeQuotaChange > 0 ? BigIntMath.min(maxQuotaIncrease, unsafeQuotaChange) : unsafeQuotaChange < 0 && BigIntMath.abs(unsafeQuotaChange) >= initialQuota ? MIN_INT96 : unsafeQuotaChange;
+  const correctIncrease = assetAfter && props.allowedToObtain[token] && quotaChange > 0;
+  const correctDecrease = assetAfter && props.allowedToSpend[token] && quotaChange < 0;
+  if (correctIncrease || correctDecrease) {
+    return {
+      balance: quotaChange,
+      token
+    };
+  }
+  return void 0;
+}
+export {
+  calcDefaultQuota,
+  calcQuotaUpdate,
+  calcRecommendedQuota,
+  roundUpQuota
+};

package/dist/esm/common-utils/utils/creditAccount/sort.js

@@ -0,0 +1,67 @@
+import { PRICE_DECIMALS } from "../../../sdk/index.js";
+import { PriceUtils } from "../priceMath.js";
+function sortBalances(balances, prices, tokens) {
+  return Object.entries(balances).sort(
+    ([addr1, amount1], [addr2, amount2]) => {
+      return assetComparator(
+        {
+          token: addr1,
+          balance: amount1
+        },
+        {
+          token: addr2,
+          balance: amount2
+        },
+        prices,
+        prices,
+        tokens,
+        tokens
+      );
+    }
+  );
+}
+function sortAssets(balances, prices, tokens) {
+  return [...balances].sort(
+    (t1, t2) => assetComparator(t1, t2, prices, prices, tokens, tokens)
+  );
+}
+function assetComparator(t1, t2, prices1, prices2, tokens1, tokens2) {
+  const addr1Lc = t1.token.toLowerCase();
+  const addr2Lc = t2.token.toLowerCase();
+  const token1 = tokens1?.[addr1Lc];
+  const token2 = tokens2?.[addr2Lc];
+  const price1 = prices1?.[addr1Lc] || PRICE_DECIMALS;
+  const price2 = prices2?.[addr2Lc] || PRICE_DECIMALS;
+  const totalPrice1 = PriceUtils.calcTotalPrice(
+    price1,
+    t1.balance,
+    token1?.decimals
+  );
+  const totalPrice2 = PriceUtils.calcTotalPrice(
+    price2,
+    t2.balance,
+    token2?.decimals
+  );
+  if (totalPrice1 === totalPrice2) {
+    return t1.balance === t2.balance ? tokensAbcComparator(token1, token2) : amountAbcComparator(t1.balance, t2.balance);
+  }
+  return amountAbcComparator(totalPrice1, totalPrice2);
+}
+function tokensAbcComparator(t1, t2) {
+  const { symbol: symbol1 = "" } = t1 || {};
+  const { symbol: symbol2 = "" } = t2 || {};
+  const symbol1LC = symbol1.toLowerCase();
+  const symbol2LC = symbol2.toLowerCase();
+  if (symbol1LC === symbol2LC) return 0;
+  return symbol1LC > symbol2LC ? 1 : -1;
+}
+function amountAbcComparator(t1, t2) {
+  return t1 > t2 ? -1 : 1;
+}
+export {
+  amountAbcComparator,
+  assetComparator,
+  sortAssets,
+  sortBalances,
+  tokensAbcComparator
+};

package/dist/esm/{sdk → common-utils}/utils/endpoints.js

@@ -1,4 +1,4 @@
-import { isSupportedNetwork } from "../index.js";
+import { isSupportedNetwork } from "../../sdk/index.js";
 const CHARTS_BACKEND_ADDRESS = "https://charts-server.fly.dev";
 const STATIC_TOKEN = "https://static.gearbox.finance/tokens/";
 class GearboxBackendApi {
@@ -8,7 +8,7 @@ class GearboxBackendApi {
     const domain = CHARTS_BACKEND_ADDRESS;
     const priceSourceArr = priceSource ? [priceSource] : [];
     const isMain = isSupportedNetwork(chainId);
-    const relativePath = URLApi.getRelativeUrl(
+    const relativePath = getRelativeUrl(
       url,
       isMain ? {
         ...options,
@@ -27,20 +27,15 @@ class GearboxBackendApi {
     const url = `https://dm.gearbox.finance/${network.toLowerCase()}_${root}.json`;
     return url;
   };
-  static apyAllRewards = () => URLApi.getRelativeUrl(
+  static apyAllRewards = () => getRelativeUrl(
     "https://state-cache.gearbox.foundation/apy-server/latest.json"
   );
 }
-class URLApi {
-  constructor() {
-  }
-  static getRelativeUrl = (url, options) => {
-    const { params = {} } = options || {};
-    const paramsString = Object.entries(params).map(([key, value]) => `${key}=${value}`).join("&");
-    return [url, ...paramsString ? [paramsString] : []].join("?");
-  };
-}
+const getRelativeUrl = (url, options) => {
+  const { params = {} } = options || {};
+  const paramsString = Object.entries(params).map(([key, value]) => `${key}=${value}`).join("&");
+  return [url, ...paramsString ? [paramsString] : []].join("?");
+};
 export {
-  GearboxBackendApi,
-  URLApi
+  GearboxBackendApi
 };

package/dist/esm/common-utils/utils/index.js

@@ -0,0 +1,5 @@
+export * from "./assetsMath.js";
+export * from "./bigintMath.js";
+export * from "./creditAccount/index.js";
+export * from "./endpoints.js";
+export * from "./priceMath.js";

package/dist/esm/common-utils/utils/priceMath.js

@@ -0,0 +1,42 @@
+import { PRICE_DECIMALS, WAD } from "../../sdk/index.js";
+class PriceUtils {
+  /**
+   * This class is intentionally non-instantiable.
+   */
+  constructor() {
+  }
+  /**
+   * Calculates normalized total value for a token amount at a given price.
+   *
+   * Formula:
+   * `(amount * WAD * price) / 10^decimals / PRICE_DECIMALS`
+   *
+   * @param price Token unit price in `PRICE_DECIMALS` precision.
+   * @param amount Token amount in raw token units.
+   * @param decimals Token decimals used to normalize `amount` (defaults to `18`).
+   * @returns Total value in WAD-normalized units.
+   */
+  static calcTotalPrice = (price, amount, decimals = 18) => amount * WAD * price / 10n ** BigInt(decimals) / PRICE_DECIMALS;
+  /**
+   * Converts a normalized monetary value into target token amount by price.
+   *
+   * Formula:
+   * `(totalMoney * 10^targetDecimals * PRICE_DECIMALS) / targetPrice / WAD`
+   *
+   * Safety behavior:
+   * - returns `0n` when `targetPrice <= 0n` to avoid invalid division
+   *
+   * @param totalMoney Value to convert, expected in WAD-normalized units.
+   * @param target Conversion target configuration:
+   * - `price`: target token unit price in `PRICE_DECIMALS` precision
+   * - `decimals`: target token decimals (defaults to `18`)
+   * @returns Target token amount in raw token units.
+   */
+  static convertByPrice(totalMoney, { price: targetPrice, decimals: targetDecimals = 18 }) {
+    if (targetPrice <= 0n) return 0n;
+    return totalMoney * 10n ** BigInt(targetDecimals) * PRICE_DECIMALS / targetPrice / WAD;
+  }
+}
+export {
+  PriceUtils
+};

package/dist/esm/permissionless/bindings/cross-chain-multisig.js

@@ -16,8 +16,8 @@ import { InstanceManagerContract } from "./instance-manager.js";
 import { MarketConfiguratorFactoryContract } from "./market-configurator-factory.js";
 const abi = crossChainMultisigAbi;
 class CrossChainMultisigContract extends BaseContract {
-  constructor(addr, client) {
-    super({ client }, { abi, addr, name: "CrossChainMultisig" });
+  constructor(addr, register) {
+    super({ register }, { abi, addr, name: "CrossChainMultisig" });
   }
   async getExecutedBatches(fromBlock, toBlock) {
     const events = await this.getEvents("ExecuteBatch", fromBlock, toBlock);
@@ -170,7 +170,7 @@ class CrossChainMultisigContract extends BaseContract {
       case Addresses.INSTANCE_MANAGER.toLowerCase(): {
         const instanceManager = new InstanceManagerContract(
           target,
-          this.client
+          this.register
         );
         return instanceManager.parseFunctionData(calldata);
       }

package/dist/esm/permissionless/bindings/instance-manager.js

@@ -22,8 +22,8 @@ import { RoutingManagerContract } from "./router/index.js";
 import { TreasurySplitterContract } from "./treasury-splitter.js";
 const abi = instanceManagerAbi;
 class InstanceManagerContract extends BaseContract {
-  constructor(addr, client) {
-    super({ client }, { abi, addr, name: "InstanceManager" });
+  constructor(addr, register) {
+    super({ register }, { abi, addr, name: "InstanceManager" });
   }
   // TODO:
   #decodeFunctionData(target, calldata) {

package/dist/esm/plugins/adapters/contracts/MellowDepositQueueAdapterContract.js

@@ -48,12 +48,6 @@ class MellowDepositQueueAdapterContract extends AbstractAdapterContract {
       referral: this.#referral ? this.labelAddress(this.#referral) : void 0
     };
   }
-  /** Legacy adapter not present in integrations-v3. */
-  classifyLegacyOperation(_parsed, _transfers) {
-    throw new Error(
-      `classifyLegacyOperation is not supported for legacy adapter: ${this.contractType}`
-    );
-  }
 }
 export {
   MellowDepositQueueAdapterContract

package/dist/esm/plugins/adapters/contracts/MellowRedeemQueueAdapterContract.js

@@ -40,12 +40,6 @@ class MellowRedeemQueueAdapterContract extends AbstractAdapterContract {
       phantomToken: this.#phantomToken ? this.labelAddress(this.#phantomToken) : void 0
     };
   }
-  /** Legacy adapter not present in integrations-v3. */
-  classifyLegacyOperation(_parsed, _transfers) {
-    throw new Error(
-      `classifyLegacyOperation is not supported for legacy adapter: ${this.contractType}`
-    );
-  }
 }
 export {
   MellowRedeemQueueAdapterContract

package/dist/esm/sdk/GearboxSDK.js

@@ -144,8 +144,6 @@ class GearboxSDK extends ChainContractsRegister {
     if (options.gasLimit !== null) {
       this.gasLimit = options.gasLimit || 550000000n;
     }
-    Object.assign(this, ChainContractsRegister.for(this.client, this.logger));
-    this.resetContracts();
   }
   async #attach(opts) {
     const {

package/dist/esm/sdk/base/BaseContract.js

@@ -57,8 +57,11 @@ class BaseContract extends Construct {
       this.contractType = bytes32ToString(this.contractType);
     }
     this.name = args.name || this.contractType || this.address || this.constructor.name;
-    this.register.setContract(this.address, this);
-    this.register.setAddressLabel(this.address, this.name);
+    const register = this.safeGetRegister();
+    if (register) {
+      register.setContract(this.address, this);
+      register.setAddressLabel(this.address, this.name);
+    }
   }
   stateHuman(_ = true) {
     return {

package/dist/esm/sdk/base/ChainContractsRegister.js

@@ -2,16 +2,6 @@ import { NOT_DEPLOYED } from "../constants/addresses.js";
 import { AddressMap } from "../utils/AddressMap.js";
 import { TokensMeta } from "./TokensMeta.js";
 class ChainContractsRegister {
-  static #chains = /* @__PURE__ */ new Map();
-  static for(client, logger) {
-    const chainId = client.chain.id;
-    let result = ChainContractsRegister.#chains.get(chainId);
-    if (!result) {
-      result = new ChainContractsRegister(client, logger);
-      ChainContractsRegister.#chains.set(chainId, result);
-    }
-    return result;
-  }
   contracts = new AddressMap(
     [],
     "contracts"
@@ -32,7 +22,9 @@ class ChainContractsRegister {
     this.logger?.debug(
       `resetting contacts register with ${this.contracts.size} contracts`
     );
+    this.labels.clear();
     this.contracts.clear();
+    this.tokensMeta.reset();
   }
   getContract(address) {
     return this.contracts.get(address);

package/dist/esm/sdk/base/Construct.js

@@ -3,27 +3,41 @@ import { ChainContractsRegister } from "./ChainContractsRegister.js";
 class Construct {
   logger;
   client;
-  register;
+  #register;
   /**
    * Indicates that contract state needs to be updated
    */
   #dirty = false;
   constructor(options) {
-    const { logger } = options;
-    if ("client" in options) {
-      const { client } = options;
-      this.client = client;
-      this.register = ChainContractsRegister.for(client, logger);
+    if (options instanceof ChainContractsRegister) {
+      this.#register = options;
+      this.client = options.client;
+    } else if ("register" in options) {
+      this.#register = options.register;
+      this.client = options.register.client;
     } else {
-      const { register } = options;
-      this.register = register;
-      this.client = register.client;
+      this.client = options.client;
     }
     this.logger = childLogger(
       this.constructor.name,
-      this.register.logger ?? logger
+      this.#register?.logger ?? options.logger
     );
   }
+  /**
+   * Throws if register was not provided in constructor options
+   * Ephemeral contracts that do not need to access other contracts may not need it
+   */
+  get register() {
+    if (!this.#register) {
+      throw new Error(
+        "contracts register not available, it must be provided if contract needs to access other contracts"
+      );
+    }
+    return this.#register;
+  }
+  safeGetRegister() {
+    return this.#register;
+  }
   get chain() {
     return this.client.chain;
   }
@@ -45,19 +59,11 @@ class Construct {
   set dirty(value) {
     this.#dirty = value;
   }
-  /**
-   * Syntax sugar for rgister.tokensMeta
-   */
   get tokensMeta() {
     return this.register.tokensMeta;
   }
-  /**
-   * Syntax suggar for getting contract labels
-   * @param address
-   * @returns
-   */
   labelAddress(address, omitAddress) {
-    return this.register.labelAddress(address, omitAddress);
+    return this.#register?.labelAddress(address, omitAddress) ?? address;
   }
   /**
    * Returns list of addresses that should be watched for events to sync state

package/dist/esm/sdk/base/SDKConstruct.js

@@ -2,7 +2,7 @@ import { Construct } from "./Construct.js";
 class SDKConstruct extends Construct {
   sdk;
   constructor(sdk) {
-    super(sdk);
+    super({ register: sdk });
     this.sdk = sdk;
   }
 }

package/dist/esm/sdk/market/adapters/PlaceholderAdapterContracts.js

@@ -1,11 +1,21 @@
+import { decodeAbiParameters } from "viem";
 import {
   MissingSerializedParamsError,
   PlaceholderContract
 } from "../../base/index.js";
 class PlaceholderAdapterContract extends PlaceholderContract {
   #targetContract;
+  #creditManager;
   constructor(options, args) {
     super(options, args.baseParams);
+    if (args.baseParams.serializedParams) {
+      const [cm, tc] = decodeAbiParameters(
+        [{ type: "address" }, { type: "address" }],
+        args.baseParams.serializedParams
+      );
+      this.#creditManager = cm;
+      this.#targetContract = tc;
+    }
   }
   get targetContract() {
     if (!this.#targetContract) {
@@ -13,6 +23,12 @@ class PlaceholderAdapterContract extends PlaceholderContract {
     }
     return this.#targetContract;
   }
+  get creditManager() {
+    if (!this.#creditManager) {
+      throw new MissingSerializedParamsError("creditManager");
+    }
+    return this.#creditManager;
+  }
 }
 export {
   PlaceholderAdapterContract

package/dist/esm/sdk/market/pricefeeds/updates/PriceUpdatesCache.js

@@ -1,21 +1,4 @@
 class PriceUpdatesCache {
-  static #caches = /* @__PURE__ */ new Map();
-  /**
-   * Price update caches can be shared across networks
-   * @param id - unique key to identify the cache
-   * @param opts
-   * @returns
-   */
-  static get(id, opts) {
-    const key = `${id}:${opts.historical ? "historical" : "latest"}:${opts.ttl}`;
-    const cache = PriceUpdatesCache.#caches.get(key);
-    if (cache) {
-      return cache;
-    }
-    const newCache = new PriceUpdatesCache(opts);
-    PriceUpdatesCache.#caches.set(key, newCache);
-    return newCache;
-  }
   #cache = /* @__PURE__ */ new Map();
   #ttlMs;
   #historical;

package/dist/esm/sdk/market/pricefeeds/updates/PythUpdater.js

@@ -44,7 +44,7 @@ class PythUpdater extends SDKConstruct {
         `using historical timestamp ${this.#historicalTimestamp}`
       );
     }
-    this.#cache = PriceUpdatesCache.get("pyth", {
+    this.#cache = new PriceUpdatesCache({
       // currently staleness period is 240 seconds on all networks, add some buffer
       // this period of 4 minutes is selected based on time that is required for user to sign transaction with wallet
       // so it's unlikely to decrease

package/dist/esm/sdk/market/pricefeeds/updates/RedstoneUpdater.js

@@ -52,7 +52,7 @@ class RedstoneUpdater extends SDKConstruct {
         `using historical timestamp ${this.#historicalTimestampMs}`
       );
     }
-    this.#cache = PriceUpdatesCache.get("redstone", {
+    this.#cache = new PriceUpdatesCache({
       // currently staleness period is 240 seconds on all networks, add some buffer
       // this period of 4 minutes is selected based on time that is required for user to sign transaction with wallet
       // so it's unlikely to decrease