@gearbox-protocol/sdk 13.6.0 → 14.0.0-next.2

package/dist/cjs/dev/index.js

@@ -24,7 +24,6 @@ __export(dev_exports, {
 });
 module.exports = __toCommonJS(dev_exports);
 __reExport(dev_exports, require("./AccountOpener.js"), module.exports);
-__reExport(dev_exports, require("./CachedStateSubscriber.js"), module.exports);
 __reExport(dev_exports, require("./calcLiquidatableLTs.js"), module.exports);
 __reExport(dev_exports, require("./claimFromFaucet.js"), module.exports);
 __reExport(dev_exports, require("./create2.js"), module.exports);
@@ -49,7 +48,6 @@ __reExport(dev_exports, require("./types.js"), module.exports);
   isRangeError,
   logSplitterTransport,
   ...require("./AccountOpener.js"),
-  ...require("./CachedStateSubscriber.js"),
   ...require("./calcLiquidatableLTs.js"),
   ...require("./claimFromFaucet.js"),
   ...require("./create2.js"),

package/dist/cjs/history/errors.js

@@ -61,6 +61,8 @@ class AdapterTraceAlignmentError extends Error {
     this.actual = actual;
     this.name = "AdapterTracesAlignmentError";
   }
+  expected;
+  actual;
 }
 class UnexpectedFacadeEventOrderError extends Error {
   constructor(e) {

package/dist/cjs/permissionless/utils/price-update/get-price-feeds.js

@@ -69,11 +69,17 @@ async function getCallsTouchedUpdatablePriceFeeds({
     import_sdk.AP_PRICE_FEED_COMPRESSOR,
     310n
   );
-  const sdk = await import_sdk.GearboxSDK.attach({
-    client,
-    marketConfigurators: [],
-    gasLimit
-  });
+  const gearboxClient = client;
+  const chain = gearboxClient.chain;
+  if (!chain) {
+    throw new Error("Chain not defined on client");
+  }
+  const sdk = new import_sdk.OnchainSDK(
+    chain.network,
+    { client: gearboxClient },
+    { gasLimit }
+  );
+  await sdk.attach({ marketConfigurators: [] });
   const touchedFeeds = parsedCalls.flatMap(
     (call) => getCallTouchedPriceFeeds(call)
   );

package/dist/cjs/permissionless/utils/price-update/get-price-update-tx.js

@@ -35,11 +35,17 @@ async function getPriceUpdateTx({
     import_addresses.Addresses.PRICE_FEED_STORE,
     client
   );
-  const sdk = await import_sdk.GearboxSDK.attach({
-    client,
-    marketConfigurators: [],
-    gasLimit
-  });
+  const gearboxClient = client;
+  const chain = gearboxClient.chain;
+  if (!chain) {
+    throw new Error("Chain not defined on client");
+  }
+  const sdk = new import_sdk.OnchainSDK(
+    chain.network,
+    { client: gearboxClient },
+    { gasLimit }
+  );
+  await sdk.attach({ marketConfigurators: [] });
   const updateTxs = await sdk.priceFeeds.generateExternalPriceFeedsUpdateTxs(priceFeeds);
   if (useMulticall3) {
     const multicallCalls = updateTxs.txs.map((tx) => ({

package/dist/cjs/permissionless/utils/price-update/get-prices.js

@@ -101,12 +101,18 @@ async function getPrices({
   if (!client.chain) {
     throw new Error("Chain not defined");
   }
-  const sdk = await import_sdk.GearboxSDK.attach({
-    client,
-    gasLimit,
-    marketConfigurators: [],
-    redstone: {},
-    pyth: {}
+  const gearboxClient = client;
+  const chain = gearboxClient.chain;
+  if (!chain) {
+    throw new Error("Chain not defined on client");
+  }
+  const sdk = new import_sdk.OnchainSDK(
+    chain.network,
+    { client: gearboxClient },
+    { gasLimit }
+  );
+  await sdk.attach({
+    marketConfigurators: []
   });
   const chunks = [];
   for (let i = 0; i < priceFeeds.length; i += chunkSize) {

package/dist/cjs/sdk/MultichainSDK.js

@@ -0,0 +1,223 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var MultichainSDK_exports = {};
+__export(MultichainSDK_exports, {
+  MultichainSDK: () => MultichainSDK
+});
+module.exports = __toCommonJS(MultichainSDK_exports);
+var import_chains = require("./chain/chains.js");
+var import_core = require("./core/index.js");
+var import_updates = require("./market/pricefeeds/updates/index.js");
+var import_OnchainSDK = require("./OnchainSDK.js");
+class MultichainSDK {
+  #chains;
+  #redstoneCache;
+  #pythCache;
+  constructor(options) {
+    this.#chains = /* @__PURE__ */ new Map();
+    for (const [network, chainConfig] of Object.entries(options.chains)) {
+      const { gasLimit, ...clientOptions } = chainConfig;
+      let plugins;
+      if (options.plugins) {
+        plugins = Object.fromEntries(
+          Object.entries(options.plugins).map(([name, factory]) => [
+            name,
+            factory()
+          ])
+        );
+      }
+      const sdkOptions = {
+        logger: options.logger?.child?.({ network }),
+        strictContractTypes: options.strictContractTypes,
+        gasLimit: gasLimit ?? options.gasLimit,
+        plugins
+      };
+      const sdk = new import_OnchainSDK.OnchainSDK(
+        network,
+        clientOptions,
+        sdkOptions
+      );
+      this.#chains.set(network, sdk);
+    }
+  }
+  /**
+   * Attach all configured chains in parallel.
+   *
+   * @param options - Shared and per-chain attach options.
+   */
+  async attach(options) {
+    if (options?.redstone) {
+      this.#redstoneCache = new import_updates.PriceUpdatesCache({
+        ttl: options.redstone.cacheTTL ?? 225e3,
+        historical: !!options.redstone.historicTimestamp
+      });
+    }
+    if (options?.pyth) {
+      this.#pythCache = new import_updates.PriceUpdatesCache({
+        ttl: options.pyth.cacheTTL ?? 225e3,
+        historical: !!options.pyth.historicTimestamp
+      });
+    }
+    await Promise.all(
+      [...this.#chains.entries()].map(([network, sdk]) => {
+        const perChainOpts = options?.perChain?.[network] ?? {};
+        return sdk.attach({
+          ...perChainOpts,
+          redstone: {
+            ...options?.redstone,
+            cache: this.#redstoneCache,
+            ...perChainOpts.redstone
+          },
+          pyth: {
+            ...options?.pyth,
+            cache: this.#pythCache,
+            ...perChainOpts.pyth
+          }
+        });
+      })
+    );
+  }
+  /**
+   * Hydrate all configured chains from serialised state.
+   *
+   * @param state - Multichain serialised state.
+   * @param options - Shared and per-chain hydrate options.
+   * @throws {@link SdkStateVersionMismatchError} if version doesn't match.
+   * @throws {@link SdkMissingChainStateError} if a configured chain has no state.
+   */
+  hydrate(state, options) {
+    if (state.version !== import_OnchainSDK.STATE_VERSION) {
+      throw new import_core.SdkStateVersionMismatchError(import_OnchainSDK.STATE_VERSION, state.version);
+    }
+    if (options?.redstone) {
+      this.#redstoneCache = new import_updates.PriceUpdatesCache({
+        ttl: options.redstone.cacheTTL ?? 225e3,
+        historical: !!options.redstone.historicTimestamp
+      });
+    }
+    if (options?.pyth) {
+      this.#pythCache = new import_updates.PriceUpdatesCache({
+        ttl: options.pyth.cacheTTL ?? 225e3,
+        historical: !!options.pyth.historicTimestamp
+      });
+    }
+    const stateByNetwork = new Map(state.chains.map((cs) => [cs.network, cs]));
+    for (const [network, sdk] of this.#chains) {
+      const chainState = stateByNetwork.get(network);
+      if (!chainState) {
+        throw new import_core.SdkMissingChainStateError(network);
+      }
+      const perChainOpts = options?.perChain?.[network] ?? {};
+      sdk.hydrate(chainState, {
+        ...perChainOpts,
+        redstone: {
+          ...options?.redstone,
+          cache: this.#redstoneCache,
+          ...perChainOpts.redstone
+        },
+        pyth: {
+          ...options?.pyth,
+          cache: this.#pythCache,
+          ...perChainOpts.pyth
+        }
+      });
+    }
+  }
+  /**
+   * Returns the {@link OnchainSDK} for a given network or chain ID.
+   *
+   * @param networkOrChainId - Network type string or numeric chain ID.
+   * @throws If the network/chain is not configured.
+   */
+  chain(networkOrChainId) {
+    let network;
+    if (typeof networkOrChainId === "number") {
+      network = (0, import_chains.getNetworkType)(networkOrChainId);
+    } else {
+      network = networkOrChainId;
+    }
+    const sdk = this.#chains.get(network);
+    if (!sdk) {
+      throw new Error(
+        `Chain ${String(networkOrChainId)} is not configured in this MultichainSDK`
+      );
+    }
+    return sdk;
+  }
+  /**
+   * Read-only map of all configured chains.
+   **/
+  get chains() {
+    return this.#chains;
+  }
+  /**
+   * Sync state for all chains in parallel.
+   *
+   * @param opts - Sync options.
+   * @throws {@link SdkSyncFailedError} if any chain fails.
+   */
+  async syncState(opts) {
+    const errors = {};
+    const results = await Promise.allSettled(
+      [...this.#chains.entries()].map(async ([_network, sdk]) => {
+        const block = await sdk.client.getBlock({ blockTag: "latest" });
+        const synced = await sdk.syncState({
+          blockNumber: block.number,
+          timestamp: block.timestamp,
+          ignoreUpdateablePrices: opts?.ignoreUpdateablePrices
+        });
+        if (!synced) {
+          return;
+        }
+      })
+    );
+    for (const [i, result] of results.entries()) {
+      if (result.status === "rejected") {
+        const network = [...this.#chains.keys()][i];
+        errors[network] = result.reason;
+      }
+    }
+    if (Object.keys(errors).length > 0) {
+      throw new import_core.SdkSyncFailedError(errors);
+    }
+  }
+  /**
+   * Serialisable snapshot of all chains' state.
+   **/
+  get state() {
+    return {
+      version: import_OnchainSDK.STATE_VERSION,
+      chains: [...this.#chains.values()].map((sdk) => sdk.state)
+    };
+  }
+  /**
+   * Human-readable snapshot of all chains' state.
+   * @param raw - When `true`, include raw numeric values.
+   */
+  stateHuman(raw) {
+    return {
+      version: import_OnchainSDK.STATE_VERSION,
+      chains: [...this.#chains.values()].map((sdk) => sdk.stateHuman(raw))
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MultichainSDK
+});