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

package/dist/types/model/opportunities.d.ts

@@ -1,6 +1,6 @@
-import { Curator } from "./curators.js";
 import { Amount, AssetType, Bps, ChainId, Leverage, Timestamp, Token } from "./primitives.js";
-import { Filterable } from "./filters.js";
+import { Curator } from "./curators.js";
+import { ChainScopedFilter, Filterable } from "./filters.js";
 import { Address } from "viem";
 //#region src/model/opportunities.d.ts
 /**
@@ -356,15 +356,11 @@ declare function opportunityId(opportunity: Opportunity): OpportunityId;
  * `"all"` to say the same thing explicitly, which is what a UI whose state has
  * an "any" option holds, see {@link Filterable}. Conditions combine with AND.
  **/
-interface OpportunityFilter {
+interface OpportunityFilter extends ChainScopedFilter {
   /**
    * Keep only pools or only strategies.
    **/
   kind?: Filterable<OpportunityKind>;
-  /**
-   * Keep only opportunities on these chains.
-   **/
-  chainIds?: Filterable<ChainId[]>;
   /**
    * Keep only opportunities whose {@link OpportunityBase.underlyingToken} is of
    * this class, which for an RWA market means the class of the token its

package/dist/types/model/opportunities.schema.d.ts

@@ -562,7 +562,7 @@ declare const opportunitySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
  **/
 declare const opportunityFilterSchema: z.ZodObject<{
   kind: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodLiteral<"pool">, z.ZodLiteral<"strategy">]>, z.ZodLiteral<"all">]>>;
-  chainIds: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodNumber>, z.ZodLiteral<"all">]>>;
+  chainIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
   underlyingType: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodLiteral<"Stable">, z.ZodLiteral<"ETH">, z.ZodLiteral<"BTC">]>, z.ZodLiteral<"all">]>>;
   paused: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodLiteral<"all">]>>;
   sunset: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodLiteral<"all">]>>;
@@ -610,7 +610,7 @@ declare const opportunityFilterQuerySchema: z.ZodCodec<z.ZodObject<{
   }>>;
 }, z.core.$strip>, z.ZodObject<{
   kind: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodLiteral<"pool">, z.ZodLiteral<"strategy">]>, z.ZodLiteral<"all">]>>;
-  chainIds: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodNumber>, z.ZodLiteral<"all">]>>;
+  chainIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
   underlyingType: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodLiteral<"Stable">, z.ZodLiteral<"ETH">, z.ZodLiteral<"BTC">]>, z.ZodLiteral<"all">]>>;
   paused: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodLiteral<"all">]>>;
   sunset: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodLiteral<"all">]>>;

package/dist/types/model/positions.d.ts

@@ -1,5 +1,5 @@
 import { AssetType, Bps, ChainId, Leverage, Token, TokenAmount } from "./primitives.js";
-import { Filterable } from "./filters.js";
+import { ChainScopedFilter, Filterable } from "./filters.js";
 import { ApyBreakdown, PointsProgram } from "./opportunities.js";
 import { DelayedReceivedAsset, LiquidationPosition } from "./liquidations.js";
 import { Address } from "viem";
@@ -264,7 +264,7 @@ declare function positionId(position: Position): PositionId;
  * `"all"` to say the same thing explicitly, which is what a UI whose state has
  * an "any" option holds, see {@link Filterable}. Conditions combine with AND.
  **/
