@gearbox-protocol/sdk 14.12.0-next.81 → 14.12.0-next.82

package/dist/types/new-sdk/types.d.ts

@@ -1,6 +1,5 @@
 import { ILogger } from "../sdk/types/logger.js";
 import { NetworkType } from "../sdk/chain/chains.js";
-import { MultichainNetworkMeta } from "../sdk/types/multichain.js";
 import { MultichainAttachOptions, MultichainSDK, MultichainSDKOptions } from "../sdk/MultichainSDK.js";
 import "../sdk/index.js";
 import { GearboxAPIOptions } from "../offchain/types.js";
@@ -8,89 +7,25 @@ import { GearboxAPI } from "../offchain/GearboxAPI.js";
 import "../offchain/index.js";
 //#region src/new-sdk/types.d.ts
 /**
- * Which sources a {@link GearboxSDK} reads from. Fixed at construction: a
- * running instance never changes mode, and the mode decides which methods
- * exist at all rather than what they return.
+ * Which sources a {@link GearboxSDK} reads from, and therefore which of its
+ * methods exist.
  **/
 type Mode = "onchain" | "offchain" | "both";
 /**
- * Outcome of the off-chain read behind a response.
- **/
-interface OffchainSourceStatus {
-  /**
-   * Whether the backend served the request.
-   **/
-  status: "success" | "error";
-  /**
-   * Rejection reason. Only set when {@link status} is `"error"`.
-   **/
-  error?: unknown;
-}
-/**
- * Which sources produced a response and which of them failed.
- *
- * Meta is always present, in every mode. A partial answer is the normal case
- * for a multi-chain read, so a caller that ignores this block is choosing to
- * treat "one chain is down" as "these opportunities do not exist".
- **/
-interface SourceMeta {
-  /**
-   * Outcome per queried chain. Empty when the read touched no chain, either
-   * because the SDK is off-chain or because a filter selected no chain.
-   **/
-  chains: MultichainNetworkMeta[];
-  /**
-   * Outcome of the off-chain read, absent when the SDK has no backend source.
-   **/
-  offchain?: OffchainSourceStatus;
-}
-/**
- * What every {@link GearboxSDK} read returns.
- *
- * @typeParam T - Payload type.
- **/
-interface ReadResult<T> {
-  /**
-   * Requested payload, built from every source that answered.
-   **/
-  result: T;
-  /**
-   * Which sources produced it, see {@link SourceMeta}.
-   **/
-  meta: SourceMeta;
-}
-/**
- * Thrown when a read had sources to ask and none of them answered.
- *
- * A read that partially succeeded never throws: it returns what it has and
- * reports the rest in {@link SourceMeta}.
- **/
-declare class AllSourcesFailedError extends Error {
-  /**
-   * Outcome of every source the failed read asked.
-   **/
-  readonly meta: SourceMeta;
-  constructor(action: string, meta: SourceMeta);
-}
-/**
- * On-chain source of a {@link GearboxSDK}: either an already-attached SDK to
- * reuse, or the options to build one with.
- *
- * An injected instance is never re-attached — its owner decides when it syncs.
+ * On-chain source of a {@link GearboxSDK}: either an SDK to reuse, which its
+ * owner keeps attaching itself, or the options to build one with.
  **/
 type OnchainSource = MultichainSDK | PlainMultichainSDKOptions;
 /**
  * {@link MultichainSDKOptions} without plugin typing.
- *
- * The facade exposes the on-chain SDK as a plain `MultichainSDK`; a consumer
- * that injects a plugin-typed instance keeps its own typed reference to it.
  **/
 type PlainMultichainSDKOptions = MultichainSDKOptions<{}>;
 /**
  * Off-chain source of a {@link GearboxSDK}: either a client to reuse or the
- * options to build one with.
+ * options to build one with. The chains come from
+ * {@link GearboxSDKOptions.networks} either way.
  **/
