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

package/dist/cjs/offchain/AbstractOffchainNamespace.js

@@ -1,26 +1,31 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_model_history_schema = require("../model/history.schema.js");
-const require_offchain_types = require("./types.js");
+const require_model_response_schema = require("../model/response.schema.js");
+const require_offchain_errors_OffchainInvalidJsonError = require("./errors/OffchainInvalidJsonError.js");
+const require_offchain_errors_OffchainNotConfiguredError = require("./errors/OffchainNotConfiguredError.js");
+const require_offchain_errors_OffchainRequestFailedError = require("./errors/OffchainRequestFailedError.js");
+const require_offchain_errors_OffchainStatusError = require("./errors/OffchainStatusError.js");
+const require_offchain_errors_OffchainValidationError = require("./errors/OffchainValidationError.js");
+const require_offchain_errors_readResponseBody = require("./errors/readResponseBody.js");
+require("./errors/index.js");
 let zod_v4 = require("zod/v4");
 //#region src/offchain/AbstractOffchainNamespace.ts
 const DEFAULT_TIMEOUT = 3e4;
 /**
-* 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.
 **/
 var AbstractOffchainNamespace = class {
 	logger;
 	#baseUrl;
+	#chainIds;
 	#timeout;
 	constructor(name, options) {
-		this.#baseUrl = options?.baseUrl?.replace(/\/+$/, "");
-		this.#timeout = options?.timeout ?? DEFAULT_TIMEOUT;
-		this.logger = options?.logger?.child?.({ name }) ?? options?.logger;
+		this.#baseUrl = options.baseUrl?.replace(/\/+$/, "");
+		this.#chainIds = [...options.chainIds];
+		this.#timeout = options.timeout ?? DEFAULT_TIMEOUT;
+		this.logger = options.logger?.child?.({ name }) ?? options.logger;
 	}
 	/**
 	* Base URL every read of this namespace is issued against.
@@ -29,36 +34,39 @@ var AbstractOffchainNamespace = class {
 		return this.#baseUrl;
 	}
 	/**
-	* 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.
+	**/
+	scopedChainIds(filter) {
+		const wanted = filter?.chainIds;
+		return wanted ? this.#chainIds.filter((chainId) => wanted.includes(chainId)) : [...this.#chainIds];
+	}
+	/**
+	* Reads one endpoint and decodes its payload. Timeouts, non-2xx answers and
+	* schema skew throw, since none of them is a {@link DataResponse}.
 	**/
 	async get(request) {
 		const url = this.#url(request.path, request.query);
-		this.logger?.debug(`reading ${url}`);
 		const payload = await this.#fetchJson(url);
-		const parsed = request.schema.safeParse(payload);
+		const parsed = require_model_response_schema.responseSchema(request.schema).safeParse(payload);
 		if (!parsed.success) {
-			this.logger?.error({
-				url,
-				issues: parsed.error.issues
-			}, "offchain response does not match the read model");
-			throw new require_offchain_types.OffchainValidationError(url, parsed.error.issues);
+			const error = new require_offchain_errors_OffchainValidationError.OffchainValidationError(url, parsed.error);
+			this.logger?.error(error, "offchain response does not match the read model");
+			throw error;
 		}
+		const { data, meta } = parsed.data;
 		return {
-			result: parsed.data,
-			meta: { status: "success" }
+			data,
+			meta: { chains: meta.chains.map((chain) => ({
+				...chain,
+				source: "offchain"
+			})) }
 		};
 	}
 	/**
-	* 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.
 	**/
 	async readHistory(request) {
 		return this.get({
@@ -71,7 +79,7 @@ var AbstractOffchainNamespace = class {
 	* Full URL of a read, with the conditions that do not narrow left out.
 	**/
 	#url(path, query) {
-		if (!this.#baseUrl) throw new require_offchain_types.OffchainNotConfiguredError(path);
+		if (!this.#baseUrl) throw new require_offchain_errors_OffchainNotConfiguredError.OffchainNotConfiguredError(path);
 		const url = new URL(`${this.#baseUrl}${path}`);
 		for (const [key, value] of Object.entries(query ?? {})) if (value !== void 0) url.searchParams.set(key, value);
 		return url.toString();
@@ -87,46 +95,15 @@ var AbstractOffchainNamespace = class {
 				signal: AbortSignal.timeout(this.#timeout)
 			});
 		} catch (error) {
-			throw new require_offchain_types.OffchainTransportError(url, describe(error));
+			throw new require_offchain_errors_OffchainRequestFailedError.OffchainRequestFailedError(url, error);
 		}
-		if (!response.ok) throw new require_offchain_types.OffchainTransportError(url, await failureReason(response), response.status);
+		if (!response.ok) throw new require_offchain_errors_OffchainStatusError.OffchainStatusError(url, response.status, await require_offchain_errors_readResponseBody.readResponseBody(response));
 		try {
 			return await response.json();
 		} catch (error) {
-			throw new require_offchain_types.OffchainTransportError(url, `the body is not JSON (${describe(error)})`, response.status);
+			throw new require_offchain_errors_OffchainInvalidJsonError.OffchainInvalidJsonError(url, response.status, error);
 		}
 	}
 };
-/**
-* Why a non-2xx response failed, in the backend's own words when it said.
-**/
-async function failureReason(response) {
-	const status = `the backend answered ${response.status}`;
-	let body;
-	try {
-		body = await response.text();
-	} catch {
-		return status;
-	}
-	const message = backendMessage(body) ?? body.trim();
-	return message ? `${status}: ${truncate(message)}` : status;
-}
-/**
-* The `message` of a Gearbox backend error body, or nothing when the body is
-* not one.
-**/
-function backendMessage(body) {
-	try {
-		const parsed = JSON.parse(body);
-		if (typeof parsed === "object" && parsed !== null && "message" in parsed && typeof parsed.message === "string") return parsed.message;
-	} catch {}
-}
-function describe(error) {
-	if (error instanceof Error) return error.name === "TimeoutError" ? "the request timed out" : error.message;
-	return String(error);
-}
-function truncate(text) {
-	return text.length > 200 ? `${text.slice(0, 200)}…` : text;
-}
 //#endregion
 exports.AbstractOffchainNamespace = AbstractOffchainNamespace;

package/dist/cjs/offchain/GearboxAPI.js

@@ -11,18 +11,21 @@ require("./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.
 **/
 var GearboxAPI = class {
+	/**
+	* Chains every read of this client is scoped to.
+	**/
+	chainIds;
 	/**
 	* Namespace for pool and strategy opportunities.
 	**/
@@ -32,6 +35,7 @@ var GearboxAPI = class {
 	**/
 	positions;
 	constructor(options) {
+		this.chainIds = [...options.chainIds];
 		this.opportunities = new require_offchain_opportunities_OffchainOpportunities.OffchainOpportunities(options);
 		this.positions = new require_offchain_positions_OffchainPositions.OffchainPositions(options);
 	}

package/dist/cjs/offchain/errors/OffchainInvalidJsonError.js

@@ -0,0 +1,19 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_offchain_errors_OffchainTransportError = require("./OffchainTransportError.js");
+//#region src/offchain/errors/OffchainInvalidJsonError.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.
+**/
+var OffchainInvalidJsonError = class extends require_offchain_errors_OffchainTransportError.OffchainTransportError {
+	name = "OffchainInvalidJsonError";
+	constructor(url, status, cause) {
+		super("The Gearbox backend answered with a body that is not JSON.", {
+			url,
+			status,
+			cause
+		});
+	}
+};
+//#endregion
+exports.OffchainInvalidJsonError = OffchainInvalidJsonError;

package/dist/cjs/offchain/errors/OffchainNotConfiguredError.js

@@ -0,0 +1,20 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let viem = require("viem");
+//#region src/offchain/errors/OffchainNotConfiguredError.ts
+/**
+* Thrown when a read is issued against a client that was never told where the
+* backend is.
+**/
+var OffchainNotConfiguredError = class extends viem.BaseError {
+	name = "OffchainNotConfiguredError";
+	/**
+	* Path that was read, below the base URL that is missing.
+	**/
+	path;
+	constructor(path) {
+		super("No baseUrl was configured for the Gearbox backend.", { metaMessages: [`Path: ${path}`] });
+		this.path = path;
+	}
+};
+//#endregion
+exports.OffchainNotConfiguredError = OffchainNotConfiguredError;

package/dist/cjs/offchain/errors/OffchainNotImplementedError.js

@@ -0,0 +1,19 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let viem = require("viem");
+//#region src/offchain/errors/OffchainNotImplementedError.ts
+/**
+* Thrown by the endpoints that are not implemented yet.
+**/
+var OffchainNotImplementedError = class extends viem.BaseError {
+	name = "OffchainNotImplementedError";
+	/**
+	* Endpoint that was asked for.
+	**/
+	endpoint;
+	constructor(endpoint) {
+		super("This Gearbox backend endpoint is not implemented yet.", { metaMessages: [`Endpoint: ${endpoint}`] });
+		this.endpoint = endpoint;
+	}
+};
+//#endregion
+exports.OffchainNotImplementedError = OffchainNotImplementedError;

package/dist/cjs/offchain/errors/OffchainRequestFailedError.js

@@ -0,0 +1,24 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_offchain_errors_OffchainTransportError = require("./OffchainTransportError.js");
+//#region src/offchain/errors/OffchainRequestFailedError.ts
+/**
+* Thrown when a request to the backend never completed: the network was down,
+* or it took longer than {@link GearboxAPIOptions.timeout}.
+**/
+var OffchainRequestFailedError = class extends require_offchain_errors_OffchainTransportError.OffchainTransportError {
+	name = "OffchainRequestFailedError";
+	constructor(url, cause) {
+		super(timedOut(cause) ? "The request to the Gearbox backend timed out." : "The request to the Gearbox backend failed.", {
+			url,
+			cause
+		});
+	}
+};
+/**
+* Whether a caught value is the rejection `AbortSignal.timeout` produces.
+**/
+function timedOut(error) {
+	return error instanceof Error && error.name === "TimeoutError";
+}
+//#endregion
+exports.OffchainRequestFailedError = OffchainRequestFailedError;

package/dist/cjs/offchain/errors/OffchainStatusError.js

@@ -0,0 +1,20 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_offchain_errors_backendMessage = require("./backendMessage.js");
+const require_offchain_errors_OffchainTransportError = require("./OffchainTransportError.js");
+//#region src/offchain/errors/OffchainStatusError.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.
+**/
+var OffchainStatusError = class extends require_offchain_errors_OffchainTransportError.OffchainTransportError {
+	name = "OffchainStatusError";
+	constructor(url, status, body) {
+		super(`The Gearbox backend answered ${status}.`, {
+			url,
+			status,
+			details: require_offchain_errors_backendMessage.backendMessage(body)
+		});
+	}
+};
+//#endregion
+exports.OffchainStatusError = OffchainStatusError;

package/dist/cjs/offchain/errors/OffchainTransportError.js

@@ -0,0 +1,31 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_offchain_errors_errorCause = require("./errorCause.js");
+let viem = require("viem");
+//#region src/offchain/errors/OffchainTransportError.ts
+/**
+* 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.
+**/
+var OffchainTransportError = class extends viem.BaseError {
+	/**
+	* URL that was requested, query included.
+	**/
+	url;
+	/**
+	* Status the backend answered with, absent when the request never completed.
+	**/
+	status;
+	constructor(shortMessage, params) {
+		const caught = require_offchain_errors_errorCause.errorCause(params.cause);
+		super(shortMessage, {
+			cause: caught.cause,
+			details: caught.details ?? params.details,
+			metaMessages: [`URL: ${params.url}`, ...params.status === void 0 ? [] : [`Status: ${params.status}`]]
+		});
+		this.url = params.url;
+		this.status = params.status;
+	}
+};
+//#endregion
+exports.OffchainTransportError = OffchainTransportError;

package/dist/cjs/offchain/errors/OffchainValidationError.js

@@ -0,0 +1,26 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let viem = require("viem");
+let zod_v4 = require("zod/v4");
+//#region src/offchain/errors/OffchainValidationError.ts
+/**
+* Thrown when the backend answered, but with a payload the read model does not
+* describe, i.e. the two are of different versions.
+**/
+var OffchainValidationError = class extends viem.BaseError {
+	name = "OffchainValidationError";
+	/**
+	* URL whose payload failed to validate.
+	**/
+	url;
+	/**
+	* The zod failure itself, e.g. for `z.treeifyError(error.zodError)`.
+	**/
+	zodError;
+	constructor(url, zodError) {
+		super("The Gearbox backend response does not match the read model.", { metaMessages: [`URL: ${url}`, ...zod_v4.z.prettifyError(zodError).split("\n")] });
+		this.url = url;
+		this.zodError = zodError;
+	}
+};
+//#endregion
+exports.OffchainValidationError = OffchainValidationError;

package/dist/cjs/offchain/errors/backendMessage.js

@@ -0,0 +1,28 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/offchain/errors/backendMessage.ts
+const MAX_LENGTH = 200;
+/**
+* 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.
+**/
+function backendMessage(body) {
+	if (!body) return;
+	const message = parsedMessage(body) ?? body.trim();
+	return message ? truncate(message) : void 0;
+}
+/**
+* The `message` of a Gearbox backend error body, or nothing when the body is
+* not one.
+**/
+function parsedMessage(body) {
+	try {
+		const parsed = JSON.parse(body);
+		if (typeof parsed === "object" && parsed !== null && "message" in parsed && typeof parsed.message === "string") return parsed.message;
+	} catch {}
+}
+function truncate(text) {
+	return text.length > MAX_LENGTH ? `${text.slice(0, MAX_LENGTH)}…` : text;
+}
+//#endregion
+exports.backendMessage = backendMessage;

package/dist/cjs/offchain/errors/errorCause.js

@@ -0,0 +1,12 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/offchain/errors/errorCause.ts
+/**
+* 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`.
+**/
+function errorCause(error) {
+	if (error === void 0) return {};
+	return error instanceof Error ? { cause: error } : { details: String(error) };
+}
+//#endregion
+exports.errorCause = errorCause;

package/dist/cjs/offchain/errors/index.js

@@ -0,0 +1,21 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_offchain_errors_backendMessage = require("./backendMessage.js");
+const require_offchain_errors_errorCause = require("./errorCause.js");
+const require_offchain_errors_OffchainTransportError = require("./OffchainTransportError.js");
+const require_offchain_errors_OffchainInvalidJsonError = require("./OffchainInvalidJsonError.js");
+const require_offchain_errors_OffchainNotConfiguredError = require("./OffchainNotConfiguredError.js");
+const require_offchain_errors_OffchainNotImplementedError = require("./OffchainNotImplementedError.js");
+const require_offchain_errors_OffchainRequestFailedError = require("./OffchainRequestFailedError.js");
+const require_offchain_errors_OffchainStatusError = require("./OffchainStatusError.js");
+const require_offchain_errors_OffchainValidationError = require("./OffchainValidationError.js");
+const require_offchain_errors_readResponseBody = require("./readResponseBody.js");
+exports.OffchainInvalidJsonError = require_offchain_errors_OffchainInvalidJsonError.OffchainInvalidJsonError;
+exports.OffchainNotConfiguredError = require_offchain_errors_OffchainNotConfiguredError.OffchainNotConfiguredError;
+exports.OffchainNotImplementedError = require_offchain_errors_OffchainNotImplementedError.OffchainNotImplementedError;
+exports.OffchainRequestFailedError = require_offchain_errors_OffchainRequestFailedError.OffchainRequestFailedError;
+exports.OffchainStatusError = require_offchain_errors_OffchainStatusError.OffchainStatusError;
+exports.OffchainTransportError = require_offchain_errors_OffchainTransportError.OffchainTransportError;
+exports.OffchainValidationError = require_offchain_errors_OffchainValidationError.OffchainValidationError;
+exports.backendMessage = require_offchain_errors_backendMessage.backendMessage;
+exports.errorCause = require_offchain_errors_errorCause.errorCause;
+exports.readResponseBody = require_offchain_errors_readResponseBody.readResponseBody;

package/dist/cjs/offchain/errors/readResponseBody.js

@@ -0,0 +1,15 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/offchain/errors/readResponseBody.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.
+**/
+async function readResponseBody(response) {
+	try {
+		return await response.text();
+	} catch {
+		return;
+	}
+}
+//#endregion
+exports.readResponseBody = readResponseBody;

package/dist/cjs/offchain/index.js

@@ -1,16 +1,33 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_offchain_types = require("./types.js");
+const require_offchain_errors_backendMessage = require("./errors/backendMessage.js");
+const require_offchain_errors_errorCause = require("./errors/errorCause.js");
+const require_offchain_errors_OffchainTransportError = require("./errors/OffchainTransportError.js");
+const require_offchain_errors_OffchainInvalidJsonError = require("./errors/OffchainInvalidJsonError.js");
+const require_offchain_errors_OffchainNotConfiguredError = require("./errors/OffchainNotConfiguredError.js");
+const require_offchain_errors_OffchainNotImplementedError = require("./errors/OffchainNotImplementedError.js");
+const require_offchain_errors_OffchainRequestFailedError = require("./errors/OffchainRequestFailedError.js");
+const require_offchain_errors_OffchainStatusError = require("./errors/OffchainStatusError.js");
+const require_offchain_errors_OffchainValidationError = require("./errors/OffchainValidationError.js");
+const require_offchain_errors_readResponseBody = require("./errors/readResponseBody.js");
+require("./errors/index.js");
 const require_offchain_AbstractOffchainNamespace = require("./AbstractOffchainNamespace.js");
 const require_offchain_opportunities_OffchainOpportunities = require("./opportunities/OffchainOpportunities.js");
 require("./opportunities/index.js");
 const require_offchain_positions_OffchainPositions = require("./positions/OffchainPositions.js");
 require("./positions/index.js");
 const require_offchain_GearboxAPI = require("./GearboxAPI.js");
+require("./types.js");
 exports.AbstractOffchainNamespace = require_offchain_AbstractOffchainNamespace.AbstractOffchainNamespace;
 exports.GearboxAPI = require_offchain_GearboxAPI.GearboxAPI;
-exports.OffchainNotConfiguredError = require_offchain_types.OffchainNotConfiguredError;
-exports.OffchainNotImplementedError = require_offchain_types.OffchainNotImplementedError;
+exports.OffchainInvalidJsonError = require_offchain_errors_OffchainInvalidJsonError.OffchainInvalidJsonError;
+exports.OffchainNotConfiguredError = require_offchain_errors_OffchainNotConfiguredError.OffchainNotConfiguredError;
+exports.OffchainNotImplementedError = require_offchain_errors_OffchainNotImplementedError.OffchainNotImplementedError;
 exports.OffchainOpportunities = require_offchain_opportunities_OffchainOpportunities.OffchainOpportunities;
 exports.OffchainPositions = require_offchain_positions_OffchainPositions.OffchainPositions;
-exports.OffchainTransportError = require_offchain_types.OffchainTransportError;
-exports.OffchainValidationError = require_offchain_types.OffchainValidationError;
+exports.OffchainRequestFailedError = require_offchain_errors_OffchainRequestFailedError.OffchainRequestFailedError;
+exports.OffchainStatusError = require_offchain_errors_OffchainStatusError.OffchainStatusError;
+exports.OffchainTransportError = require_offchain_errors_OffchainTransportError.OffchainTransportError;
+exports.OffchainValidationError = require_offchain_errors_OffchainValidationError.OffchainValidationError;
+exports.backendMessage = require_offchain_errors_backendMessage.backendMessage;
+exports.errorCause = require_offchain_errors_errorCause.errorCause;
+exports.readResponseBody = require_offchain_errors_readResponseBody.readResponseBody;

package/dist/cjs/offchain/opportunities/OffchainOpportunities.js

@@ -12,13 +12,16 @@ var OffchainOpportunities = class extends require_offchain_AbstractOffchainNames
 		super("OffchainOpportunities", options);
 	}
 	/**
-	* All opportunities the backend knows about, optionally narrowed by
-	* {@link OpportunityFilter}.
+	* Opportunities of the chains this client covers, optionally narrowed further
+	* by {@link OpportunityFilter}.
 	**/
 	async list(filter) {
 		return this.get({
 			path: this.#root,
-			query: filter ? zod_v4.z.encode(require_model_opportunities_schema.opportunityFilterQuerySchema, filter) : void 0,
+			query: zod_v4.z.encode(require_model_opportunities_schema.opportunityFilterQuerySchema, {
+				...filter,
+				chainIds: this.scopedChainIds(filter)
+			}),
 			schema: zod_v4.z.array(require_model_opportunities_schema.opportunitySchema)
 		});
 	}

package/dist/cjs/offchain/positions/OffchainPositions.js

@@ -1,48 +1,42 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_model_positions_schema = require("../../model/positions.schema.js");
 const require_offchain_AbstractOffchainNamespace = require("../AbstractOffchainNamespace.js");
+let zod_v4 = require("zod/v4");
 //#region src/offchain/positions/OffchainPositions.ts
 /**
 * Backend counterpart of the `positions` namespace.
 **/
 var OffchainPositions = class extends require_offchain_AbstractOffchainNamespace.AbstractOffchainNamespace {
+	#root = "/v2/positions";
 	constructor(options) {
 		super("OffchainPositions", options);
 	}
 	/**
 	* Everything a wallet holds, optionally narrowed by {@link PositionFilter}.
-	*
-	* @returns An empty list until the backend client is implemented.
 	**/
-	async list(wallet, filter) {
-		this.logger?.debug({
-			wallet,
-			filter
-		}, "offchain positions list is not implemented, serving empty list");
-		return {
-			result: [],
-			meta: { status: "success" }
-		};
+	async list(props) {
+		return this.get({
+			path: `${this.#root}/${props.wallet}`,
+			query: zod_v4.z.encode(require_model_positions_schema.positionFilterQuerySchema, {
+				...props.filter,
+				chainIds: this.scopedChainIds(props.filter)
+			}),
+			schema: zod_v4.z.array(require_model_positions_schema.positionSchema)
+		});
 	}
 	/**
-	* 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.
 	**/
 	async getHistory(query) {
-		this.logger?.debug({ query }, "offchain positions history is not implemented, serving empty series");
 		return {
-			result: {
+			data: {
 				metric: query.metric,
 				points: [],
 				metadata: {}
 			},
-			meta: { status: "success" }
+			meta: { chains: [] }
 		};
 	}
 };

package/dist/cjs/offchain/types.js

@@ -1,76 +1 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-//#region src/offchain/types.ts
-/**
-* Thrown by the endpoints that have no stub answer, so that a caller in
-* `offchain` mode fails loudly instead of reading an empty detail page as a
-* missing entity.
-*
-* Lives here rather than in one namespace because every stubbed namespace
-* throws it.
-**/
-var OffchainNotImplementedError = class extends Error {
-	constructor(endpoint) {
-		super(`GearboxAPI: ${endpoint} is not implemented yet`);
-		this.name = "OffchainNotImplementedError";
-	}
-};
-/**
-* Thrown when a read is issued against a client that was never told where the
-* backend is.
-**/
-var OffchainNotConfiguredError = class extends Error {
-	constructor(path) {
-		super(`GearboxAPI: cannot read ${path}, no baseUrl was configured`);
-		this.name = "OffchainNotConfiguredError";
-	}
-};
-/**
-* Thrown when the backend could not be reached, or answered with a status
-* outside the 2xx range.
-**/
-var OffchainTransportError = class extends Error {
-	/**
-	* URL that was requested, query included.
-	**/
-	url;
-	/**
-	* Status the backend answered with, absent when the request never completed.
-	**/
-	status;
-	constructor(url, reason, status) {
-		super(`GearboxAPI: request to ${url} failed, ${reason}`);
-		this.name = "OffchainTransportError";
-		this.url = url;
-		this.status = status;
-	}
-};
-/**
-* Thrown when the backend answered, but with a payload the read model does not
-* describe.
-*
-* This is version skew rather than a bad request, and it is deliberately
-* handled like a transport error: the combined SDK drops the backend's
-* contribution in `both` mode and fails the read in `offchain` mode.
-**/
-var OffchainValidationError = class extends Error {
-	/**
-	* URL whose payload failed to validate.
-	**/
-	url;
-	/**
-	* What did not match, in the order zod reported it.
-	**/
-	issues;
-	constructor(url, issues) {
-		const summary = issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`).join("; ");
-		super(`GearboxAPI: response from ${url} does not match the model, ${summary}`);
-		this.name = "OffchainValidationError";
-		this.url = url;
-		this.issues = issues;
-	}
-};
-//#endregion
-exports.OffchainNotConfiguredError = OffchainNotConfiguredError;
-exports.OffchainNotImplementedError = OffchainNotImplementedError;
-exports.OffchainTransportError = OffchainTransportError;
-exports.OffchainValidationError = OffchainValidationError;