-interface PositionFilter {
+interface PositionFilter extends ChainScopedFilter {
   /**
    * Keep only positions of this kind.
    **/
@@ -274,10 +274,6 @@ interface PositionFilter {
    * Applicable only to {@link StrategyPosition}
    **/
   isZeroDebt?: Filterable<boolean>;
-  /**
-   * Keep only positions on these chains.
-   **/
-  chainIds?: Filterable<ChainId[]>;
   /**
    * Keep only positions whose underlying is of this class, which for an RWA
    * market means the class of the token its wrapper holds.

package/dist/types/model/positions.schema.d.ts

@@ -694,9 +694,39 @@ declare const positionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
 declare const positionFilterSchema: z.ZodObject<{
   kind: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodLiteral<"pool">, z.ZodLiteral<"strategy">, z.ZodLiteral<"liquidation">]>, z.ZodLiteral<"all">]>>;
   isZeroDebt: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodLiteral<"all">]>>;
-  chainIds: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodNumber>, z.ZodLiteral<"all">]>>;
+  chainIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
   underlyingType: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodLiteral<"Stable">, z.ZodLiteral<"ETH">, z.ZodLiteral<"BTC">]>, z.ZodLiteral<"all">]>>;
 }, z.core.$strip>;
+/**
+ * {@link PositionFilter} as a URL can carry it: every condition is a string,
+ * and a condition that does not narrow is absent rather than empty.
+ **/
+declare const positionFilterQueryParamsSchema: z.ZodObject<{
+  kind: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"pool">, z.ZodLiteral<"strategy">, z.ZodLiteral<"liquidation">]>>;
+  isZeroDebt: z.ZodOptional<z.ZodEnum<{
+    false: "false";
+    true: "true";
+  }>>;
+  chainIds: z.ZodOptional<z.ZodString>;
+  underlyingType: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"Stable">, z.ZodLiteral<"ETH">, z.ZodLiteral<"BTC">]>>;
+}, z.core.$strip>;
+/**
+ * Code for {@link PositionFilter} to encode/decode to/from url query parameters.
+ **/
+declare const positionFilterQuerySchema: z.ZodCodec<z.ZodObject<{
+  kind: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"pool">, z.ZodLiteral<"strategy">, z.ZodLiteral<"liquidation">]>>;
+  isZeroDebt: z.ZodOptional<z.ZodEnum<{
+    false: "false";
+    true: "true";
+  }>>;
+  chainIds: z.ZodOptional<z.ZodString>;
+  underlyingType: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"Stable">, z.ZodLiteral<"ETH">, z.ZodLiteral<"BTC">]>>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodLiteral<"pool">, z.ZodLiteral<"strategy">, z.ZodLiteral<"liquidation">]>, z.ZodLiteral<"all">]>>;
+  isZeroDebt: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodLiteral<"all">]>>;
+  chainIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+  underlyingType: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodLiteral<"Stable">, z.ZodLiteral<"ETH">, z.ZodLiteral<"BTC">]>, z.ZodLiteral<"all">]>>;
+}, z.core.$strip>>;
 /**
  * {@link PoolPositionKey}
  **/
@@ -726,4 +756,4 @@ declare const positionKeySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   kind: z.ZodLiteral<"strategy">;
 }, z.core.$strip>], "kind">;
 //#endregion
-export { pnlBreakdownSchema, pointsProgramPnLSchema, pointsRewardsPnLSchema, poolPositionKeySchema, poolPositionSchema, positionCollateralSchema, positionFilterSchema, positionKeySchema, positionKindSchema, positionSchema, rewardsPnLSchema, strategyPositionKeySchema, strategyPositionSchema, tokenRewardsPnLSchema };
+export { pnlBreakdownSchema, pointsProgramPnLSchema, pointsRewardsPnLSchema, poolPositionKeySchema, poolPositionSchema, positionCollateralSchema, positionFilterQueryParamsSchema, positionFilterQuerySchema, positionFilterSchema, positionKeySchema, positionKindSchema, positionSchema, rewardsPnLSchema, strategyPositionKeySchema, strategyPositionSchema, tokenRewardsPnLSchema };

package/dist/types/model/response.d.ts

