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

package/dist/esm/sdk/OnchainSDK.js

@@ -0,0 +1,464 @@
+import {
+  createPublicClient,
+  fallback,
+  http,
+  parseEventLogs
+} from "viem";
+import { ChainContractsRegister } from "./base/index.js";
+import { getChain } from "./chain/index.js";
+import {
+  ADDRESS_PROVIDER_V310,
+  AP_GEAR_TOKEN,
+  AP_ROUTER,
+  isV310,
+  NO_VERSION,
+  VERSION_RANGE_310
+} from "./constants/index.js";
+import {
+  createAddressProvider,
+  hydrateAddressProvider,
+  SdkAlreadyAttachedError,
+  SdkChainMismatchError,
+  SdkNotAttachedError,
+  SdkStateVersionMismatchError
+} from "./core/index.js";
+import { MarketRegister } from "./market/MarketRegister.js";
+import { PriceFeedRegister } from "./market/pricefeeds/index.js";
+import { PluginStateVersionError } from "./plugins/index.js";
+import { createRouter } from "./router/index.js";
+import { formatTimestamp, TypedObjectUtils, toAddress } from "./utils/index.js";
+import { getLogsSafe } from "./utils/viem/index.js";
+const STATE_VERSION = 1;
+function createViemClient(opts, chain) {
+  if ("client" in opts) {
+    return opts.client;
+  }
+  let transport;
+  if ("transport" in opts) {
+    transport = opts.transport;
+  } else {
+    const rpcs = opts.rpcURLs.map(
+      (url) => http(url, {
+        ...opts.httpTransportOptions,
+        timeout: opts.timeout,
+        retryCount: opts.retryCount
+      })
+    );
+    transport = rpcs.length > 1 ? fallback(rpcs) : rpcs[0];
+  }
+  return createPublicClient({ transport, chain });
+}
+class OnchainSDK extends ChainContractsRegister {
+  /** Registered plugin instances, keyed by plugin name. */
+  plugins;
+  #currentBlock;
+  #timestamp;
+  #syncing = false;
+  #attached = false;
+  #addressProvider;
+  #marketRegister;
+  #priceFeeds;
+  /**
+   * Gas limit applied to read-only `eth_call` requests.
+   **/
+  gasLimit;
+  /**
+   * When `true`, the SDK throws on unrecognised contract types.
+   **/
+  strictContractTypes;
+  /**
+   * @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 = getChain(network);
+    if ("client" in clientOptions) {
+      const clientChainId = clientOptions.client.chain?.id;
+      if (clientChainId !== void 0 && clientChainId !== gearboxChain.id) {
+        throw new SdkChainMismatchError(gearboxChain.id, clientChainId);
+      }
+    }
+    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 ?? getChain(this.networkType).gasLimit;
+    }
+  }
+  /**
+   * 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 SdkAlreadyAttachedError();
+    }
+    const {
+      addressProvider = ADDRESS_PROVIDER_V310,
+      blockNumber,
+      ignoreUpdateablePrices,
+      ignoreMarkets,
+      marketConfigurators: mcs,
+      redstone,
+      pyth
+    } = options ?? {};
+    const marketConfigurators = mcs ?? TypedObjectUtils.keys(
+      this.client.chain.defaultMarketConfigurators
+    );
+    this.logger?.info(
+      {
+        networkType: this.networkType,
+        chainId: this.chainId,
+        addressProvider,
+        marketConfigurators,
+        blockNumber,
+        ignoreMarkets
+      },
+      "attaching sdk"
+    );
+    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(
+        "attaching to fixed block number, but redstone historicTimestamp is not set. price updates might fail"
+      );
+    }
+    if (!!blockNumber && !pyth?.historicTimestamp && time - Number(block.timestamp) * 1e3 > 60 * 1e3) {
+      this.logger?.warn(
+        "attaching to fixed block number, but pyth historicTimestamp is not set. price updates might fail"
+      );
+    }
+    this.#priceFeeds = new PriceFeedRegister(this, { redstone, pyth });
+    this.logger?.debug(
+      `attach block number ${this.currentBlock} timestamp ${this.timestamp}`
+    );
+    this.#addressProvider = await createAddressProvider(this, addressProvider);
+    this.logger?.debug(
+      `address provider version: ${this.#addressProvider.version}`
+    );
+    await this.#addressProvider.syncState(this.currentBlock);
+    this.#marketRegister = new MarketRegister(this, ignoreMarkets);
+    await this.#marketRegister.loadMarkets(
+      marketConfigurators,
+      ignoreUpdateablePrices
+    );
+    const pluginsList = TypedObjectUtils.entries(this.plugins);
+    const pluginResponse = await Promise.allSettled(
+      pluginsList.map(([name, plugin]) => {
+        if (plugin.attach) {
+          this.logger?.debug(`attaching plugin ${name}`);
+          return plugin.attach();
+        }
+        return void 0;
+      })
+    );
+    pluginResponse.forEach((r, i) => {
+      const [name, plugin] = pluginsList[i];
+      if (plugin.attach && r.status === "fulfilled") {
+        this.logger?.debug(`attached plugin ${name}`);
+      } else if (plugin.attach && r.status === "rejected") {
+        this.logger?.error(r.reason, `failed to attach plugin ${name}`);
+      }
+    });
+    this.logger?.info(`attach time: ${Date.now() - time} ms`);
+    this.#attached = true;
+  }
+  /**
+   * 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 SdkAlreadyAttachedError();
+    }
+    if (state.version !== STATE_VERSION) {
+      throw new SdkStateVersionMismatchError(STATE_VERSION, state.version);
+    }
+    if (state.network !== this.networkType) {
+      throw new 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 PriceFeedRegister(this, { redstone, pyth });
+    this.#addressProvider = hydrateAddressProvider(this, state.addressProvider);
+    this.logger?.debug(
+      `address provider version: ${this.#addressProvider.version}`
+    );
+    this.#marketRegister = new MarketRegister(this, ignoreMarkets);
+    this.#marketRegister.hydrate(state.markets);
+    for (const [name, plugin] of TypedObjectUtils.entries(this.plugins)) {
+      const pluginState = state.plugins[name];
+      if (plugin.hydrate && pluginState) {
+        if (!pluginState.loaded) {
+          this.logger?.debug(
+            `skipping hydrating plugin ${name} state: not loaded`
+          );
+          continue;
+        }
+        if (pluginState.version !== plugin.version) {
+          throw new PluginStateVersionError(plugin, pluginState);
+        }
+        plugin.hydrate(pluginState);
+      }
+    }
+    this.logger?.info("hydrated sdk state");
+    this.#attached = true;
+  }
+  /** 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.
+   * @param raw - When `true`, include raw numeric values alongside formatted ones.
+   */
+  stateHuman(raw = true) {
+    return {
+      network: this.networkType,
+      block: Number(this.currentBlock),
+      timestamp: formatTimestamp(Number(this.timestamp), raw),
+      core: {
+        addressProviderV3: this.addressProvider.stateHuman(raw)
+      },
+      tokens: this.tokensMeta.values(),
+      plugins: Object.fromEntries(
+        TypedObjectUtils.entries(this.plugins).map(([name, plugin]) => [
+          name,
+          plugin.loaded ? plugin.stateHuman?.(raw) : void 0
+        ])
+      ),
+      ...this.marketRegister.stateHuman(raw)
+    };
+  }
+  /** Serialisable snapshot of the current SDK state. */
+  get state() {
+    return {
+      version: STATE_VERSION,
+      network: this.networkType,
+      chainId: this.chainId,
+      currentBlock: this.currentBlock,
+      timestamp: this.timestamp,
+      addressProvider: this.addressProvider.state,
+      markets: this.marketRegister.state,
+      plugins: Object.fromEntries(
+        TypedObjectUtils.entries(this.plugins).map(([name, plugin]) => [
+          name,
+          plugin.loaded ? { version: plugin.version, loaded: true, ...plugin.state } : { version: plugin.version, loaded: false }
+        ])
+      )
+    };
+  }
+  /**
+   * Incrementally updates SDK state by replaying on-chain events.
+   *
+   * @param opts - Target block and sync behaviour.
+   * @returns `true` if the sync completed successfully.
+   */
+  async syncState(opts) {
+    let { blockNumber, timestamp, ignoreUpdateablePrices } = opts ?? {};
+    if (this.priceFeeds.historical && !ignoreUpdateablePrices) {
+      this.logger?.warn(
+        "syncState is not supported with redstone or pyth historicTimestamp"
+      );
+    }
+    if (!blockNumber || !timestamp) {
+      const block = await this.client.getBlock({
+        blockTag: "latest"
+      });
+      blockNumber = block.number;
+      timestamp = block.timestamp;
+    }
+    if (blockNumber <= this.currentBlock) {
+      return false;
+    }
+    if (this.#syncing) {
+      this.logger?.warn(
+        `cannot sync to ${blockNumber}, already syncing at ${this.currentBlock}`
+      );
+      return false;
+    }
+    this.#syncing = true;
+    const prevBlock = this.currentBlock;
+    const prevTimestamp = this.timestamp;
+    let success = false;
+    try {
+      let delta = Math.floor(Date.now() / 1e3) - Number(timestamp);
+      this.logger?.debug(
+        `syncing state to block ${blockNumber} (delta ${delta}s )...`
+      );
+      const watchAddresses = [
+        ...Array.from(this.marketRegister.watchAddresses),
+        this.addressProvider.address
+      ];
+      const fromBlock = this.currentBlock + 1n;
+      this.logger?.debug(
+        `getting logs from ${watchAddresses.length} addresses in [${fromBlock}:${blockNumber}]`
+      );
+      const logs = await getLogsSafe(this.client, {
+        fromBlock,
+        toBlock: blockNumber,
+        address: watchAddresses
+      });
+      for (const log of logs) {
+        const contract = this.getContract(log.address);
+        if (contract) {
+          const event = parseEventLogs({
+            abi: contract.abi,
+            logs: [log]
+          })[0];
+          contract.processLog(event);
+        }
+      }
+      this.#currentBlock = blockNumber;
+      this.#timestamp = timestamp;
+      await this.marketRegister.syncState(ignoreUpdateablePrices);
+      const pluginsList = TypedObjectUtils.entries(this.plugins);
+      const pluginResponse = await Promise.allSettled(
+        pluginsList.map(([name, plugin]) => {
+          if (plugin.syncState) {
+            this.logger?.debug(`syncing plugin ${name}`);
+            return plugin.syncState();
+          }
+          return void 0;
+        })
+      );
+      pluginResponse.forEach((r, i) => {
+        const [name, plugin] = pluginsList[i];
+        if (plugin.syncState && r.status === "fulfilled") {
+          this.logger?.debug(`synced plugin ${name}`);
+        } else if (plugin.syncState && r.status === "rejected") {
+          this.logger?.error(r.reason, `failed to sync plugin ${name}`);
+        }
+      });
+      delta = Math.floor(Date.now() / 1e3) - Number(timestamp);
+      this.logger?.debug(
+        `synced state to block ${blockNumber} (delta ${delta}s)`
+      );
+      success = true;
+    } catch (e) {
+      this.logger?.error(
+        `sync state to block ${blockNumber} with ts ${timestamp} failed, reverting to old block ${prevBlock} with ts ${prevTimestamp}: ${e}`
+      );
+      this.#currentBlock = prevBlock;
+      this.#timestamp = prevTimestamp;
+    } finally {
+      this.#syncing = false;
+    }
+    return success;
+  }
+  /**
+   * Block number that the SDK state corresponds to.
+   * @throws {@link SdkNotAttachedError} if not attached.
+   */
+  get currentBlock() {
+    if (this.#currentBlock === void 0) {
+      throw new SdkNotAttachedError();
+    }
+    return this.#currentBlock;
+  }
+  /**
+   * Block timestamp (Unix epoch seconds) corresponding to {@link currentBlock}.
+   * @throws {@link SdkNotAttachedError} if not attached.
+   */
+  get timestamp() {
+    if (this.#timestamp === void 0) {
+      throw new SdkNotAttachedError();
+    }
+    return this.#timestamp;
+  }
+  /**
+   * Global registry of all price feeds known to the SDK.
+   * @throws {@link SdkNotAttachedError} if not attached.
+   */
+  get priceFeeds() {
+    if (this.#priceFeeds === void 0) {
+      throw new SdkNotAttachedError();
+    }
+    return this.#priceFeeds;
+  }
+  /** GEAR governance token address, or `undefined` if not listed. */
+  get gear() {
+    try {
+      const g = this.addressProvider.getAddress(AP_GEAR_TOKEN, NO_VERSION);
+      return g;
+    } catch (e) {
+      this.logger?.warn(e);
+      return void 0;
+    }
+  }
+  /**
+   * The chain's address provider contract.
+   * @throws {@link SdkNotAttachedError} if not attached.
+   */
+  get addressProvider() {
+    if (this.#addressProvider === void 0) {
+      throw new SdkNotAttachedError();
+    }
+    return this.#addressProvider;
+  }
+  /**
+   * Registry of all loaded markets.
+   * @throws {@link SdkNotAttachedError} if not attached.
+   */
+  get marketRegister() {
+    if (this.#marketRegister === void 0) {
+      throw new SdkNotAttachedError();
+    }
+    return this.#marketRegister;
+  }
+  /**
+   * Resolves the appropriate router contract for a given credit manager,
+   * credit facade, or explicit version range.
+   */
+  routerFor(params) {
+    let routerRange;
+    if (Array.isArray(params)) {
+      routerRange = params;
+    } else {
+      let facadeAddr;
+      if ("creditFacade" in params) {
+        facadeAddr = toAddress(params.creditFacade);
+      } else {
+        const cm = this.marketRegister.findCreditManager(
+          toAddress(params.creditManager)
+        );
+        facadeAddr = cm.creditFacade.address;
+      }
+      const facadeV = this.mustGetContract(facadeAddr).version;
+      if (isV310(facadeV)) {
+        routerRange = VERSION_RANGE_310;
+      } else {
+        throw new Error(`Unsupported credit facade version ${facadeV}`);
+      }
+    }
+    const routerEntry = this.addressProvider.getLatest(AP_ROUTER, routerRange);
+    if (!routerEntry) {
+      throw new Error(`router not found in version range ${routerRange}`);
+    }
+    const [routerAddr, routerV] = routerEntry;
+    return createRouter(this, routerAddr, routerV);
+  }
+}
+export {
+  OnchainSDK,
+  STATE_VERSION
+};

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