-type OffchainSource = GearboxAPI | GearboxAPIOptions;
+type OffchainSource = GearboxAPI | Omit<GearboxAPIOptions, "chainIds">;
 /**
  * Options for creating a {@link GearboxSDK}.
  *
@@ -102,9 +37,8 @@ interface GearboxSDKOptions<M extends Mode = Mode> {
    **/
   mode: M;
   /**
-   * Chains the SDK covers. This list is authoritative: when {@link onchain} is
-   * an already-attached instance covering a different set of chains, the
-   * mismatch is logged and this list still decides what is read.
+   * Chains the SDK covers, which every read of every source is scoped to. An
+   * injected source covering a different set is rejected at construction.
    **/
   networks: NetworkType[];
   /**
@@ -115,14 +49,27 @@ interface GearboxSDKOptions<M extends Mode = Mode> {
    * Off-chain source. Required in `offchain` and `both` mode.
    **/
   offchain?: OffchainSource;
+  /**
+   * How many seconds the backend may lag the chain and still serve a chain in
+   * `both` mode, see {@link DEFAULT_MAX_OFFCHAIN_LAG}.
+   **/
+  maxOffchainLagSeconds?: number;
   /**
    * Options passed to {@link MultichainSDK.attach}, used only when the SDK
    * builds the on-chain source itself.
    **/
   attach?: MultichainAttachOptions;
+  logger?: ILogger;
+}
+/**
+ * What a {@link GearboxSDK} hands every namespace it builds.
+ **/
+interface NamespaceOptions {
   /**
-   * Logger for source selection and degradation diagnostics.
+   * How far the backend may lag the chain, see
+   * {@link GearboxSDKOptions.maxOffchainLagSeconds}.
    **/
+  maxOffchainLagSeconds: number;
   logger?: ILogger;
 }
 /**
@@ -146,4 +93,4 @@ interface OffchainByMode {
   both: GearboxAPI;
 }
 //#endregion
-export { AllSourcesFailedError, GearboxSDKOptions, Mode, OffchainByMode, OffchainSource, OffchainSourceStatus, OnchainByMode, OnchainSource, PlainMultichainSDKOptions, ReadResult, SourceMeta };
+export { GearboxSDKOptions, Mode, NamespaceOptions, OffchainByMode, OffchainSource, OnchainByMode, OnchainSource, PlainMultichainSDKOptions };

package/dist/types/new-sdk/utils/filterResponse.d.ts

@@ -0,0 +1,16 @@
+import { ChainScopedFilter } from "../../model/filters.js";
+import { DataResponse } from "../../model/response.js";
+import "../../model/index.js";
+//#region src/new-sdk/utils/filterResponse.d.ts
+/**
+ * Narrows an already-read list, rows and metadata alike. `undefined` passes
+ * through, so a read still in flight stays that way.
+ *
+ * @typeParam T - Row type.
+ * @typeParam F - Filter type.
+ * @param matches - Whether one row satisfies the filter, e.g.
+ *   `matchesOpportunityFilter`.
+ **/
+declare function filterResponse<T, F extends ChainScopedFilter>(response: DataResponse<T[]> | undefined, filter: F | undefined, matches: (row: T, filter?: F) => boolean): DataResponse<T[]> | undefined;
+//#endregion
+export { filterResponse };

package/dist/types/new-sdk/utils/history.d.ts

@@ -1,48 +1,18 @@
-import { HistoryChartMetadata, HistoryPoint, HistoryRange } from "../../model/history.js";
+import { HistoryRange, HistorySeries } from "../../model/history.js";
+import { DataResponse } from "../../model/response.js";
 import "../../model/index.js";
-import { SourceMeta } from "../types.js";
 //#region src/new-sdk/utils/history.d.ts
