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

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 { SourceMerger } 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: SourceMerger<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 };

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

@@ -0,0 +1,8 @@
+import { AllSourcesFailedError } from "./AllSourcesFailedError.js";
+import { MissingSourceError } from "./MissingSourceError.js";
+import { NoSourceServedError } from "./NoSourceServedError.js";
+import { ChainRef, SourceChainMismatchError } from "./SourceChainMismatchError.js";
+import { SourceUnavailableError } from "./SourceUnavailableError.js";
+import { assertSameChains } from "./assertSameChains.js";
+import { everyChainFailed } from "./everyChainFailed.js";
+export { AllSourcesFailedError, ChainRef, MissingSourceError, NoSourceServedError, SourceChainMismatchError, SourceUnavailableError, assertSameChains, everyChainFailed };

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

@@ -1,12 +1,23 @@
-import { AllSourcesFailedError, GearboxSDKOptions, Mode, OffchainByMode, OffchainSource, OffchainSourceStatus, OnchainByMode, OnchainSource, PlainMultichainSDKOptions, ReadResult, SourceMeta } from "./types.js";
-import { AbstractNamespace, CombineSources, OffchainContribution, OnchainContribution } from "./AbstractNamespace.js";
-import { Chart, ChartMetadata, HistoryReader } from "./utils/history.js";
+import { GearboxSDKOptions, Mode, NamespaceOptions, OffchainByMode, OffchainSource, OnchainByMode, OnchainSource, PlainMultichainSDKOptions } from "./types.js";
+import { filterResponse } from "./utils/filterResponse.js";
+import { HistoryReader } from "./utils/history.js";
+import { DEFAULT_MAX_OFFCHAIN_LAG, mergeChainList, mergeChainOne } from "./utils/mergeChains.js";
+import { SourceMerger } from "./utils/types.js";
 import "./utils/index.js";
-import { Opportunities, OpportunitiesBase, OpportunitiesByMode, OpportunitiesOffchainOnly, OpportunitiesOnchainOnly } from "./opportunities/types.js";
+import { AbstractNamespace, MergedQuery } from "./AbstractNamespace.js";
+import { Opportunities, OpportunitiesBase, OpportunitiesByMode, OpportunitiesMerged, OpportunitiesOffchainBranch, OpportunitiesOffchainOnly, OpportunitiesOnchainBranch, OpportunitiesOnchainOnly, OpportunityMergers } from "./opportunities/types.js";
 import { OpportunitiesNamespace } from "./opportunities/OpportunitiesNamespace.js";
 import "./opportunities/index.js";
-import { Positions, PositionsBase, PositionsByMode, PositionsOffchainOnly, PositionsOnchainOnly } from "./positions/types.js";
+import { PositionMergers, Positions, PositionsBase, PositionsByMode, PositionsMerged, PositionsOffchainBranch, PositionsOffchainOnly, PositionsOnchainBranch, PositionsOnchainOnly } from "./positions/types.js";
 import { PositionsNamespace } from "./positions/PositionsNamespace.js";
 import "./positions/index.js";
 import { GearboxSDK } from "./GearboxSDK.js";
