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

package/dist/cjs/sdk/{GearboxSDK.js → OnchainSDK.js}

@@ -16,12 +16,12 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var GearboxSDK_exports = {};
-__export(GearboxSDK_exports, {
-  GearboxSDK: () => GearboxSDK,
+var OnchainSDK_exports = {};
+__export(OnchainSDK_exports, {
+  OnchainSDK: () => OnchainSDK,
   STATE_VERSION: () => STATE_VERSION
 });
-module.exports = __toCommonJS(GearboxSDK_exports);
+module.exports = __toCommonJS(OnchainSDK_exports);
 var import_viem = require("viem");
 var import_base = require("./base/index.js");
 var import_chain = require("./chain/index.js");
@@ -32,15 +32,13 @@ var import_pricefeeds = require("./market/pricefeeds/index.js");
 var import_plugins = require("./plugins/index.js");
 var import_router = require("./router/index.js");
 var import_utils = require("./utils/index.js");
-var import_internal = require("./utils/internal/index.js");
 var import_viem2 = require("./utils/viem/index.js");
-const ERR_NOT_ATTACHED = new Error("Gearbox SDK not attached");
 const STATE_VERSION = 1;
-function createClient(opts, network) {
-  let transport;
+function createViemClient(opts, chain) {
   if ("client" in opts) {
     return opts.client;
   }
+  let transport;
   if ("transport" in opts) {
     transport = opts.transport;
   } else {
@@ -53,157 +51,72 @@ function createClient(opts, network) {
     );
     transport = rpcs.length > 1 ? (0, import_viem.fallback)(rpcs) : rpcs[0];
   }
-  const chain = network ? (0, import_viem.defineChain)({
-    ...(0, import_chain.getChain)(network.networkType),
-    id: network.chainId
-  }) : void 0;
   return (0, import_viem.createPublicClient)({ transport, chain });
 }
-async function attachClient(options, network) {
-  let { chainId, networkType } = network;
-  const attachClient2 = createClient(options);
-  if (networkType) {
-    if (!chainId) {
-      chainId = (0, import_chain.getChain)(networkType).id;
-    }
-  } else {
-    networkType = await (0, import_chain.detectNetwork)(attachClient2);
-    if (!chainId) {
-      chainId = await attachClient2.getChainId();
-    }
-  }
-  return createClient(options, { networkType, chainId });
-}
-class GearboxSDK extends import_base.ChainContractsRegister {
-  #hooks = new import_internal.Hooks();
-  /**
-   * Registered plugin instances, keyed by plugin name.
-   **/
+class OnchainSDK extends import_base.ChainContractsRegister {
+  /** Registered plugin instances, keyed by plugin name. */
   plugins;
   #currentBlock;
   #timestamp;
   #syncing = false;
+  #attached = false;
   #addressProvider;
-  #attachConfig;
   #marketRegister;
   #priceFeeds;
   /**
    * Gas limit applied to read-only `eth_call` requests.
-   * `undefined` means that gas limit will not be set on read-only calls,
-   * leaving it to rpc provider to decide.
    **/
   gasLimit;
   /**
-   * When `true`, the SDK throws on unrecognised contract types instead of
-   * falling back to a generic contract wrapper.
+   * When `true`, the SDK throws on unrecognised contract types.
    **/
   strictContractTypes;
   /**
-   * Registers a callback for an SDK lifecycle event.
-   *
-   * @see {@link SDKHooks} for available event names.
-   **/
-  addHook = this.#hooks.addHook.bind(this.#hooks);
-  /**
-   * Removes a previously registered lifecycle callback.
-   *
-   * @see {@link SDKHooks} for available event names.
-   **/
-  removeHook = this.#hooks.removeHook.bind(this.#hooks);
-  /**
-   * Creates and initialises a new SDK instance by reading live on-chain state.
-   *
-   * This is the primary way to bootstrap the SDK.  The method connects to the
-   * chain, discovers the address provider and all configured markets, and
-   * attaches any supplied plugins.
-   *
-   * @param options - Combined SDK, client, and (optional) network options.
-   * @returns A fully initialised SDK instance.
-   **/
-  static async attach(options) {
-    const {
-      logger,
-      plugins,
-      blockNumber,
-      redstone,
-      pyth,
-      ignoreUpdateablePrices,
-      ignoreMarkets,
-      marketConfigurators: mcs,
-      strictContractTypes,
-      gasLimit
-    } = options;
-    let { addressProvider } = options;
-    const client = await attachClient(options, options);
-    if (!addressProvider) {
-      addressProvider = import_constants.ADDRESS_PROVIDER_V310;
+   * @param network - Gearbox network type (e.g. `"Mainnet"`, `"Monad"`).
+   * @param clientOptions - Connection options (RPC URLs, transport, or client).
+   * @param options - SDK configuration options.
+   */
+  constructor(network, clientOptions, options) {
+    const gearboxChain = (0, import_chain.getChain)(network);
+    if ("client" in clientOptions) {
+      const clientChainId = clientOptions.client.chain?.id;
+      if (clientChainId !== void 0 && clientChainId !== gearboxChain.id) {
+        throw new import_core.SdkChainMismatchError(gearboxChain.id, clientChainId);
+      }
     }
-    const marketConfigurators = mcs ?? import_utils.TypedObjectUtils.keys(client.chain.defaultMarketConfigurators);
-    return new GearboxSDK({
-      client,
-      logger,
-      plugins,
-      strictContractTypes,
-      gasLimit
-    }).#attach({
-      addressProvider,
-      blockNumber,
-      ignoreUpdateablePrices,
-      ignoreMarkets,
-      marketConfigurators,
-      redstone,
-      pyth
-    });
-  }
-  /**
-   * Creates a new SDK instance from a previously serialised {@link GearboxState}
-   * snapshot, without making any on-chain calls.
-   *
-   * Use this for fast startup when a recent state snapshot is available
-   * (e.g. loaded from a file or received from a backend service).
-   *
-   * @param options - SDK and client options (block number and address provider
-   *   are taken from the snapshot).
-   * @param state - Serialised state obtained from {@link GearboxSDK.state}.
-   * @returns A fully initialised SDK instance.
-   * @throws If the snapshot's {@link STATE_VERSION} does not match.
-   **/
-  static hydrate(options, state) {
-    const { logger, plugins, strictContractTypes, gasLimit, ...rest } = options;
-    const client = createClient(options, {
-      networkType: state.network,
-      chainId: state.chainId
-    });
-    return new GearboxSDK({
-      client,
-      plugins,
-      logger,
-      strictContractTypes,
-      gasLimit
-    }).#hydrate(rest, state);
-  }
-  constructor(options) {
-    super(options.client, options.logger);
-    this.strictContractTypes = options.strictContractTypes ?? false;
-    this.plugins = options.plugins ?? {};
+    const client = createViemClient(clientOptions, gearboxChain);
+    super(client, options?.logger);
+    this.strictContractTypes = options?.strictContractTypes ?? false;
+    this.plugins = options?.plugins ?? {};
     for (const plugin of Object.values(this.plugins)) {
       plugin.sdk = this;
     }
-    if (options.gasLimit !== null) {
-      this.gasLimit = options.gasLimit || (0, import_chain.getChain)(this.networkType).gasLimit;
+    if (options?.gasLimit !== null) {
+      this.gasLimit = options?.gasLimit ?? (0, import_chain.getChain)(this.networkType).gasLimit;
     }
   }
-  async #attach(opts) {
+  /**
+   * Initialises the SDK by reading live on-chain state.
+   *
+   * @param options - Attach configuration.
+   * @throws {@link SdkAlreadyAttachedError} if already attached.
+   */
+  async attach(options) {
+    if (this.#attached) {
+      throw new import_core.SdkAlreadyAttachedError();
+    }
     const {
-      addressProvider,
+      addressProvider = import_constants.ADDRESS_PROVIDER_V310,
       blockNumber,
       ignoreUpdateablePrices,
       ignoreMarkets,
-      marketConfigurators,
+      marketConfigurators: mcs,
       redstone,
       pyth
-    } = opts;
-    const re = this.#attachConfig ? "re" : "";
+    } = options ?? {};
+    const marketConfigurators = mcs ?? import_utils.TypedObjectUtils.keys(
+      this.client.chain.defaultMarketConfigurators
+    );
     this.logger?.info(
       {
         networkType: this.networkType,
@@ -213,30 +126,27 @@ class GearboxSDK extends import_base.ChainContractsRegister {
         blockNumber,
         ignoreMarkets
       },
-      `${re}attaching gearbox sdk`
+      "attaching sdk"
     );
-    if (!!blockNumber && !opts.redstone?.historicTimestamp) {
+    const time = Date.now();
+    const block = await this.client.getBlock(
+      blockNumber ? { blockNumber: BigInt(blockNumber) } : { blockTag: "latest" }
+    );
+    this.#currentBlock = block.number;
+    this.#timestamp = block.timestamp;
+    if (!!blockNumber && !redstone?.historicTimestamp && time - Number(block.timestamp) * 1e3 > 60 * 1e3) {
       this.logger?.warn(
-        `${re}attaching to fixed block number, but redstone historicTimestamp is not set. price updates might fail`
+        "attaching to fixed block number, but redstone historicTimestamp is not set. price updates might fail"
       );
     }
-    if (!!blockNumber && !opts.pyth?.historicTimestamp) {
+    if (!!blockNumber && !pyth?.historicTimestamp && time - Number(block.timestamp) * 1e3 > 60 * 1e3) {
       this.logger?.warn(
-        `${re}attaching to fixed block number, but pyth historicTimestamp is not set. price updates might fail`
+        "attaching to fixed block number, but pyth historicTimestamp is not set. price updates might fail"
       );
     }
-    this.#attachConfig = opts;
-    const time = Date.now();
-    const block = await this.client.getBlock(
-      blockNumber ? { blockNumber: BigInt(blockNumber) } : {
-        blockTag: "latest"
-      }
-    );
-    this.#currentBlock = block.number;
-    this.#timestamp = block.timestamp;
     this.#priceFeeds = new import_pricefeeds.PriceFeedRegister(this, { redstone, pyth });
     this.logger?.debug(
-      `${re}attach block number ${this.currentBlock} timestamp ${this.timestamp}`
+      `attach block number ${this.currentBlock} timestamp ${this.timestamp}`
     );
     this.#addressProvider = await (0, import_core.createAddressProvider)(this, addressProvider);
     this.logger?.debug(
@@ -252,7 +162,7 @@ class GearboxSDK extends import_base.ChainContractsRegister {
     const pluginResponse = await Promise.allSettled(
       pluginsList.map(([name, plugin]) => {
         if (plugin.attach) {
-          this.logger?.debug(`${re}attaching plugin ${name}`);
+          this.logger?.debug(`attaching plugin ${name}`);
           return plugin.attach();
         }
         return void 0;
@@ -261,52 +171,51 @@ class GearboxSDK extends import_base.ChainContractsRegister {
     pluginResponse.forEach((r, i) => {
       const [name, plugin] = pluginsList[i];
       if (plugin.attach && r.status === "fulfilled") {
-        this.logger?.debug(`${re}attached plugin ${name}`);
+        this.logger?.debug(`attached plugin ${name}`);
       } else if (plugin.attach && r.status === "rejected") {
-        this.logger?.error(r.reason, `failed to ${re}attach plugin ${name}`);
+        this.logger?.error(r.reason, `failed to attach plugin ${name}`);
       }
     });
-    this.logger?.info(`${re}attach time: ${Date.now() - time} ms`);
-    return this;
+    this.logger?.info(`attach time: ${Date.now() - time} ms`);
+    this.#attached = true;
   }
-  #hydrate(options, state) {
-    const { logger: _logger, ignoreMarkets, ...opts } = options;
+  /**
+   * Restores SDK state from a previously serialised {@link GearboxState}
+   * snapshot, without making any on-chain calls.
+   *
+   * @param state - Serialised state obtained from {@link OnchainSDK.state}.
+   * @param options - Hydrate configuration.
+   * @throws {@link SdkAlreadyAttachedError} if already attached.
+   * @throws {@link SdkStateVersionMismatchError} if snapshot version doesn't match.
+   * @throws {@link SdkChainMismatchError} if snapshot network doesn't match.
+   */
+  hydrate(state, options) {
+    if (this.#attached) {
+      throw new import_core.SdkAlreadyAttachedError();
+    }
     if (state.version !== STATE_VERSION) {
-      throw new Error(
-        `hydrated state version is ${state.version}, but expected ${STATE_VERSION}`
-      );
+      throw new import_core.SdkStateVersionMismatchError(STATE_VERSION, state.version);
     }
-    const re = this.#attachConfig ? "re" : "";
-    this.logger?.info(
-      { networkType: this.networkType },
-      `${re}hydrating sdk state`
-    );
+    if (state.network !== this.networkType) {
+      throw new import_core.SdkChainMismatchError(this.networkType, state.network);
+    }
+    const { ignoreMarkets, redstone, pyth } = options ?? {};
+    this.logger?.info({ networkType: this.networkType }, "hydrating sdk state");
     this.#currentBlock = state.currentBlock;
     this.#timestamp = state.timestamp;
-    this.#priceFeeds = new import_pricefeeds.PriceFeedRegister(this, {
-      redstone: opts.redstone,
-      pyth: opts.pyth
-    });
+    this.#priceFeeds = new import_pricefeeds.PriceFeedRegister(this, { redstone, pyth });
     this.#addressProvider = (0, import_core.hydrateAddressProvider)(this, state.addressProvider);
     this.logger?.debug(
       `address provider version: ${this.#addressProvider.version}`
     );
     this.#marketRegister = new import_MarketRegister.MarketRegister(this, ignoreMarkets);
     this.#marketRegister.hydrate(state.markets);
-    this.#attachConfig = {
-      ...opts,
-      addressProvider: this.addressProvider.address,
-      marketConfigurators: this.marketRegister.marketConfigurators.map(
-        (m) => m.address
-      ),
-      blockNumber: this.currentBlock
-    };
     for (const [name, plugin] of import_utils.TypedObjectUtils.entries(this.plugins)) {
       const pluginState = state.plugins[name];
       if (plugin.hydrate && pluginState) {
         if (!pluginState.loaded) {
           this.logger?.debug(
-            `skipping ${re}hydrating plugin ${name} state: not loaded`
+            `skipping hydrating plugin ${name} state: not loaded`
           );
           continue;
         }
@@ -316,66 +225,20 @@ class GearboxSDK extends import_base.ChainContractsRegister {
         plugin.hydrate(pluginState);
       }
     }
-    this.logger?.info(`${re}hydrated sdk state`);
-    return this;
+    this.logger?.info("hydrated sdk state");
+    this.#attached = true;
   }
-  /**
-   * Re-attaches the SDK using the same configuration, discarding all cached
-   * state and re-reading everything from the chain.
-   *
-   * Useful when the SDK needs a full refresh (e.g. after a protocol upgrade).
-   * Note that if the original `blockNumber` was pinned, the same block is
-   * re-used — call {@link syncState} instead if you want to advance.
-   *
-   * @throws If the SDK has not been attached yet.
-   **/
-  async reattach() {
-    if (!this.#attachConfig) {
-      throw new Error("cannot reattach, attach config is not set");
-    }
-    await this.#attach(this.#attachConfig);
-  }
-  /**
-   * Replaces the SDK's in-memory state with a new serialised snapshot
-   * without re-creating the instance.
-   *
-   * After hydration the `rehydrate` hook is triggered so that listeners
-   * can react to the state change.
-   *
-   * @param state - Serialised state obtained from {@link GearboxSDK.state}.
-   * @throws If the SDK has not been attached or hydrated yet.
-   **/
-  async rehydrate(state) {
-    if (!this.#attachConfig) {
-      throw new Error("cannot rehydrate, attach config is not set");
-    }
-    const opts = {
-      ignoreUpdateablePrices: this.#attachConfig.ignoreUpdateablePrices,
-      redstone: this.#attachConfig.redstone,
-      pyth: this.#attachConfig.pyth
-    };
-    this.#hydrate(opts, state);
-    await this.#hooks.triggerHooks("rehydrate", {
-      blockNumber: state.currentBlock,
-      timestamp: state.timestamp
-    });
-  }
-  /**
-   * Gearbox network type the SDK is connected to (e.g. `"Mainnet"`, `"Arbitrum"`).
-   **/
+  /** Gearbox network type the SDK is connected to (e.g. `"Mainnet"`, `"Arbitrum"`). */
   get networkType() {
     return this.client.chain.network;
   }
   /**
-   * Returns a human-readable snapshot of the entire SDK state, suitable
-   * for logging or diagnostic inspection.
-   *
-   * @param raw - When `true`, include raw numeric values alongside
-   *   formatted ones.
-   * @default true
-   **/
+   * Returns a human-readable snapshot of the entire SDK state.
+   * @param raw - When `true`, include raw numeric values alongside formatted ones.
+   */
   stateHuman(raw = true) {
     return {
+      network: this.networkType,
       block: Number(this.currentBlock),
       timestamp: (0, import_utils.formatTimestamp)(Number(this.timestamp), raw),
       core: {
@@ -391,13 +254,7 @@ class GearboxSDK extends import_base.ChainContractsRegister {
       ...this.marketRegister.stateHuman(raw)
     };
   }
-  /**
-   * Serialisable snapshot of the current SDK state.
-   *
-   * The returned object can be persisted (e.g. written to a file) and later
-   * passed to {@link GearboxSDK.hydrate} for instant restoration without
-   * on-chain reads.
-   **/
+  /** Serialisable snapshot of the current SDK state. */
   get state() {
     return {
       version: STATE_VERSION,
@@ -416,28 +273,15 @@ class GearboxSDK extends import_base.ChainContractsRegister {
     };
   }
   /**
-   * Incrementally updates the SDK state by replaying on-chain events from the
-   * last processed block up to the target block (defaults to `latest`).
-   *
-   * Use the to periodically update sdk state on cron, or subscribe to new blocks
-   * using viem's `watchBlocks`
+   * Incrementally updates SDK state by replaying on-chain events.
    *
-   * On failure the SDK reverts to the previous block/timestamp so that
-   * subsequent calls can retry.
-   *
-   * @param opts - Target block and sync behaviour. When omitted the latest
-   *   block is fetched automatically.
-   * @returns `true` if the sync completed successfully, `false` if it was
-   *   skipped or failed.
-   **/
+   * @param opts - Target block and sync behaviour.
+   * @returns `true` if the sync completed successfully.
+   */
   async syncState(opts) {
-    let {
-      blockNumber,
-      timestamp,
-      ignoreUpdateablePrices = this.#attachConfig?.ignoreUpdateablePrices
-    } = opts ?? {};
-    if (this.#attachConfig?.redstone?.historicTimestamp || this.#attachConfig?.pyth?.historicTimestamp) {
-      throw new Error(
+    let { blockNumber, timestamp, ignoreUpdateablePrices } = opts ?? {};
+    if (this.priceFeeds.historical && !ignoreUpdateablePrices) {
+      this.logger?.warn(
         "syncState is not supported with redstone or pyth historicTimestamp"
       );
     }
@@ -492,11 +336,6 @@ class GearboxSDK extends import_base.ChainContractsRegister {
       this.#currentBlock = blockNumber;
       this.#timestamp = timestamp;
       await this.marketRegister.syncState(ignoreUpdateablePrices);
-      await this.#hooks.triggerHooks("syncState", {
-        blockNumber,
-        timestamp,
-        ignoreUpdateablePrices
-      });
       const pluginsList = import_utils.TypedObjectUtils.entries(this.plugins);
       const pluginResponse = await Promise.allSettled(
         pluginsList.map(([name, plugin]) => {
@@ -533,44 +372,35 @@ class GearboxSDK extends import_base.ChainContractsRegister {
   }
   /**
    * Block number that the SDK state corresponds to.
-   *
-   * @throws If the SDK has not been attached or hydrated yet.
-   **/
+   * @throws {@link SdkNotAttachedError} if not attached.
+   */
   get currentBlock() {
     if (this.#currentBlock === void 0) {
-      throw ERR_NOT_ATTACHED;
+      throw new import_core.SdkNotAttachedError();
     }
     return this.#currentBlock;
   }
   /**
    * Block timestamp (Unix epoch seconds) corresponding to {@link currentBlock}.
-   *
-   * @throws If the SDK has not been attached or hydrated yet.
-   **/
+   * @throws {@link SdkNotAttachedError} if not attached.
+   */
   get timestamp() {
     if (this.#timestamp === void 0) {
-      throw ERR_NOT_ATTACHED;
+      throw new import_core.SdkNotAttachedError();
     }
     return this.#timestamp;
   }
   /**
-   * Global registry of all price feeds known to the SDK (on all markets).
-   *
-   * Unlike per-oracle price feed references, this register does not carry
-   * oracle-specific metadata (staleness period, main/reserve designation, etc.).
-   *
-   * @throws If the SDK has not been attached or hydrated yet.
-   **/
+   * Global registry of all price feeds known to the SDK.
+   * @throws {@link SdkNotAttachedError} if not attached.
+   */
   get priceFeeds() {
     if (this.#priceFeeds === void 0) {
-      throw ERR_NOT_ATTACHED;
+      throw new import_core.SdkNotAttachedError();
     }
     return this.#priceFeeds;
   }
-  /**
-   * Address of the GEAR governance token on this chain, or `undefined`
-   * if the address provider does not list it.
-   **/
+  /** GEAR governance token address, or `undefined` if not listed. */
   get gear() {
     try {
       const g = this.addressProvider.getAddress(import_constants.AP_GEAR_TOKEN, import_constants.NO_VERSION);
@@ -581,38 +411,29 @@ class GearboxSDK extends import_base.ChainContractsRegister {
     }
   }
   /**
-   * The chain's address provider contract, the central directory for all
-   * protocol-wide Gearbox protocol addresses.
-   *
-   * @throws If the SDK has not been attached or hydrated yet.
-   **/
+   * The chain's address provider contract.
+   * @throws {@link SdkNotAttachedError} if not attached.
+   */
   get addressProvider() {
     if (this.#addressProvider === void 0) {
-      throw ERR_NOT_ATTACHED;
+      throw new import_core.SdkNotAttachedError();
     }
     return this.#addressProvider;
   }
   /**
-   * Registry of all loaded markets (pools, credit managers, oracles, etc.).
-   *
-   * @throws If the SDK has not been attached or hydrated yet.
-   **/
+   * Registry of all loaded markets.
+   * @throws {@link SdkNotAttachedError} if not attached.
+   */
   get marketRegister() {
     if (this.#marketRegister === void 0) {
-      throw ERR_NOT_ATTACHED;
+      throw new import_core.SdkNotAttachedError();
     }
     return this.#marketRegister;
   }
   /**
    * Resolves the appropriate router contract for a given credit manager,
    * credit facade, or explicit version range.
-   *
-   * @param params - Identifies the context: a credit manager address/state,
-   *   a credit facade address/state, or a {@link VersionRange}.
-   * @returns The matching router contract instance.
-   * @throws If the credit facade version is unsupported or no router is
-   *   registered for the resolved version range.
-   **/
+   */
   routerFor(params) {
     let routerRange;
     if (Array.isArray(params)) {
@@ -644,6 +465,6 @@ class GearboxSDK extends import_base.ChainContractsRegister {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  GearboxSDK,
+  OnchainSDK,
   STATE_VERSION
 });

package/dist/cjs/sdk/core/errors.js

@@ -0,0 +1,77 @@
+"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 errors_exports = {};
+__export(errors_exports, {
+  SdkAlreadyAttachedError: () => SdkAlreadyAttachedError,
+  SdkChainMismatchError: () => SdkChainMismatchError,
+  SdkMissingChainStateError: () => SdkMissingChainStateError,
+  SdkNotAttachedError: () => SdkNotAttachedError,
+  SdkStateVersionMismatchError: () => SdkStateVersionMismatchError,
+  SdkSyncFailedError: () => SdkSyncFailedError
+});
+module.exports = __toCommonJS(errors_exports);
+var import_viem = require("viem");
+class SdkNotAttachedError extends import_viem.BaseError {
+  name = "SdkNotAttachedError";
+  constructor() {
+    super("SDK is not attached \u2014 call attach() or hydrate() first");
+  }
+}
+class SdkAlreadyAttachedError extends import_viem.BaseError {
+  name = "SdkAlreadyAttachedError";
+  constructor() {
+    super("SDK is already attached");
+  }
+}
+class SdkStateVersionMismatchError extends import_viem.BaseError {
+  name = "SdkStateVersionMismatchError";
+  constructor(expected, actual) {
+    super(`State version mismatch: expected ${expected}, got ${actual}`);
+  }
+}
+class SdkChainMismatchError extends import_viem.BaseError {
+  name = "SdkChainMismatchError";
+  constructor(expected, actual) {
+    super(`Chain mismatch: expected ${expected}, got ${actual}`);
+  }
+}
+class SdkMissingChainStateError extends import_viem.BaseError {
+  name = "SdkMissingChainStateError";
+  constructor(network) {
+    super(`Hydration state missing for configured chain: ${network}`);
+  }
+}
+class SdkSyncFailedError extends import_viem.BaseError {
+  name = "SdkSyncFailedError";
+  perChainErrors;
+  constructor(perChainErrors) {
+    const chains = Object.keys(perChainErrors).join(", ");
+    super(`syncState failed for chains: ${chains}`);
+    this.perChainErrors = perChainErrors;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SdkAlreadyAttachedError,
+  SdkChainMismatchError,
+  SdkMissingChainStateError,
+  SdkNotAttachedError,
+  SdkStateVersionMismatchError,
+  SdkSyncFailedError
+});