-/**
- * Everything that annotates a chart: what the backend said about the series,
- * plus which sources produced it.
- **/
-interface ChartMetadata extends HistoryChartMetadata {
-  /**
-   * Which sources answered, see {@link SourceMeta}. A chart is backend-only,
-   * so this reports the backend alone.
-   **/
-  source: SourceMeta;
-}
-/**
- * One chart: the points to draw and everything that annotates them.
- **/
-interface Chart {
-  /**
-   * Samples, oldest first.
-   **/
-  data: HistoryPoint[];
-  /**
-   * Annotations of the series, see {@link ChartMetadata}.
-   **/
-  metadata: ChartMetadata;
-}
 /**
  * Reads the charts of one subject, one metric and one range at a time.
  *
- * The constraint is `string` rather than {@link HistoryMetric}, matching
- * {@link HistorySeries}: opportunities and positions carry their own metric
- * unions, and those are free to drift apart.
- *
  * @typeParam Metric - Metrics the subject has.
  **/
 interface HistoryReader<Metric extends string> {
   /**
-   * Historical chart of one metric over one window.
-   *
-   * A metric the subject does not have is a compile error rather than an empty
-   * chart.
+   * Historical chart of one metric over one window. A metric the subject does
+   * not have is a compile error.
    **/
-  chart(metric: Metric, range: HistoryRange): Promise<Chart>;
+  chart(metric: Metric, range: HistoryRange): Promise<DataResponse<HistorySeries<Metric>>>;
 }
 //#endregion
-export { Chart, ChartMetadata, HistoryReader };
+export { HistoryReader };

package/dist/types/new-sdk/utils/index.d.ts

@@ -1,2 +1,5 @@
-import { Chart, ChartMetadata, HistoryReader } from "./history.js";
-export { Chart, ChartMetadata, HistoryReader };
+import { filterResponse } from "./filterResponse.js";
+import { HistoryReader } from "./history.js";
+import { DEFAULT_MAX_OFFCHAIN_LAG, mergeChainList, mergeChainOne } from "./mergeChains.js";
+import { SourceMerger } from "./types.js";
+export { DEFAULT_MAX_OFFCHAIN_LAG, HistoryReader, type SourceMerger, filterResponse, mergeChainList, mergeChainOne };

package/dist/types/new-sdk/utils/mergeChains.d.ts

@@ -0,0 +1,20 @@
+import { ChainScoped, DataResponse } from "../../model/response.js";
+import "../../model/index.js";
+//#region src/new-sdk/utils/mergeChains.d.ts
+/**
+ * How many seconds the backend may lag the chain and still be used.
+ **/
+declare const DEFAULT_MAX_OFFCHAIN_LAG = 120;
+/**
+ * Merges two lists chain by chain: a chain is served by the backend when it is
+ * within `maxLagSeconds` of the chain, by the chain otherwise, and reported as
+ * an error when neither source succeeded.
+ **/
+declare function mergeChainList<T extends ChainScoped>(onchain: DataResponse<T[]> | undefined, offchain: DataResponse<T[]> | undefined, maxLagSeconds?: number): DataResponse<T[]> | undefined;
+/**
+ * Merges two versions of one entity under the same freshness rule as
+ * {@link mergeChainList}, returning the winning response whole.
+ **/
+declare function mergeChainOne<T>(onchain: DataResponse<T> | undefined, offchain: DataResponse<T> | undefined, maxLagSeconds?: number): DataResponse<T> | undefined;
+//#endregion
+export { DEFAULT_MAX_OFFCHAIN_LAG, mergeChainList, mergeChainOne };

package/dist/types/new-sdk/utils/types.d.ts

@@ -0,0 +1,11 @@
+import { DataResponse } from "../../model/response.js";
+import "../../model/index.js";
+//#region src/new-sdk/utils/types.d.ts
+/**
+ * How one read combines what the two sources returned.
+ *
+ * @typeParam T - Payload type of the read.
+ **/
+type SourceMerger<T> = (onchain: DataResponse<T> | undefined, offchain: DataResponse<T> | undefined) => DataResponse<T> | undefined;
+//#endregion
+export { SourceMerger };

package/dist/types/offchain/AbstractOffchainNamespace.d.ts

@@ -1,6 +1,9 @@
 import { ILogger } from "../sdk/types/logger.js";
+import { ChainId } from "../model/primitives.js";
+import { ChainScopedFilter } from "../model/filters.js";
 import { HistoryMetric, HistoryRange, HistorySeries } from "../model/history.js";