@@ -37,10 +37,10 @@ interface ResponseMetadata {
  **/
 type DataSource = "onchain" | "offchain";
 /**
- * Chain that answered, and which source served it.
+ * Chain that answered, which source served it, and the block it answered from.
  *
  * Discriminated from {@link ChainFailed} on {@link status}, so a success
- * without a source is unrepresentable.
+ * without a source, or without the block it reflects, is unrepresentable.
  **/
 interface ChainSucceeded {
   /**
@@ -55,13 +55,14 @@ interface ChainSucceeded {
   source: DataSource;
   /**
    * Block the data reflects. A `number` here (model convention), converted
-   * from `bigint` at the onchain boundary.
+   * from `bigint` at the onchain boundary. A chain that cannot say which block
+   * it answered from is a {@link ChainFailed}.
    **/
-  blockNumber?: number;
+  blockNumber: number;
   /**
    * Unix seconds of {@link blockNumber}.
    **/
-  timestamp?: Timestamp;
+  timestamp: Timestamp;
 }
 /**
  * Chain that did not answer.
@@ -78,7 +79,7 @@ interface ChainFailed {
    **/
   source?: DataSource;
   /**
-   * Rejection reason. A `string` in JSON responses, an `Error` (or an
+   * Rejection reason. A `string` in a JSON response, an `Error` (or an
    * `AggregateError` when both sources failed) when produced locally.
    *
    * Serialises to `{}` if an envelope carrying a real `Error` is put into

package/dist/types/model/response.schema.d.ts

@@ -1,3 +1,4 @@
+import { DataResponse } from "./response.js";
 import { z } from "zod/v4";
 //#region src/model/response.schema.d.ts
 /**
@@ -10,27 +11,39 @@ import { z } from "zod/v4";
 /**
  * {@link DataSource}
  **/
-declare const dataSourceSchema: z.ZodUnion<readonly [z.ZodLiteral<"onchain">, z.ZodLiteral<"offchain">]>;
+declare const dataSourceSchema: z.ZodEnum<{
+  offchain: "offchain";
+  onchain: "onchain";
+}>;
 /**
  * {@link ChainSucceeded}
+ *
+ * `source` may be omitted by the backend and decodes to `"offchain"`. The block
+ * has no such default: a success that omits it fails validation.
  **/
 declare const chainSucceededSchema: z.ZodObject<{
   chainId: z.ZodNumber;
   status: z.ZodLiteral<"success">;
-  source: z.ZodUnion<readonly [z.ZodLiteral<"onchain">, z.ZodLiteral<"offchain">]>;
-  blockNumber: z.ZodOptional<z.ZodNumber>;
-  timestamp: z.ZodOptional<z.ZodNumber>;
+  source: z.ZodDefault<z.ZodEnum<{
+    offchain: "offchain";
+    onchain: "onchain";
+  }>>;
+  blockNumber: z.ZodNumber;
+  timestamp: z.ZodNumber;
 }, z.core.$strip>;
 /**
  * {@link ChainFailed}
  *
- * `error` is a `string` on the wire. The schema accepts `unknown` so the same
- * codec also validates a locally produced envelope that carries an `Error`.
+ * `error` is a `string` in a JSON body. The schema accepts `unknown` so the
+ * same codec also validates a locally produced envelope carrying an `Error`.
  **/
 declare const chainFailedSchema: z.ZodObject<{
   chainId: z.ZodNumber;
   status: z.ZodLiteral<"error">;
-  source: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"onchain">, z.ZodLiteral<"offchain">]>>;
+  source: z.ZodOptional<z.ZodEnum<{
+    offchain: "offchain";
+    onchain: "onchain";
+  }>>;
   error: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$strip>;
 /**
@@ -39,13 +52,19 @@ declare const chainFailedSchema: z.ZodObject<{
 declare const chainMetadataSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   chainId: z.ZodNumber;
   status: z.ZodLiteral<"success">;
-  source: z.ZodUnion<readonly [z.ZodLiteral<"onchain">, z.ZodLiteral<"offchain">]>;
-  blockNumber: z.ZodOptional<z.ZodNumber>;
-  timestamp: z.ZodOptional<z.ZodNumber>;
+  source: z.ZodDefault<z.ZodEnum<{
+    offchain: "offchain";
+    onchain: "onchain";
+  }>>;
+  blockNumber: z.ZodNumber;
+  timestamp: z.ZodNumber;
 }, z.core.$strip>, z.ZodObject<{
   chainId: z.ZodNumber;
   status: z.ZodLiteral<"error">;
-  source: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"onchain">, z.ZodLiteral<"offchain">]>>;
+  source: z.ZodOptional<z.ZodEnum<{
+    offchain: "offchain";
+    onchain: "onchain";
+  }>>;
   error: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$strip>], "status">;
 /**
@@ -55,35 +74,25 @@ declare const responseMetadataSchema: z.ZodObject<{
   chains: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
     chainId: z.ZodNumber;
     status: z.ZodLiteral<"success">;
-    source: z.ZodUnion<readonly [z.ZodLiteral<"onchain">, z.ZodLiteral<"offchain">]>;
-    blockNumber: z.ZodOptional<z.ZodNumber>;
-    timestamp: z.ZodOptional<z.ZodNumber>;
+    source: z.ZodDefault<z.ZodEnum<{
+      offchain: "offchain";
+      onchain: "onchain";
+    }>>;
+    blockNumber: z.ZodNumber;
+    timestamp: z.ZodNumber;
   }, z.core.$strip>, z.ZodObject<{
     chainId: z.ZodNumber;
     status: z.ZodLiteral<"error">;
-    source: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"onchain">, z.ZodLiteral<"offchain">]>>;
+    source: z.ZodOptional<z.ZodEnum<{
+      offchain: "offchain";
+      onchain: "onchain";
+    }>>;
     error: z.ZodOptional<z.ZodUnknown>;
   }, z.core.$strip>], "status">>;
 }, z.core.$strip>;
 /**
  * {@link DataResponse} parameterized by the payload schema.
  **/
-declare function responseSchema<S extends z.ZodType>(payloadSchema: S): z.ZodObject<{
-  data: S;
-  meta: z.ZodObject<{
-    chains: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-      chainId: z.ZodNumber;
-      status: z.ZodLiteral<"success">;
-      source: z.ZodUnion<readonly [z.ZodLiteral<"onchain">, z.ZodLiteral<"offchain">]>;
-      blockNumber: z.ZodOptional<z.ZodNumber>;
-      timestamp: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>, z.ZodObject<{
-      chainId: z.ZodNumber;
-      status: z.ZodLiteral<"error">;
-      source: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"onchain">, z.ZodLiteral<"offchain">]>>;
-      error: z.ZodOptional<z.ZodUnknown>;
-    }, z.core.$strip>], "status">>;
-  }, z.core.$strip>;
-}, z.core.$strip>;
+declare function responseSchema<S extends z.ZodType>(payloadSchema: S): z.ZodType<DataResponse<z.output<S>>>;
 //#endregion
 export { chainFailedSchema, chainMetadataSchema, chainSucceededSchema, dataSourceSchema, responseMetadataSchema, responseSchema };

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

