@gearbox-protocol/sdk 13.6.0-kyc.7 → 14.0.0-next.1

package/dist/esm/history/errors.js

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

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/plugins/adapters/abi/actionAbi.js

@@ -48,7 +48,7 @@ const adapterActionSignatures = {
     310: "function setPairStatusBatch((address,address,address,uint8)[])",
     311: "function setPairStatusBatch((address,address,address,uint8,uint8)[])"
   },
-  [AdapterType.TRADERJOE_ROUTER]: {
+  [AdapterType.TRADER_JOE_ROUTER]: {
     310: "function setPoolStatusBatch((address,address,uint256,uint8,bool)[])"
   },
   [AdapterType.UNISWAP_V2_ROUTER]: {

package/dist/esm/plugins/adapters/abi/conctructorAbi.js

@@ -63,7 +63,7 @@ const adapterConstructorAbi = {
   [AdapterType.DAI_USDS_EXCHANGE]: {
     310: BASIC_ADAPTER_ABI
   },
-  [AdapterType.TRADERJOE_ROUTER]: {
+  [AdapterType.TRADER_JOE_ROUTER]: {
     310: BASIC_ADAPTER_ABI
   },
   [AdapterType.UNISWAP_V2_ROUTER]: {

package/dist/esm/plugins/adapters/createAdapter.js

@@ -109,7 +109,7 @@ function createAdapter(options, data, strict) {
       return new PendleRouterAdapterContract(options, data);
     case "ADAPTER::STAKING_REWARDS":
       return new StakingRewardsAdapterContract(options, data);
-    case "ADAPTER::TRADERJOE_ROUTER":
+    case "ADAPTER::TRADER_JOE_ROUTER":
       return new TraderJoeRouterAdapterContract(options, data);
     case "ADAPTER::UNISWAP_V2_ROUTER":
       return new UniswapV2AdapterContract(options, data);

package/dist/esm/plugins/adapters/types.js

@@ -36,7 +36,7 @@ var AdapterType = /* @__PURE__ */ ((AdapterType2) => {
   AdapterType2["MIDAS_REDEMPTION_VAULT"] = "MIDAS_REDEMPTION_VAULT";
   AdapterType2["PENDLE_ROUTER"] = "PENDLE_ROUTER";
   AdapterType2["STAKING_REWARDS"] = "STAKING_REWARDS";
-  AdapterType2["TRADERJOE_ROUTER"] = "TRADERJOE_ROUTER";
+  AdapterType2["TRADER_JOE_ROUTER"] = "TRADER_JOE_ROUTER";
   AdapterType2["UNISWAP_V2_ROUTER"] = "UNISWAP_V2_ROUTER";
   AdapterType2["UNISWAP_V3_ROUTER"] = "UNISWAP_V3_ROUTER";
   AdapterType2["UNISWAP_V4_GATEWAY"] = "UNISWAP_V4_GATEWAY";

package/dist/esm/sdk/MultichainSDK.js

@@ -0,0 +1,208 @@
+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;
+  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 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
+          }
+        });
+      })
+    );
+  }
+  /**
+   * 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 !== 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) {
+        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
+        }
+      });
+    }
+  }
+  /**
+   * 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);
+    }
+  }
+  /**
+   * 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
+};