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

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

@@ -0,0 +1,19 @@
+import { ChainScopedFilter } from "../../model/filters.js";
+import { DataResponse } from "../../model/response.js";
+import "../../model/index.js";
+import { FilterResult } from "./types.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, and an envelope narrows to
+ * an envelope, see {@link FilterResult}.
+ *
+ * @typeParam T - Row type.
+ * @typeParam F - Filter type.
+ * @typeParam R - What the response was given as.
+ * @param matches - Whether one row satisfies the filter, e.g.
+ *   `matchesOpportunityFilter`.
+ **/
+declare function filterResponse<T, F extends ChainScopedFilter, R extends DataResponse<T[]> | undefined>(response: R, filter: F | undefined, matches: (row: T, filter?: F) => boolean): FilterResult<R, T>;
+//#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 { EntityMerger, FilterResult, ListMerger, MergeListResult } from "./types.js";
+import { filterResponse } from "./filterResponse.js";
+import { HistoryReader } from "./history.js";
+import { DEFAULT_MAX_OFFCHAIN_LAG, mergeChainList, mergeChainOne } from "./mergeChains.js";
+export { DEFAULT_MAX_OFFCHAIN_LAG, type EntityMerger, type FilterResult, HistoryReader, type ListMerger, type MergeListResult, filterResponse, mergeChainList, mergeChainOne };

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

@@ -0,0 +1,22 @@
+import { ChainScoped, DataResponse } from "../../model/response.js";
+import "../../model/index.js";
+import { MergeListResult } from "./types.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. Answers with an envelope as soon as
+ * either side has arrived, see {@link MergeListResult}.
+ **/
+declare function mergeChainList<T extends ChainScoped, Onchain extends DataResponse<T[]> | undefined, Offchain extends DataResponse<T[]> | undefined>(onchain: Onchain, offchain: Offchain, maxLagSeconds?: number): MergeListResult<Onchain, Offchain, T[]>;
+/**
+ * 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,43 @@
+import { DataResponse } from "../../model/response.js";
+import "../../model/index.js";
+//#region src/new-sdk/utils/types.d.ts
+/**
+ * Whether a merge could have been given nothing at all, i.e. both sides are
+ * typed as possibly absent. One definite side already answers this `false`.
+ **/
+type BothMayBeMissing<Onchain, Offchain> = undefined extends Onchain & Offchain ? true : false;
+/**
+ * What merging two lists answers with: an envelope unless both sides could
+ * still be missing, since a list merge serves whichever side did arrive.
+ *
+ * @typeParam Onchain - What the on-chain side was given as.
+ * @typeParam Offchain - What the backend side was given as.
+ * @typeParam T - Payload type of the read.
+ **/
+type MergeListResult<Onchain, Offchain, T> = BothMayBeMissing<Onchain, Offchain> extends true ? DataResponse<T> | undefined : DataResponse<T>;
+/**
+ * What narrowing an already-read list answers with: `undefined` only where the
+ * read itself was still in flight.
+ *
+ * @typeParam R - What the response was given as.
+ * @typeParam T - Row type.
+ **/
+type FilterResult<R, T> = R extends undefined ? undefined : DataResponse<T[]>;
+/**
+ * How a list read combines what the two sources returned. A side still in
+ * flight is `undefined`; the merge answers with an envelope as soon as either
+ * one has arrived, see {@link MergeListResult}.
+ *
+ * @typeParam T - Payload type of the read.
+ **/
+type ListMerger<T> = <Onchain extends DataResponse<T> | undefined, Offchain extends DataResponse<T> | undefined>(onchain: Onchain, offchain: Offchain) => MergeListResult<Onchain, Offchain, T>;
+/**
+ * How a single-entity read combines what the two sources returned. Unlike
+ * {@link ListMerger} this stays optional whatever it was given: neither source
+ * may have served the entity, and there is nothing to answer with then.
+ *
+ * @typeParam T - Payload type of the read.
+ **/
+type EntityMerger<T> = (onchain: DataResponse<T> | undefined, offchain: DataResponse<T> | undefined) => DataResponse<T> | undefined;
+//#endregion
+export { EntityMerger, FilterResult, ListMerger, MergeListResult };

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 };

package/dist/types/offchain/opportunities/OffchainOpportunities.d.ts

@@ -1,6 +1,7 @@
 import { Opportunity, OpportunityFilter, PoolOpportunityDetail, PoolOpportunityKey, StrategyOpportunityDetail, StrategyOpportunityKey } from "../../model/opportunities.js";
 import { HistoryMetric, HistorySeries, OpportunityHistoryQuery } from "../../model/history.js";