@@ -1,119 +1,54 @@
 import { ILogger } from "../sdk/types/logger.js";
-import { ChainId } from "../model/primitives.js";
-import { NetworkType } from "../sdk/chain/chains.js";
-import { MultichainNetworkMeta } from "../sdk/types/multichain.js";
+import { DataResponse } from "../model/response.js";
 import "../model/index.js";
-import { MultichainSDK } from "../sdk/MultichainSDK.js";
-import "../sdk/index.js";
-import { OffchainResult } from "../offchain/types.js";
-import { GearboxAPI } from "../offchain/GearboxAPI.js";
-import "../offchain/index.js";
-import { OffchainSourceStatus, ReadResult, SourceMeta } from "./types.js";
+import { NamespaceOptions } from "./types.js";
+import { EntityMerger, ListMerger } from "./utils/types.js";
+import "./utils/index.js";
 //#region src/new-sdk/AbstractNamespace.d.ts
 /**
- * What the on-chain source contributed, after per-chain failures have been
- * turned into metadata.
+ * One read of a combined namespace: the same query against each source, plus
+ * the policy that turns the two answers into one.
  *
- * @internal
+ * @typeParam Onchain - On-chain source namespace.
+ * @typeParam Offchain - Backend source namespace.
+ * @typeParam T - Payload type of the read.
  **/