@@ -0,0 +1,48 @@
+import { BaseError } from "viem";
+class SdkNotAttachedError extends BaseError {
+  name = "SdkNotAttachedError";
+  constructor() {
+    super("SDK is not attached \u2014 call attach() or hydrate() first");
+  }
+}
+class SdkAlreadyAttachedError extends BaseError {
+  name = "SdkAlreadyAttachedError";
+  constructor() {
+    super("SDK is already attached");
+  }
+}
+class SdkStateVersionMismatchError extends BaseError {
+  name = "SdkStateVersionMismatchError";
+  constructor(expected, actual) {
+    super(`State version mismatch: expected ${expected}, got ${actual}`);
+  }
+}
+class SdkChainMismatchError extends BaseError {
+  name = "SdkChainMismatchError";
+  constructor(expected, actual) {
+    super(`Chain mismatch: expected ${expected}, got ${actual}`);
+  }
+}
+class SdkMissingChainStateError extends BaseError {
+  name = "SdkMissingChainStateError";
+  constructor(network) {
+    super(`Hydration state missing for configured chain: ${network}`);
+  }
+}
+class SdkSyncFailedError extends BaseError {
+  name = "SdkSyncFailedError";
+  perChainErrors;
+  constructor(perChainErrors) {
+    const chains = Object.keys(perChainErrors).join(", ");
+    super(`syncState failed for chains: ${chains}`);
+    this.perChainErrors = perChainErrors;
+  }
+}
+export {
+  SdkAlreadyAttachedError,
+  SdkChainMismatchError,
+  SdkMissingChainStateError,
+  SdkNotAttachedError,
+  SdkStateVersionMismatchError,
+  SdkSyncFailedError
+};