-export { AbstractNamespace, AllSourcesFailedError, Chart, ChartMetadata, CombineSources, GearboxSDK, GearboxSDKOptions, HistoryReader, Mode, OffchainByMode, OffchainContribution, OffchainSource, OffchainSourceStatus, OnchainByMode, OnchainContribution, OnchainSource, Opportunities, OpportunitiesBase, OpportunitiesByMode, OpportunitiesNamespace, OpportunitiesOffchainOnly, OpportunitiesOnchainOnly, PlainMultichainSDKOptions, Positions, PositionsBase, PositionsByMode, PositionsNamespace, PositionsOffchainOnly, PositionsOnchainOnly, ReadResult, SourceMeta };
+import { AllSourcesFailedError } from "./errors/AllSourcesFailedError.js";
+import { MissingSourceError } from "./errors/MissingSourceError.js";
+import { NoSourceServedError } from "./errors/NoSourceServedError.js";
+import { ChainRef, SourceChainMismatchError } from "./errors/SourceChainMismatchError.js";
+import { SourceUnavailableError } from "./errors/SourceUnavailableError.js";
+import { assertSameChains } from "./errors/assertSameChains.js";
+import { everyChainFailed } from "./errors/everyChainFailed.js";
+import "./errors/index.js";
+export { AbstractNamespace, AllSourcesFailedError, ChainRef, DEFAULT_MAX_OFFCHAIN_LAG, GearboxSDK, GearboxSDKOptions, HistoryReader, MergedQuery, MissingSourceError, Mode, NamespaceOptions, NoSourceServedError, OffchainByMode, OffchainSource, OnchainByMode, OnchainSource, Opportunities, OpportunitiesBase, OpportunitiesByMode, OpportunitiesMerged, OpportunitiesNamespace, OpportunitiesOffchainBranch, OpportunitiesOffchainOnly, OpportunitiesOnchainBranch, OpportunitiesOnchainOnly, OpportunityMergers, PlainMultichainSDKOptions, PositionMergers, Positions, PositionsBase, PositionsByMode, PositionsMerged, PositionsNamespace, PositionsOffchainBranch, PositionsOffchainOnly, PositionsOnchainBranch, PositionsOnchainOnly, SourceChainMismatchError, type SourceMerger, SourceUnavailableError, assertSameChains, everyChainFailed, filterResponse, mergeChainList, mergeChainOne };

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

@@ -1,69 +1,48 @@
-import { ILogger } from "../../sdk/types/logger.js";
 import { Opportunity, OpportunityFilter, PoolOpportunityDetail, PoolOpportunityKey, PoolOpportunityRef, StrategyOpportunityDetail, StrategyOpportunityKey, StrategyOpportunityRef } from "../../model/opportunities.js";
 import { PoolHistoryMetric, StrategyHistoryMetric } from "../../model/history.js";
+import { DataResponse } from "../../model/response.js";
 import "../../model/index.js";
 import { MultichainSDK } from "../../sdk/MultichainSDK.js";
 import "../../sdk/index.js";
 import { GearboxAPI } from "../../offchain/GearboxAPI.js";
 import "../../offchain/index.js";
-import { ReadResult } from "../types.js";
-import { AbstractNamespace } from "../AbstractNamespace.js";
+import { NamespaceOptions } from "../types.js";
 import { HistoryReader } from "../utils/history.js";
 import "../utils/index.js";
-import { OpportunitiesBase, OpportunitiesOffchainOnly } from "./types.js";
+import { AbstractNamespace } from "../AbstractNamespace.js";
+import { OpportunitiesBase, OpportunitiesOffchainOnly, OpportunityMergers } from "./types.js";
 //#region src/new-sdk/opportunities/OpportunitiesNamespace.d.ts
 /**
- * The `opportunities` namespace of the combined SDK.
- *
- * A stateless router over the two sources, see {@link AbstractNamespace} for
- * the routing itself. What is specific to opportunities is the reads below and
- * the merge policy at the bottom of the class.
- *
- * The class implements the methods of every mode; {@link GearboxSDK} exposes it
- * as its mode's slice of {@link OpportunitiesByMode}, so calling a method the
- * mode does not have is a compile error rather than a runtime one.
+ * The `opportunities` namespace of a {@link GearboxSDK}, see
+ * {@link OpportunitiesByMode} for what each mode offers.
  **/