-interface OnchainContribution<T> {
-  value?: T;
-  chains: MultichainNetworkMeta[];
+interface MergedQuery<Onchain, Offchain, T> {
+  fromChain: (source: Onchain) => Promise<DataResponse<T>>;
+  fromBackend: (source: Offchain) => Promise<DataResponse<T>>;
+  merge: ListMerger<T> | EntityMerger<T>;
 }
 /**
- * What the off-chain source contributed, after a rejection has been turned into
- * metadata.
+ * Base class of every {@link GearboxSDK} namespace: holds the two source
+ * namespaces, exposes each on its own, and runs merged reads over both.
  *
- * @internal
+ * @typeParam Onchain - On-chain source namespace, e.g.
+ *   `MultichainOpportunitiesService`.
+ * @typeParam Offchain - Backend source namespace, e.g. `OffchainOpportunities`.
  **/
-interface OffchainContribution<T> {
-  value?: T;
-  status?: OffchainSourceStatus;
-}
-/**
- * How a read turns the two contributions into one payload. Either side is
- * absent when its source was not asked, or was asked and failed.
- *
- * @internal
- **/
-type CombineSources<T> = (onchain: T | undefined, offchain: T | undefined) => T;
-/**
- * Shared machinery of every {@link GearboxSDK} namespace.
- *
- * A namespace is a stateless router: it asks the sources its mode allows, in
- * parallel, merges what came back and reports what did not. This class owns
- * that routing — per-chain failure capture, backend degradation, the response
- * envelope and the all-sources-failed rule — so a namespace holds nothing but
- * its reads and its merge policy.
- *
- * The sources are whatever it was handed, and their readiness is their owner's
- * business: a source that is not ready to answer fails the read it was given,
- * and that failure is reported like any other.
- *
- * All protocol knowledge lives in the sources: `MultichainSDK` for the chain,
- * `GearboxAPI` for the backend. None of it is repeated here or in a subclass.
- *
- * @typeParam ListRow - Row type of the namespace's list read.
- **/
-declare abstract class AbstractNamespace<ListRow extends object> {
+declare abstract class AbstractNamespace<Onchain, Offchain> {
   #private;
-  protected readonly logger?: ILogger;
-  protected constructor(name: string, onchain: MultichainSDK | undefined, offchain: GearboxAPI | undefined, logger?: ILogger);
-  /**
-   * Per-field source policy for one row of this namespace.
-   **/
-  protected abstract mergeOne<T extends object>(onchain: T, offchain: T): T;
-  /**
-   * Union policy for this namespace's list read.
-   **/
-  protected abstract mergeList(onchain: ListRow[], offchain: ListRow[]): ListRow[];
-  /**
-   * Asks both sources in parallel and combines whatever answered.
-   *
-   * The action name is only used in diagnostics and in the error raised when
-   * every source the read had failed.
-   **/
-  protected read<T>(action: string, fromChain: (sdk: MultichainSDK) => Promise<OnchainContribution<T>>, fromBackend: (api: GearboxAPI) => Promise<OffchainResult<T>>, combine: CombineSources<T>): Promise<ReadResult<T>>;
-  /**
-   * Reads the namespace's list from both sources, unioned by
-   * {@link AbstractNamespace.mergeList}.
-   **/
-  protected readList(action: string, fromChain: (sdk: MultichainSDK) => Promise<OnchainContribution<ListRow[]>>, fromBackend: (api: GearboxAPI) => Promise<OffchainResult<ListRow[]>>): Promise<ReadResult<ListRow[]>>;
-  /**
-   * Reads one row from both sources and merges them under
-   * {@link AbstractNamespace.mergeOne}. The key names the chain, so the
-   * on-chain leg queries exactly one.
-   **/
-  protected readOne<T extends object>(action: string, chainId: ChainId, fromChain: (sdk: MultichainSDK) => Promise<T>, fromBackend: (api: GearboxAPI) => Promise<OffchainResult<T>>): Promise<ReadResult<T>>;
   /**
-   * Reads something only the backend can answer.
-   *
-   * The fallback stands in for a backend that answered with nothing, which is
-   * a different thing from a backend that failed and was dropped.
+   * How far the backend may lag the chain and still serve a chain.
    **/
-  protected readOffchain<T>(action: string, fromBackend: (api: GearboxAPI) => Promise<OffchainResult<T>>, fallback: T): Promise<ReadResult<T>>;
-  /**
-   * Runs a read against the chain, or reports the chain as absent when the
-   * namespace has no on-chain source at all.
-   **/
-  protected fromChain<T>(run: (sdk: MultichainSDK) => Promise<OnchainContribution<T>>): Promise<OnchainContribution<T>>;
+  protected readonly maxOffchainLagSeconds: number;
+  protected readonly logger?: ILogger;
+  protected constructor(name: string, onchain: Onchain | undefined, offchain: Offchain | undefined, options: NamespaceOptions);
   /**
-   * Runs a read against the backend, turning any rejection into metadata so
-   * that a dead backend degrades a `both`-mode read instead of failing it.
+   * The on-chain source namespace on its own. Throws
+   * {@link SourceUnavailableError} in `offchain` mode.
    **/
-  protected fromBackend<T>(run: (api: GearboxAPI) => Promise<OffchainResult<T>>): Promise<OffchainContribution<T>>;
+  get onchain(): Onchain;
   /**
-   * Runs a read against one chain, turning a rejection into that chain's
-   * metadata entry.
+   * The backend source namespace on its own. Throws
+   * {@link SourceUnavailableError} in `onchain` mode.
    **/
-  protected onOneChain<T>(action: string, network: NetworkType, run: () => Promise<T>): Promise<OnchainContribution<T>>;
+  get offchain(): Offchain;
   /**
-   * A read that reached at least one source returns what it has; a read where
-   * every source it had failed throws, because an empty result would otherwise
-   * be indistinguishable from "there is nothing here".
+   * Asks both sources at once and merges what came back, failing only when no
+   * chain was served at all.
    **/
-  protected assertAnySourceSucceeded(action: string, meta: SourceMeta): void;
-  protected networkOf(chainId: ChainId): NetworkType | undefined;
+  protected merged<T>(action: string, query: MergedQuery<Onchain, Offchain, T>): Promise<DataResponse<T>>;
 }
 //#endregion
-export { AbstractNamespace, CombineSources, OffchainContribution, OnchainContribution };
+export { AbstractNamespace, MergedQuery };

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

@@ -7,12 +7,9 @@ import { Positions } from "./positions/types.js";
 import "./positions/index.js";
 //#region src/new-sdk/GearboxSDK.d.ts
 /**
- * Combined entry point over both sources of Gearbox data: the chain and the
- * Gearbox backend.
- *
- * The {@link Mode} is fixed at construction and decides which methods exist,
- * not what they return, so a screen written against `both` cannot silently
- * degrade to a subset when someone reconfigures the SDK:
+ * Entry point over both sources of Gearbox data: the chain and the Gearbox
+ * backend. The {@link Mode} is fixed at construction and decides which methods
+ * exist.
  *
  * ```ts
  * const sdk = new GearboxSDK({
@@ -23,13 +20,9 @@ import "./positions/index.js";
  * });
  * await sdk.attach();
  *
- * const { result, meta } = await sdk.opportunities.list({ kind: "strategy" });
+ * const { data, meta } = await sdk.opportunities.list({ kind: "strategy" });
  * ```
  *
- * Every read answers with `{ result, meta }`: `meta` says which chains and
- * which backend answered, because a partial answer is the normal case for a
- * multi-chain read.
- *
  * @typeParam M - Mode the instance was built in.
  **/
 declare class GearboxSDK<const M extends Mode = Mode> {
@@ -39,8 +32,7 @@ declare class GearboxSDK<const M extends Mode = Mode> {
    **/
   readonly mode: M;
   /**
-   * Chains this instance covers. Authoritative even when an injected on-chain
-   * SDK covers a different set.
+   * Chains this instance covers, which every read is scoped to.
    **/
   readonly networks: readonly NetworkType[];
   /**
@@ -53,26 +45,19 @@ declare class GearboxSDK<const M extends Mode = Mode> {
   readonly positions: Positions<M>;
   constructor(options: GearboxSDKOptions<M>);
   /**
-   * Attaches the on-chain SDK when this instance owns one.
-   *
-   * Reads issued before this resolves still reach the chain and fail there, so
-   * in `both` mode they are served from the backend alone and report the chain
-   * as failed in their meta, rather than blocking.
-   *
-   * A no-op in `offchain` mode and when an already-attached SDK was injected.
+   * Attaches the on-chain SDK when this instance owns one; a no-op in `offchain`
+   * mode and when an already-attached SDK was injected.
    **/
   attach(): Promise<void>;
   /**
    * Whether the on-chain source is ready to be read from. Always `true` in
-   * `offchain` mode, where there is nothing to wait for.
+   * `offchain` mode.
    **/
   get attached(): boolean;
   /**
    * The underlying on-chain SDK, for everything this facade does not expose
-   * yet: markets, credit accounts, transaction building.
-   *
-   * `undefined` in `offchain` mode. Otherwise it exists from construction on,
-   * but only answers reads once {@link attach} has resolved.
+   * yet: markets, credit accounts, transaction building. `undefined` in
+   * `offchain` mode, and only answers reads once {@link attach} has resolved.
    **/
   get onchain(): OnchainByMode[M];
   /**

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

@@ -0,0 +1,11 @@
+import { ResponseMetadata } from "../../model/response.js";
+import "../../model/index.js";
+//#region src/new-sdk/errors/AllSourcesFailedError.d.ts
+/**
+ * Thrown when a read had sources to ask and none of them served a single chain.
+ **/
+declare class AllSourcesFailedError extends AggregateError {
+  constructor(action: string, sourceErrors: unknown[], meta?: ResponseMetadata);
+}
+//#endregion
+export { AllSourcesFailedError };

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

@@ -0,0 +1,23 @@
+import { DataSource } from "../../model/response.js";
+import "../../model/index.js";
+import { Mode } from "../types.js";
+import { BaseError } from "viem";
+//#region src/new-sdk/errors/MissingSourceError.d.ts
+/**
+ * Thrown at construction when a {@link GearboxSDK} was not given a source its
+ * {@link Mode} reads from.
+ **/
+declare class MissingSourceError extends BaseError {
+  name: string;
+  /**
+   * Mode the SDK was built in.
+   **/
+  readonly mode: Mode;
+  /**
+   * Source that mode needs and did not get.
+   **/
+  readonly source: DataSource;
+  constructor(mode: Mode, source: DataSource);
+}
+//#endregion
+export { MissingSourceError };

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

@@ -0,0 +1,17 @@
+import { ChainId } from "../../model/primitives.js";
+import "../../model/index.js";
+//#region src/new-sdk/errors/NoSourceServedError.d.ts
+/**
+ * The failure of a chain no source served. It is reported in that chain's
+ * metadata entry rather than thrown: the other chains of the same read may
+ * still have been served.
+ **/
+declare class NoSourceServedError extends AggregateError {
+  /**
+   * Chain no source served.
+   **/
+  readonly chainId: ChainId;
+  constructor(chainId: ChainId, reasons: unknown[]);
+}
+//#endregion
+export { NoSourceServedError };

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

@@ -0,0 +1,35 @@
+import { ChainId } from "../../model/primitives.js";
+import { NetworkType } from "../../sdk/chain/chains.js";
+import { DataSource } from "../../model/response.js";
+import "../../model/index.js";
+import "../../sdk/index.js";
+import { BaseError } from "viem";
+//#region src/new-sdk/errors/SourceChainMismatchError.d.ts
+/**
+ * How a source names the chains it covers: by label or by id, depending on which
+ * of the two it was configured with.
+ **/
+type ChainRef = NetworkType | ChainId;
+/**
+ * Thrown at construction when a source covers anything other than exactly the
+ * chains a {@link GearboxSDK} was built for, see
+ * {@link GearboxSDKOptions.networks}.
+ **/
+declare class SourceChainMismatchError extends BaseError {
+  name: string;
+  /**
+   * Source whose coverage does not match.
+   **/
+  readonly source: DataSource;
+  /**
+   * Chains the SDK covers.
+   **/
+  readonly expected: readonly ChainRef[];
+  /**
+   * Chains the source covers.
+   **/
+  readonly covered: readonly ChainRef[];
+  constructor(source: DataSource, expected: readonly ChainRef[], covered: readonly ChainRef[]);
+}
+//#endregion
+export { ChainRef, SourceChainMismatchError };

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

@@ -0,0 +1,22 @@
+import { DataSource } from "../../model/response.js";
+import "../../model/index.js";
+import { BaseError } from "viem";
+//#region src/new-sdk/errors/SourceUnavailableError.d.ts
+/**
+ * Thrown when a source branch of a namespace is read in a mode that has no such
+ * source, e.g. `sdk.opportunities.onchain` in `offchain` mode.
+ **/
+declare class SourceUnavailableError extends BaseError {
+  name: string;
+  /**
+   * Namespace whose branch was read.
+   **/
+  readonly namespace: string;
+  /**
+   * Source this mode does not read.
+   **/
+  readonly source: DataSource;
+  constructor(namespace: string, source: DataSource);
+}
+//#endregion
+export { SourceUnavailableError };

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

@@ -0,0 +1,11 @@
+import { DataSource } from "../../model/response.js";
+import "../../model/index.js";
+import { ChainRef } from "./SourceChainMismatchError.js";
+//#region src/new-sdk/errors/assertSameChains.d.ts
+/**
+ * Rejects a source covering anything other than exactly the chains the SDK was
+ * built for. A source is not narrowed to them: it has to name them.
+ **/
+declare function assertSameChains<T extends ChainRef>(source: DataSource, expected: readonly T[], covered: readonly T[]): void;
+//#endregion
+export { assertSameChains };

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

@@ -0,0 +1,10 @@
+import { ResponseMetadata } from "../../model/response.js";
+import "../../model/index.js";
+//#region src/new-sdk/errors/everyChainFailed.d.ts
+/**
+ * Whether a merged envelope covered chains and lost every one of them, which is
+ * what makes a read a failure rather than a partial result.
+ **/
+declare function everyChainFailed(meta: ResponseMetadata): boolean;
+//#endregion
+export { everyChainFailed };