@gearbox-protocol/sdk 13.7.0-kyc.3 → 14.0.0-next.10

package/dist/esm/dev/RevolverTransport.js

@@ -70,8 +70,14 @@ const revolverTransportConfigSchema = z.union([
   })
 ]);
 class NoAvailableTransportsError extends BaseError {
-  constructor(cause) {
-    super("no available transports", { cause });
+  statuses;
+  constructor(statuses, cause) {
+    super("No available transports", {
+      cause,
+      metaMessages: statuses.length > 0 ? statuses.map((s) => `- ${s.id}: ${s.status}`) : ["No transports configured"],
+      name: "NoAvailableTransportsError"
+    });
+    this.statuses = statuses;
   }
 }
 class RevolverTransport {
@@ -129,7 +135,7 @@ class RevolverTransport {
       );
     }
     if (transports.length === 0) {
-      throw new NoAvailableTransportsError();
+      throw new NoAvailableTransportsError([]);
     }
     this.#isSingle = transports.length === 1;
     const selectionStrategy = config.selectionStrategy ?? "simple";
@@ -180,7 +186,7 @@ class RevolverTransport {
       }
     } while (this.#selector.canRotate());
     this.#requests.delete(r);
-    throw new NoAvailableTransportsError(error);
+    throw new NoAvailableTransportsError(this.#selector.statuses(), error);
   };
   get config() {
     return {

package/dist/esm/dev/index.js

@@ -1,5 +1,4 @@
 export * from "./AccountOpener.js";
-export * from "./CachedStateSubscriber.js";
 export * from "./calcLiquidatableLTs.js";
 export * from "./claimFromFaucet.js";
 export * from "./create2.js";

package/dist/esm/dev/logSplitterTransport.js

@@ -21,7 +21,9 @@ const RANGE_ERROR_PATTERNS = [
   /eth_getLogs is limited to/i,
   /eth_getLogs requests with up to/i,
   /range is too large/i,
-  /exceeded max allowed range/i
+  /exceeded max allowed range/i,
+  // Encountered on DRPC: "query exceeds max results 20000, retry with the range …"
+  /exceeds max results/i
 ];
 function isRangeError(error) {
   const msg = errorMessage(error);
@@ -29,10 +31,17 @@ function isRangeError(error) {
 }
 const GENERIC_BLOCKS_RE = /(\d+)\s*block/i;
 const ALCHEMY_RANGE_RE = /this block range should work: \[(0x[0-9a-fA-F]+),\s*(0x[0-9a-fA-F]+)\]/;
+const DRPC_RANGE_RE = /retry with the range (\d+)-(\d+)/;
 function parsePageSizeHint(error) {
   const alchemy = tryAlchemyHint(error);
   if (alchemy != null) return alchemy;
   const msg = errorMessage(error);
+  const drpc = msg.match(DRPC_RANGE_RE);
+  if (drpc) {
+    const from = Number(drpc[1]);
+    const to = Number(drpc[2]);
+    return to - from + 1;
+  }
   const m = msg.match(GENERIC_BLOCKS_RE);
   return m ? Number(m[1]) : null;
 }

package/dist/esm/permissionless/utils/create2.js

@@ -1,8 +1,8 @@
-import { formatAbiItem } from "abitype";
 import {
   getCreate2Address,
   stringToHex
 } from "viem";
+import { formatAbiItem } from "viem/utils";
 const PUBLIC_CREATE2_FACTORY = "0x4e59b44847b379578588920ca78fbf26c0b4956c";
 function handleSalt(salt) {
   if (salt.slice(0, 2) !== "0x" || salt.length !== 66) {

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

@@ -1,6 +1,6 @@
 import {
   AP_PRICE_FEED_COMPRESSOR,
-  GearboxSDK
+  OnchainSDK
 } from "../../../sdk/index.js";
 import { AddressProviderContract } from "../../bindings/index.js";
 import { Addresses } from "../../deployment/addresses.js";
@@ -47,11 +47,17 @@ async function getCallsTouchedUpdatablePriceFeeds({
     AP_PRICE_FEED_COMPRESSOR,
     310n
   );
-  const sdk = await 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 OnchainSDK(
+    chain.network,
+    { client: gearboxClient },
+    { gasLimit }
+  );
+  await sdk.attach({ marketConfigurators: [] });
   const touchedFeeds = parsedCalls.flatMap(
     (call) => getCallTouchedPriceFeeds(call)
   );

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

@@ -3,8 +3,8 @@ import {
 } from "viem";
 import {
   createRawTx,
-  GearboxSDK,
-  getRawPriceUpdates
+  getRawPriceUpdates,
+  OnchainSDK
 } from "../../../sdk/index.js";
 import { PriceFeedStoreContract } from "../../bindings/index.js";
 import { Addresses } from "../../deployment/addresses.js";
@@ -18,11 +18,17 @@ async function getPriceUpdateTx({
     Addresses.PRICE_FEED_STORE,
     client
   );
-  const sdk = await 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 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/esm/permissionless/utils/price-update/get-prices.js

@@ -1,7 +1,7 @@
 import {
   multicall3Abi
 } from "viem";
-import { GearboxSDK, simulateMulticall } from "../../../sdk/index.js";
+import { OnchainSDK, simulateMulticall } from "../../../sdk/index.js";
 const latestRoundDataAbi = [
   {
     inputs: [],
@@ -80,12 +80,18 @@ async function getPrices({
   if (!client.chain) {
     throw new Error("Chain not defined");
   }
-  const sdk = await 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 OnchainSDK(
+    chain.network,
+    { client: gearboxClient },
+    { gasLimit }
+  );
+  await sdk.attach({
+    marketConfigurators: []
   });
   const chunks = [];
   for (let i = 0; i < priceFeeds.length; i += chunkSize) {

package/dist/esm/sdk/MultichainSDK.js

@@ -0,0 +1,217 @@
+import { getNetworkType } from "./chain/chains.js";
+import {
+  SdkMissingChainStateError,
+  SdkStateVersionMismatchError,
+  SdkSyncFailedError
+} from "./core/index.js";
+import {
+  PriceUpdatesCache
+} from "./market/pricefeeds/updates/index.js";
+import {
+  OnchainSDK,
+  STATE_VERSION
+} from "./OnchainSDK.js";
+class MultichainSDK {
+  #chains;
+  #redstoneCache;
+  #pythCache;
+  #logger;
+  constructor(options) {
+    this.#chains = /* @__PURE__ */ new Map();
+    this.#logger = options.logger;
+    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 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 PriceUpdatesCache({
+        ttl: options.redstone.cacheTTL ?? 225e3,
+        historical: !!options.redstone.historicTimestamp
+      });
+    }
+    if (options?.pyth) {
+      this.#pythCache = new 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
+          }
+        });
+      })
+    );
+    this.#logger?.info("Attached all chains");
+  }
+  /**
+   * 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 and `allowMissingChains` is not set.
+   */
+  hydrate(state, options) {
+    if (state.version !== STATE_VERSION) {
+      throw new SdkStateVersionMismatchError(STATE_VERSION, state.version);
+    }
+    if (options?.redstone) {
+      this.#redstoneCache = new PriceUpdatesCache({
+        ttl: options.redstone.cacheTTL ?? 225e3,
+        historical: !!options.redstone.historicTimestamp
+      });
+    }
+    if (options?.pyth) {
+      this.#pythCache = new 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) {
+        if (options?.allowMissingChains) {
+          continue;
+        }
+        throw new 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
+        }
+      });
+    }
+    this.#logger?.info("Hydrated all chains");
+  }
+  /**
+   * 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 = 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 SdkSyncFailedError(errors);
+    }
+    this.#logger?.info("Synced state for all chains");
+  }
+  /**
+   * Serialisable snapshot of all chains' state.
+   **/
+  get state() {
+    return {
+      version: 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: STATE_VERSION,
+      chains: [...this.#chains.values()].map((sdk) => sdk.stateHuman(raw))
+    };
+  }
+}
+export {
+  MultichainSDK
+};