package/dist/esm/sdk/core/index.js

@@ -1,3 +1,4 @@
 export * from "./AddressProviderV310Contract.js";
 export * from "./createAddressProvider.js";
+export * from "./errors.js";
 export * from "./types.js";

package/dist/esm/sdk/index.js

@@ -3,8 +3,9 @@ export * from "./base/index.js";
 export * from "./chain/index.js";
 export * from "./constants/index.js";
 export * from "./core/index.js";
-export * from "./GearboxSDK.js";
+export * from "./MultichainSDK.js";
 export * from "./market/index.js";
+export * from "./OnchainSDK.js";
 export * from "./options.js";
 export * from "./plugins/index.js";
 export * from "./pools/index.js";

package/dist/esm/sdk/market/pricefeeds/PriceFeedsRegister.js

@@ -328,6 +328,13 @@ class PriceFeedRegister extends SDKConstruct {
   get latestUpdate() {
     return this.#latestUpdate;
   }
+  /**
+   * @internal
+   * Returns true if any of the updaters are in historical mode
+   */
+  get historical() {
+    return this.#updaters.some((u) => u.historical);
+  }
 }
 export {
   PriceFeedRegister

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

@@ -30,6 +30,9 @@ const PythOptions = z.object({
 });
 class PythUpdater extends SDKConstruct {
   #cache;
+  /**
+   * Fixed pyth historic timestamp in seconds
+   */
   #historicalTimestamp;
   #apiProxy;
   #failOnMissingFeeds;
@@ -44,10 +47,7 @@ class PythUpdater extends SDKConstruct {
         `using historical timestamp ${this.#historicalTimestamp}`
       );
     }
-    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
+    this.#cache = opts.cache ?? new PriceUpdatesCache({
       ttl: cacheTTL ?? 225 * 1e3,
       historical: !!historicTimestamp
     });