-import { GearboxAPIOptions, OffchainResult } from "../types.js";
+import { DataResponse } from "../../model/response.js";
+import { GearboxAPIOptions } from "../types.js";
 import { AbstractOffchainNamespace } from "../AbstractOffchainNamespace.js";
 //#region src/offchain/opportunities/OffchainOpportunities.d.ts
 /**
@@ -8,24 +9,24 @@ import { AbstractOffchainNamespace } from "../AbstractOffchainNamespace.js";
  **/
 declare class OffchainOpportunities extends AbstractOffchainNamespace {
   #private;
-  constructor(options?: GearboxAPIOptions);
+  constructor(options: GearboxAPIOptions);
   /**
-   * All opportunities the backend knows about, optionally narrowed by
-   * {@link OpportunityFilter}.
+   * Opportunities of the chains this client covers, optionally narrowed further
+   * by {@link OpportunityFilter}.
    **/
-  list(filter?: OpportunityFilter): Promise<OffchainResult<Opportunity[]>>;
+  list(filter?: OpportunityFilter): Promise<DataResponse<Opportunity[]>>;
   /**
    * Detailed view of one pool opportunity.
    **/
-  getPool(key: PoolOpportunityKey): Promise<OffchainResult<PoolOpportunityDetail>>;
+  getPool(key: PoolOpportunityKey): Promise<DataResponse<PoolOpportunityDetail>>;
   /**
    * Detailed view of one strategy opportunity.
    **/
-  getStrategy(key: StrategyOpportunityKey): Promise<OffchainResult<StrategyOpportunityDetail>>;
+  getStrategy(key: StrategyOpportunityKey): Promise<DataResponse<StrategyOpportunityDetail>>;
   /**
    * One historical series of one opportunity
    **/
-  getHistory<M extends HistoryMetric>(query: OpportunityHistoryQuery<M>): Promise<OffchainResult<HistorySeries<M>>>;
+  getHistory<M extends HistoryMetric>(query: OpportunityHistoryQuery<M>): Promise<DataResponse<HistorySeries<M>>>;
 }
 //#endregion
 export { OffchainOpportunities };

package/dist/types/offchain/positions/OffchainPositions.d.ts

@@ -1,32 +1,26 @@
-import { Position, PositionFilter } from "../../model/positions.js";
+import { Position } from "../../model/positions.js";
 import { HistorySeries, PositionHistoryMetric, PositionHistoryQuery } from "../../model/history.js";
-import { GearboxAPIOptions, OffchainResult } from "../types.js";
+import { DataResponse } from "../../model/response.js";
+import { ListPositionsPropsBase } from "../../sdk/positions/types.js";
+import { GearboxAPIOptions } from "../types.js";
 import { AbstractOffchainNamespace } from "../AbstractOffchainNamespace.js";
-import { Address } from "viem";
 //#region src/offchain/positions/OffchainPositions.d.ts
 /**
  * Backend counterpart of the `positions` namespace.
  **/
 declare class OffchainPositions extends AbstractOffchainNamespace {
-  constructor(options?: GearboxAPIOptions);
+  #private;
+  constructor(options: GearboxAPIOptions);
   /**
    * Everything a wallet holds, optionally narrowed by {@link PositionFilter}.
-   *
-   * @returns An empty list until the backend client is implemented.
    **/
-  list(wallet: Address, filter?: PositionFilter): Promise<OffchainResult<Position[]>>;
+  list(props: ListPositionsPropsBase): Promise<DataResponse<Position[]>>;
   /**
-   * One historical series of one position. History exists only here: rebuilding
-   * it from the chain would mean an archive read per point.
-   *
-   * The requested metric types the response, so a caller asking for one metric
-   * does not have to narrow the union back down. When the transport lands,
-   * validation is what upholds it: a response carrying a different metric than
-   * the one asked for is a version-skew error like any other.
+   * One historical series of one position.
    *
    * @returns An empty series until the backend client is implemented.
    **/
-  getHistory<M extends PositionHistoryMetric>(query: PositionHistoryQuery<M>): Promise<OffchainResult<HistorySeries<M>>>;
+  getHistory<M extends PositionHistoryMetric>(query: PositionHistoryQuery<M>): Promise<DataResponse<HistorySeries<M>>>;
 }
 //#endregion
 export { OffchainPositions };