-import { GearboxAPIOptions, OffchainResult } from "./types.js";
+import { DataResponse } from "../model/response.js";
+import { GearboxAPIOptions } from "./types.js";
 import { z } from "zod/v4";
 //#region src/offchain/AbstractOffchainNamespace.d.ts
 /**
@@ -23,8 +26,7 @@ interface OffchainGetRequest<S extends z.ZodType> {
    **/
   query?: OffchainQuery;
   /**
-   * Schema the payload is decoded with. Decoding is what turns the response
-   * into read model values, so it is required rather than optional.
+   * Schema the payload is decoded with.
    **/
   schema: S;
 }
@@ -39,49 +41,40 @@ interface OffchainHistoryRequest<M extends HistoryMetric> {
    **/
   path: string;
   /**
-   * Metric the response must carry, see
-   * {@link AbstractOffchainNamespace.readHistory}.
+   * Metric the response must carry.
    **/
   metric: M;
-  /**
-   * Window to cover.
-   **/
   range: HistoryRange;
 }
 /**
- * Common logic of every {@link GearboxAPI} namespace.
- *
- * A namespace is a set of routes: it knows which path answers which read and
- * which schema describes the payload. Everything under that — where the
- * backend is, how long a request may take, how a failure is reported and how a
- * response becomes read model values — lives here, so a namespace holds
+ * Base class of every {@link GearboxAPI} namespace: issues the requests,
+ * decodes the responses and reports the failures, so that a namespace holds
  * nothing but its routes.
  **/
 declare abstract class AbstractOffchainNamespace {
   #private;
   protected readonly logger?: ILogger;
-  protected constructor(name: string, options?: GearboxAPIOptions);
+  protected constructor(name: string, options: GearboxAPIOptions);
   /**
    * Base URL every read of this namespace is issued against.
    **/
   get baseUrl(): string | undefined;
   /**
-   * Reads one endpoint and decodes its payload.
-   *
-   * A 2xx body is a {@link DataResponse}. Timeouts, non-2xx, and schema skew
-   * throw — they are not a backend envelope, and this layer is what wraps
-   * them, because the request may never have reached the backend.
+   * Chains one read covers: the configured ones, narrowed by the filter when it
+   * names any. A filter naming a chain this client does not cover narrows
+   * nothing.
+   **/
+  protected scopedChainIds(filter?: ChainScopedFilter): ChainId[];
+  /**
+   * Reads one endpoint and decodes its payload. Timeouts, non-2xx answers and
+   * schema skew throw, since none of them is a {@link DataResponse}.
    **/
-  protected get<S extends z.ZodType>(request: OffchainGetRequest<S>): Promise<OffchainResult<z.output<S>>>;
+  protected get<S extends z.ZodType>(request: OffchainGetRequest<S>): Promise<DataResponse<z.output<S>>>;
   /**
-   * Reads one historical series.
-   *
-   * The requested metric is pinned in the schema, which is what upholds the
-   * `HistorySeries<M>` a caller gets back: a response carrying a different
-   * metric is version skew and fails validation like any other mismatch,
-   * rather than being cast into the requested shape.
+   * Reads one historical series. A response carrying a metric other than the
+   * requested one fails validation.
    **/
-  protected readHistory<M extends HistoryMetric>(request: OffchainHistoryRequest<M>): Promise<OffchainResult<HistorySeries<M>>>;
+  protected readHistory<M extends HistoryMetric>(request: OffchainHistoryRequest<M>): Promise<DataResponse<HistorySeries<M>>>;
 }
 //#endregion
 export { AbstractOffchainNamespace, OffchainGetRequest, OffchainHistoryRequest, OffchainQuery };

package/dist/types/offchain/GearboxAPI.d.ts

@@ -1,3 +1,4 @@
+import { ChainId } from "../model/primitives.js";
 import { GearboxAPIOptions } from "./types.js";
 import { OffchainOpportunities } from "./opportunities/OffchainOpportunities.js";
 import "./opportunities/index.js";