-declare class OpportunitiesNamespace extends AbstractNamespace<Opportunity> implements OpportunitiesBase, OpportunitiesOffchainOnly {
-  #private;
-  constructor(onchain: MultichainSDK | undefined, offchain: GearboxAPI | undefined, logger?: ILogger);
+declare class OpportunitiesNamespace extends AbstractNamespace<MultichainSDK["opportunities"], GearboxAPI["opportunities"]> implements OpportunitiesBase, OpportunitiesOffchainOnly {
+  /**
+   * {@inheritDoc OpportunitiesBase.merge}
+   **/
+  readonly merge: OpportunityMergers;
+  constructor(onchain: MultichainSDK | undefined, offchain: GearboxAPI | undefined, options: NamespaceOptions);
   /**
    * {@inheritDoc OpportunitiesBase.list}
    **/
-  list(filter?: OpportunityFilter): Promise<ReadResult<Opportunity[]>>;
+  list(filter?: OpportunityFilter): Promise<DataResponse<Opportunity[]>>;
   /**
    * {@inheritDoc OpportunitiesBase.getPool}
    **/
-  getPool(key: PoolOpportunityKey): Promise<ReadResult<PoolOpportunityDetail>>;
+  getPool(key: PoolOpportunityKey): Promise<DataResponse<PoolOpportunityDetail>>;
   /**
    * {@inheritDoc OpportunitiesBase.getStrategy}
    **/
-  getStrategy(key: StrategyOpportunityKey): Promise<ReadResult<StrategyOpportunityDetail>>;
+  getStrategy(key: StrategyOpportunityKey): Promise<DataResponse<StrategyOpportunityDetail>>;
+  /**
+   * {@inheritDoc OpportunitiesBase.filter}
+   **/
+  filter(response: DataResponse<Opportunity[]> | undefined, filter?: OpportunityFilter): DataResponse<Opportunity[]> | undefined;
   /**
    * {@inheritDoc OpportunitiesOffchainOnly.history}
    **/
   history(key: PoolOpportunityRef): HistoryReader<PoolHistoryMetric>;
   history(key: StrategyOpportunityRef): HistoryReader<StrategyHistoryMetric>;
-  /**
-   * Merges the two versions of one opportunity.
-   *
-   * The chain wins every field it fills; the backend fills the rest and owns
-   * {@link OFFCHAIN_OWNED_FIELDS}.
-   *
-   * The rule is onchain-first, field-wise, and never deeper than one level: a
-   * group like `totalSupply` or `supplyApy` is taken whole from one source, so
-   * a row never mixes an on-chain token amount with a backend dollar value
-   * derived from a different block.
-   **/
-  protected mergeOne<T extends object>(onchain: T, offchain: T): T;
-  /**
-   * Unions the two lists by canonical opportunity id.
-   *
-   * Rows present in both are merged by {@link OpportunitiesNamespace.mergeOne}.
-   * Rows only the backend knows are appended: a chain the SDK does not cover,
-   * or a market it has not loaded, is a reason to show more rather than fewer
-   * opportunities.
-   **/
-  protected mergeList(onchain: Opportunity[], offchain: Opportunity[]): Opportunity[];
 }
 //#endregion
 export { OpportunitiesNamespace };

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

@@ -1,3 +1,3 @@
-import { Opportunities, OpportunitiesBase, OpportunitiesByMode, OpportunitiesOffchainOnly, OpportunitiesOnchainOnly } from "./types.js";
+import { Opportunities, OpportunitiesBase, OpportunitiesByMode, OpportunitiesMerged, OpportunitiesOffchainBranch, OpportunitiesOffchainOnly, OpportunitiesOnchainBranch, OpportunitiesOnchainOnly, OpportunityMergers } from "./types.js";
 import { OpportunitiesNamespace } from "./OpportunitiesNamespace.js";
-export { Opportunities, OpportunitiesBase, OpportunitiesByMode, OpportunitiesNamespace, OpportunitiesOffchainOnly, OpportunitiesOnchainOnly };
+export { Opportunities, OpportunitiesBase, OpportunitiesByMode, OpportunitiesMerged, OpportunitiesNamespace, OpportunitiesOffchainBranch, OpportunitiesOffchainOnly, OpportunitiesOnchainBranch, OpportunitiesOnchainOnly, OpportunityMergers };