@@ -96,6 +96,9 @@ class PythUpdater extends SDKConstruct {
     );
     return results;
   }
+  get historical() {
+    return !!this.#historicalTimestamp;
+  }
   /**
    * Gets pyth payloads
    * @param dataFeedsIds

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

@@ -52,10 +52,7 @@ class RedstoneUpdater extends SDKConstruct {
         `using historical timestamp ${this.#historicalTimestampMs}`
       );
     }
-    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
+    this.#cache = opts.cache ?? new PriceUpdatesCache({
       ttl: opts.cacheTTL ?? 225 * 1e3,
       historical: !!ts
     });
@@ -126,6 +123,9 @@ class RedstoneUpdater extends SDKConstruct {
     );
     return results;
   }
+  get historical() {
+    return !!this.#historicalTimestampMs;
+  }
   /**
    * Gets payloads, retries once if it has expired while inflight
    * @param dataServiceId

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

@@ -1,8 +1,10 @@
 export * from "./fetchPythPayloads.js";
 export * from "./fetchRedstonePayloads.js";
+import { PriceUpdatesCache } from "./PriceUpdatesCache.js";
 import { PythOptions, PythUpdater } from "./PythUpdater.js";
 import { RedstoneOptions, RedstoneUpdater } from "./RedstoneUpdater.js";
 export {
+  PriceUpdatesCache,
   PythOptions,
   PythUpdater,
   RedstoneOptions,

package/dist/esm/sdk/options.js

@@ -4,53 +4,13 @@ import {
   RedstoneOptions
 } from "./market/pricefeeds/updates/index.js";
 import { ZodAddress } from "./utils/index.js";
-const SDKOptions = z.object({
-  /**
-   * Override address of the Gearbox AddressProvider contract.
-   * If not set, uses default universal address provider address {@link ADDRESS_PROVIDER_V310}
-   **/
-  addressProvider: ZodAddress().optional(),
-  /**
-   * Addresses of market configurator contracts to load.
-   * If not set, all default market configurators for the chain are loaded
-   * (from {@link GearboxChain.defaultMarketConfigurators})
-   **/
-  marketConfigurators: z.array(ZodAddress()).optional(),
-  /**
-   * Pin SDK to a specific block number during attach.
-   * When set, all on-chain reads use this block instead of `latest`.
-   **/
-  blockNumber: z.union([z.bigint().nonnegative(), z.number().int().nonnegative()]).optional(),
-  /**
-   * Skip fetching updatable price feeds on attach and sync.
-   * Speeds up initialisation when prices are not needed.
-   **/
-  ignoreUpdateablePrices: z.boolean().optional(),
-  /**
-   * Pool addresses whose markets should be skipped during attach/hydrate/sync.
-   **/
-  ignoreMarkets: z.array(ZodAddress()).optional(),
-  /**
-   * When `true`, throw on unrecognised contract types instead of falling
-   * back to a generic contract wrapper.
-   **/
+const OnchainSDKOptionsSchema = z.object({
+  /** When `true`, throw on unrecognised contract types. */
   strictContractTypes: z.boolean().optional(),
-  /**
-   * Plugins that extend SDK functionality.
-   **/
+  /** Plugins that extend SDK functionality. */
   plugins: z.record(z.string(), z.any()).optional(),
-  /**
-   * Custom logger implementation.
-   **/
+  /** Custom logger implementation. */
   logger: z.any(),
-  /**
-   * Options for Redstone price-feed updates.
-   **/
-  redstone: RedstoneOptions.optional(),
-  /**
-   * Options for Pyth price-feed updates.
-   **/
-  pyth: PythOptions.optional(),
   /**
    * Explicit gas limit for read-only `eth_call` requests.
    * `null` disables the gas limit entirely; `undefined` uses the SDK default.
@@ -58,6 +18,23 @@ const SDKOptions = z.object({
    **/
   gasLimit: z.bigint().nonnegative().nullable().optional()
 });
+const AttachOptionsSchema = z.object({
+  /** Override address of the Gearbox AddressProvider contract. */
+  addressProvider: ZodAddress().optional(),
+  /** Addresses of market configurator contracts to load. */
+  marketConfigurators: z.array(ZodAddress()).optional(),
+  /** Pin SDK to a specific block number during attach. */
+  blockNumber: z.union([z.bigint().nonnegative(), z.number().int().nonnegative()]).optional(),
+  /** Skip fetching updatable price feeds on attach and sync. */
+  ignoreUpdateablePrices: z.boolean().optional(),
+  /** Pool addresses whose markets should be skipped. */
+  ignoreMarkets: z.array(ZodAddress()).optional(),
+  /** Options for Redstone price-feed updates. */
+  redstone: RedstoneOptions.optional(),
+  /** Options for Pyth price-feed updates. */
+  pyth: PythOptions.optional()
+});
 export {
-  SDKOptions
+  AttachOptionsSchema,
+  OnchainSDKOptionsSchema
 };