@@ -11,18 +12,21 @@ import "./positions/index.js";
  * call reads the same way against either source:
  *
  * ```ts
- * const api = new GearboxAPI({ baseUrl: "https://api.gearbox.fi" });
- * const { result } = await api.opportunities.list({ kind: "strategy" });
+ * const api = new GearboxAPI({
+ *   baseUrl: "https://api.gearbox.fi",
+ *   chainIds: [1, 42161],
+ * });
+ * const { data } = await api.opportunities.list({ kind: "strategy" });
  * ```
  *
- * The backend imports the read model from this package and its endpoints
- * return those types directly, so there is no wire DTO layer here — only
- * transport and schema validation.
- *
- * The transport is not implemented yet; see {@link OffchainOpportunities} and
- * {@link OffchainPositions} for what each stubbed endpoint currently answers.
+ * Every read is scoped to {@link GearboxAPIOptions.chainIds}, so a client only
+ * ever sees the chains it was built for even though the backend knows more.
  **/
 declare class GearboxAPI {
+  /**
+   * Chains every read of this client is scoped to.
+   **/
+  readonly chainIds: readonly ChainId[];
   /**
    * Namespace for pool and strategy opportunities.
    **/
@@ -31,7 +35,7 @@ declare class GearboxAPI {
    * Namespace for the positions a wallet holds.
    **/
   readonly positions: OffchainPositions;
-  constructor(options?: GearboxAPIOptions);
+  constructor(options: GearboxAPIOptions);
 }
 //#endregion
 export { GearboxAPI };

package/dist/types/offchain/errors/OffchainInvalidJsonError.d.ts

@@ -0,0 +1,16 @@
+import { OffchainTransportError } from "./OffchainTransportError.js";
+//#region src/offchain/errors/OffchainInvalidJsonError.d.ts
+/**
+ * Thrown when the backend answered in the 2xx range with a body that is not
+ * JSON, so there is nothing to validate against the read model.
+ **/
+declare class OffchainInvalidJsonError extends OffchainTransportError {
+  name: string;
+  /**
+   * Status the backend answered with.
+   **/
+  readonly status: number;
+  constructor(url: string, status: number, cause: unknown);
+}
+//#endregion
+export { OffchainInvalidJsonError };

package/dist/types/offchain/errors/OffchainNotConfiguredError.d.ts

@@ -0,0 +1,16 @@
+import { BaseError } from "viem";
+//#region src/offchain/errors/OffchainNotConfiguredError.d.ts
+/**
+ * Thrown when a read is issued against a client that was never told where the
+ * backend is.
+ **/
+declare class OffchainNotConfiguredError extends BaseError {
+  name: string;
+  /**
+   * Path that was read, below the base URL that is missing.
+   **/
+  readonly path: string;
+  constructor(path: string);
+}
+//#endregion
+export { OffchainNotConfiguredError };

package/dist/types/offchain/errors/OffchainNotImplementedError.d.ts

@@ -0,0 +1,15 @@
+import { BaseError } from "viem";
+//#region src/offchain/errors/OffchainNotImplementedError.d.ts
+/**
+ * Thrown by the endpoints that are not implemented yet.
+ **/
+declare class OffchainNotImplementedError extends BaseError {
+  name: string;
+  /**
+   * Endpoint that was asked for.
+   **/
+  readonly endpoint: string;
+  constructor(endpoint: string);
+}
+//#endregion
+export { OffchainNotImplementedError };

package/dist/types/offchain/errors/OffchainRequestFailedError.d.ts

@@ -0,0 +1,12 @@
+import { OffchainTransportError } from "./OffchainTransportError.js";
+//#region src/offchain/errors/OffchainRequestFailedError.d.ts
+/**
+ * Thrown when a request to the backend never completed: the network was down,
+ * or it took longer than {@link GearboxAPIOptions.timeout}.
+ **/
+declare class OffchainRequestFailedError extends OffchainTransportError {
+  name: string;
+  constructor(url: string, cause: unknown);
+}
+//#endregion
+export { OffchainRequestFailedError };

package/dist/types/offchain/errors/OffchainStatusError.d.ts

@@ -0,0 +1,16 @@
+import { OffchainTransportError } from "./OffchainTransportError.js";
+//#region src/offchain/errors/OffchainStatusError.d.ts
+/**
+ * Thrown when the backend answered with a status outside the 2xx range. What it
+ * said about it, when it said anything, is the `details` of the error.
+ **/
+declare class OffchainStatusError extends OffchainTransportError {
+  name: string;
+  /**
+   * Status the backend answered with.
+   **/
+  readonly status: number;
+  constructor(url: string, status: number, body?: string);
+}
+//#endregion
+export { OffchainStatusError };

package/dist/types/offchain/errors/OffchainTransportError.d.ts

@@ -0,0 +1,43 @@
+import { BaseError } from "viem";
+//#region src/offchain/errors/OffchainTransportError.d.ts
+/**
+ * What every transport failure of a backend read names, see
+ * {@link OffchainTransportError}.
+ **/
+interface OffchainTransportErrorParams {
+  /**
+   * URL that was requested, query included.
+   **/
+  url: string;
+  /**
+   * Status the backend answered with, absent when the request never completed.
+   **/
+  status?: number;
+  /**
+   * Value that was caught, normalised by {@link errorCause}.
+   **/
+  cause?: unknown;
+  /**
+   * What the backend itself said. Used only when there is no {@link cause},
+   * whose message viem reports instead.
+   **/
+  details?: string;
+}
+/**
+ * Thrown when the backend could not be reached, or answered with something
+ * other than a JSON body in the 2xx range. Its subclasses say which of the
+ * three it was; catch this one to catch all of them.
+ **/
+declare abstract class OffchainTransportError extends BaseError {
+  /**
+   * URL that was requested, query included.
+   **/
+  readonly url: string;
+  /**
+   * Status the backend answered with, absent when the request never completed.
+   **/
+  readonly status?: number;
+  protected constructor(shortMessage: string, params: OffchainTransportErrorParams);
+}
+//#endregion
+export { OffchainTransportError, OffchainTransportErrorParams };

package/dist/types/offchain/errors/OffchainValidationError.d.ts

@@ -0,0 +1,21 @@
+import { BaseError } from "viem";
+import { z } from "zod/v4";
+//#region src/offchain/errors/OffchainValidationError.d.ts
+/**
+ * Thrown when the backend answered, but with a payload the read model does not
+ * describe, i.e. the two are of different versions.
+ **/
+declare class OffchainValidationError extends BaseError {
+  name: string;
+  /**
+   * URL whose payload failed to validate.
+   **/
+  readonly url: string;
+  /**
+   * The zod failure itself, e.g. for `z.treeifyError(error.zodError)`.
+   **/
+  readonly zodError: z.core.$ZodError;
+  constructor(url: string, zodError: z.core.$ZodError);
+}
+//#endregion
+export { OffchainValidationError };

package/dist/types/offchain/errors/backendMessage.d.ts

@@ -0,0 +1,9 @@
+//#region src/offchain/errors/backendMessage.d.ts
+/**
+ * Why a non-2xx response failed, in the backend's own words: the `message` of a
+ * Gearbox backend error body, the whole body when it is not one, and nothing
+ * when it said nothing at all.
+ **/
+declare function backendMessage(body: string | undefined): string | undefined;
+//#endregion
+export { backendMessage };

package/dist/types/offchain/errors/errorCause.d.ts

@@ -0,0 +1,22 @@
+//#region src/offchain/errors/errorCause.d.ts
+/**
+ * The `cause` / `details` pair viem's `BaseError` accepts, see
+ * {@link errorCause}.
+ **/
+interface ErrorCause {
+  /**
+   * The caught value when it was an `Error`, so `walk()` reaches it.
+   **/
+  cause?: Error;
+  /**
+   * The caught value stringified, when it was not an `Error`.
+   **/
+  details?: string;
+}
+/**
+ * Turns a caught `unknown` into what viem's `BaseError` takes: it types `cause`
+ * as an `Error`, so anything else can only be reported as `details`.
+ **/
+declare function errorCause(error: unknown): ErrorCause;
+//#endregion
+export { ErrorCause, errorCause };

package/dist/types/offchain/errors/index.d.ts

@@ -0,0 +1,11 @@
+import { backendMessage } from "./backendMessage.js";
+import { ErrorCause, errorCause } from "./errorCause.js";
+import { OffchainTransportError, OffchainTransportErrorParams } from "./OffchainTransportError.js";
+import { OffchainInvalidJsonError } from "./OffchainInvalidJsonError.js";
+import { OffchainNotConfiguredError } from "./OffchainNotConfiguredError.js";
+import { OffchainNotImplementedError } from "./OffchainNotImplementedError.js";
+import { OffchainRequestFailedError } from "./OffchainRequestFailedError.js";
+import { OffchainStatusError } from "./OffchainStatusError.js";
+import { OffchainValidationError } from "./OffchainValidationError.js";
+import { readResponseBody } from "./readResponseBody.js";
+export { ErrorCause, OffchainInvalidJsonError, OffchainNotConfiguredError, OffchainNotImplementedError, OffchainRequestFailedError, OffchainStatusError, OffchainTransportError, OffchainTransportErrorParams, OffchainValidationError, backendMessage, errorCause, readResponseBody };

package/dist/types/offchain/errors/readResponseBody.d.ts

@@ -0,0 +1,8 @@
+//#region src/offchain/errors/readResponseBody.d.ts
+/**
+ * Body of a failed response as text, or nothing when it cannot be read: a
+ * failure explaining a failure is not itself worth throwing.
+ **/
+declare function readResponseBody(response: Response): Promise<string | undefined>;
+//#endregion
+export { readResponseBody };

package/dist/types/offchain/index.d.ts

@@ -1,8 +1,19 @@
-import { GearboxAPIOptions, OffchainNotConfiguredError, OffchainNotImplementedError, OffchainResult, OffchainSourceMeta, OffchainTransportError, OffchainValidationError } from "./types.js";
+import { GearboxAPIOptions } from "./types.js";
 import { AbstractOffchainNamespace, OffchainGetRequest, OffchainHistoryRequest, OffchainQuery } from "./AbstractOffchainNamespace.js";
+import { backendMessage } from "./errors/backendMessage.js";
+import { ErrorCause, errorCause } from "./errors/errorCause.js";
+import { OffchainTransportError, OffchainTransportErrorParams } from "./errors/OffchainTransportError.js";
+import { OffchainInvalidJsonError } from "./errors/OffchainInvalidJsonError.js";
+import { OffchainNotConfiguredError } from "./errors/OffchainNotConfiguredError.js";
+import { OffchainNotImplementedError } from "./errors/OffchainNotImplementedError.js";
+import { OffchainRequestFailedError } from "./errors/OffchainRequestFailedError.js";
+import { OffchainStatusError } from "./errors/OffchainStatusError.js";
+import { OffchainValidationError } from "./errors/OffchainValidationError.js";
+import { readResponseBody } from "./errors/readResponseBody.js";
+import "./errors/index.js";
 import { OffchainOpportunities } from "./opportunities/OffchainOpportunities.js";
 import "./opportunities/index.js";
 import { OffchainPositions } from "./positions/OffchainPositions.js";
 import "./positions/index.js";
 import { GearboxAPI } from "./GearboxAPI.js";
-export { AbstractOffchainNamespace, GearboxAPI, GearboxAPIOptions, OffchainGetRequest, OffchainHistoryRequest, OffchainNotConfiguredError, OffchainNotImplementedError, OffchainOpportunities, OffchainPositions, OffchainQuery, OffchainResult, OffchainSourceMeta, OffchainTransportError, OffchainValidationError };
+export { AbstractOffchainNamespace, ErrorCause, GearboxAPI, GearboxAPIOptions, OffchainGetRequest, OffchainHistoryRequest, OffchainInvalidJsonError, OffchainNotConfiguredError, OffchainNotImplementedError, OffchainOpportunities, OffchainPositions, OffchainQuery, OffchainRequestFailedError, OffchainStatusError, OffchainTransportError, OffchainTransportErrorParams, OffchainValidationError, backendMessage, errorCause, readResponseBody };