@gearbox-protocol/sdk 14.12.0-next.66 → 14.12.0-next.67

package/dist/cjs/model/opportunities.js

@@ -0,0 +1,55 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/model/opportunities.ts
+/**
+* Builds the canonical id of a pool opportunity.
+*
+* @example
+* ```ts
+* poolOpportunityId(1, "0xda00...") // "1:0xda00..."
+* ```
+**/
+function poolOpportunityId(chainId, pool) {
+	return `${chainId}:${pool.toLowerCase()}`;
+}
+/**
+* Builds the canonical id of a strategy opportunity.
+*
+* @example
+* ```ts
+* strategyOpportunityId(1, "0x3eb9...", "0x7f39...") // "1:0x3eb9...:0x7f39..."
+* ```
+**/
+function strategyOpportunityId(chainId, creditManager, targetCollateral) {
+	return `${chainId}:${creditManager.toLowerCase()}:${targetCollateral.toLowerCase()}`;
+}
+/**
+* Canonical id of any opportunity, dispatching on {@link Opportunity.kind}.
+**/
+function opportunityId(opportunity) {
+	return opportunity.kind === "pool" ? poolOpportunityId(opportunity.chainId, opportunity.pool) : strategyOpportunityId(opportunity.chainId, opportunity.creditManager, opportunity.targetCollateral.address);
+}
+/**
+* Whether an opportunity satisfies every criterion of a filter.
+*
+* This is the single definition of what each criterion means: every source
+* builds its rows first and runs them through here, so the chain and the
+* backend cannot disagree on what a filter selects.
+*
+* @param opportunity - Row to test.
+* @param filter - Criteria to test against. An absent filter matches anything.
+**/
+function matchesOpportunityFilter(opportunity, filter) {
+	if (!filter) return true;
+	if (filter.kind && opportunity.kind !== filter.kind) return false;
+	if (filter.chainIds && !filter.chainIds.includes(opportunity.chainId)) return false;
+	if (filter.underlyingType && opportunity.underlyingToken.assetType !== filter.underlyingType) return false;
+	if (filter.paused !== void 0 && opportunity.paused !== filter.paused) return false;
+	if (filter.sunset !== void 0 && opportunity.sunset !== filter.sunset) return false;
+	if (filter.rwa !== void 0 && opportunity.rwa !== filter.rwa) return false;
+	return true;
+}
+//#endregion
+exports.matchesOpportunityFilter = matchesOpportunityFilter;
+exports.opportunityId = opportunityId;
+exports.poolOpportunityId = poolOpportunityId;
+exports.strategyOpportunityId = strategyOpportunityId;

package/dist/cjs/model/opportunities.schema.js

@@ -0,0 +1,220 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_utils_zod = require("../sdk/utils/zod.js");
+const require_model_primitives_schema = require("./primitives.schema.js");
+let zod_v4 = require("zod/v4");
+//#region src/model/opportunities.schema.ts
+/**
+* Runtime schemas for {@link ./opportunities.js}, see the note in
+* `primitives.schema.ts` on why they are written by hand.
+**/
+/**
+* {@link OpportunityKind}
+**/
+const opportunityKindSchema = zod_v4.z.union([zod_v4.z.literal("pool"), zod_v4.z.literal("strategy")]);
+/**
+* {@link PointsProgram}
+**/
+const pointsProgramSchema = zod_v4.z.object({
+	id: zod_v4.z.string(),
+	name: zod_v4.z.string(),
+	multiplier: zod_v4.z.number().nullable()
+});
+/**
+* {@link TokenRewards}
+**/
+const tokenRewardsSchema = zod_v4.z.object({
+	kind: zod_v4.z.literal("token"),
+	token: require_model_primitives_schema.tokenSchema,
+	supplyApr: require_model_primitives_schema.bpsSchema.optional(),
+	borrowApr: require_model_primitives_schema.bpsSchema.optional()
+});
+/**
+* {@link PointRewards}
+**/
+const pointRewardsSchema = zod_v4.z.object({
+	kind: zod_v4.z.literal("point"),
+	points: zod_v4.z.array(pointsProgramSchema)
+});
+/**
+* {@link Rewards}
+**/
+const rewardsSchema = zod_v4.z.discriminatedUnion("kind", [tokenRewardsSchema, pointRewardsSchema]);
+/**
+* {@link ApyBreakdown}
+**/
+const apyBreakdownSchema = zod_v4.z.object({
+	totalApy: require_model_primitives_schema.bpsSchema,
+	organicApy: require_model_primitives_schema.bpsSchema,
+	rewards: zod_v4.z.array(rewardsSchema)
+});
+/**
+* {@link OpportunityBase}
+**/
+const opportunityBaseSchema = zod_v4.z.object({
+	chainId: require_model_primitives_schema.chainIdSchema,
+	title: zod_v4.z.string(),
+	curator: require_model_primitives_schema.curatorSchema,
+	underlyingToken: require_model_primitives_schema.tokenSchema,
+	totalSupply: require_model_primitives_schema.amountSchema,
+	totalBorrow: require_model_primitives_schema.amountSchema,
+	utilization: require_model_primitives_schema.bpsSchema,
+	supplyApy: apyBreakdownSchema.optional(),
+	collateralTokens: zod_v4.z.array(require_model_primitives_schema.tokenSchema),
+	paused: zod_v4.z.boolean(),
+	rwa: zod_v4.z.boolean(),
+	sunset: zod_v4.z.boolean()
+});
+/**
+* {@link PoolOpportunity}
+**/
+const poolOpportunitySchema = zod_v4.z.object({
+	...opportunityBaseSchema.shape,
+	kind: zod_v4.z.literal("pool"),
+	pool: require_sdk_utils_zod.ZodAddress()
+});
+/**
+* {@link StrategyOpportunity}
+**/
+const strategyOpportunitySchema = zod_v4.z.object({
+	...opportunityBaseSchema.shape,
+	kind: zod_v4.z.literal("strategy"),
+	creditManager: require_sdk_utils_zod.ZodAddress(),
+	targetCollateral: require_model_primitives_schema.tokenSchema,
+	liquidationThreshold: require_model_primitives_schema.bpsSchema,
+	liquidationPremium: require_model_primitives_schema.bpsSchema,
+	liquidationFee: require_model_primitives_schema.bpsSchema,
+	expirationDate: require_model_primitives_schema.timestampSchema.nullable(),
+	collateralApy: apyBreakdownSchema.optional(),
+	borrowApy: require_model_primitives_schema.bpsSchema.optional(),
+	additionalBorrowApy: require_model_primitives_schema.bpsSchema.optional(),
+	maxBorrowAmount: require_model_primitives_schema.amountSchema,
+	maxLeverage: require_model_primitives_schema.leverageSchema
+});
+/**
+* {@link Opportunity}
+**/
+const opportunitySchema = zod_v4.z.discriminatedUnion("kind", [poolOpportunitySchema, strategyOpportunitySchema]);
+/**
+* {@link OpportunityFilter}
+**/
+const opportunityFilterSchema = zod_v4.z.object({
+	kind: opportunityKindSchema.optional(),
+	chainIds: zod_v4.z.array(require_model_primitives_schema.chainIdSchema).optional(),
+	underlyingType: require_model_primitives_schema.assetTypeSchema.optional(),
+	paused: zod_v4.z.boolean().optional(),
+	sunset: zod_v4.z.boolean().optional(),
+	rwa: zod_v4.z.boolean().optional()
+});
+/**
+* {@link RateCurvePoint}
+**/
+const rateCurvePointSchema = zod_v4.z.object({
+	utilization: require_model_primitives_schema.bpsSchema,
+	supplyApy: require_model_primitives_schema.bpsSchema,
+	borrowApy: require_model_primitives_schema.bpsSchema
+});
+/**
+* {@link RateCurve}
+**/
+const rateCurveSchema = zod_v4.z.object({
+	points: zod_v4.z.array(rateCurvePointSchema),
+	borrowingLimitUtilization: require_model_primitives_schema.bpsSchema.nullable()
+});
+/**
+* {@link QuotaAsset}
+**/
+const quotaAssetSchema = zod_v4.z.object({
+	token: require_model_primitives_schema.tokenSchema,
+	quotaRate: require_model_primitives_schema.bpsSchema,
+	limit: require_model_primitives_schema.amountSchema,
+	used: require_model_primitives_schema.amountSchema
+});
+/**
+* {@link PriceFeedData}. Recursive: a composite feed lists the feeds it reads.
+**/
+const priceFeedDataSchema = zod_v4.z.object({
+	name: zod_v4.z.string(),
+	type: zod_v4.z.string(),
+	feedAddress: require_sdk_utils_zod.ZodAddress(),
+	get dependencies() {
+		return zod_v4.z.array(priceFeedDataSchema);
+	}
+});
+/**
+* {@link PriceFeedSummary}
+**/
+const priceFeedSummarySchema = zod_v4.z.object({
+	underlyingPriceInUsd: zod_v4.z.number(),
+	collateralPriceInUsd: zod_v4.z.number(),
+	collateralPriceInUnderlying: zod_v4.z.number(),
+	underlyingFeed: priceFeedDataSchema,
+	collateralFeed: priceFeedDataSchema
+});
+/**
+* {@link PoolOpportunityDetail}
+**/
+const poolOpportunityDetailSchema = zod_v4.z.object({
+	...poolOpportunitySchema.shape,
+	rateCurve: rateCurveSchema,
+	quotaAssets: zod_v4.z.array(quotaAssetSchema)
+});
+/**
+* {@link StrategyOpportunityDetail}
+**/
+const strategyOpportunityDetailSchema = zod_v4.z.object({
+	...strategyOpportunitySchema.shape,
+	rateCurve: rateCurveSchema,
+	priceFeeds: priceFeedSummarySchema
+});
+/**
+* {@link OpportunityDetail}
+**/
+const opportunityDetailSchema = zod_v4.z.discriminatedUnion("kind", [poolOpportunityDetailSchema, strategyOpportunityDetailSchema]);
+/**
+* {@link PoolOpportunityKey}
+**/
+const poolOpportunityKeySchema = zod_v4.z.object({
+	chainId: require_model_primitives_schema.chainIdSchema,
+	pool: require_sdk_utils_zod.ZodAddress()
+});
+/**
+* {@link StrategyOpportunityKey}
+**/
+const strategyOpportunityKeySchema = zod_v4.z.object({
+	chainId: require_model_primitives_schema.chainIdSchema,
+	creditManager: require_sdk_utils_zod.ZodAddress(),
+	targetCollateral: require_sdk_utils_zod.ZodAddress()
+});
+/**
+* {@link OpportunityKey}
+**/
+const opportunityKeySchema = zod_v4.z.discriminatedUnion("kind", [zod_v4.z.object({
+	kind: zod_v4.z.literal("pool"),
+	...poolOpportunityKeySchema.shape
+}), zod_v4.z.object({
+	kind: zod_v4.z.literal("strategy"),
+	...strategyOpportunityKeySchema.shape
+})]);
+//#endregion
+exports.apyBreakdownSchema = apyBreakdownSchema;
+exports.opportunityBaseSchema = opportunityBaseSchema;
+exports.opportunityDetailSchema = opportunityDetailSchema;
+exports.opportunityFilterSchema = opportunityFilterSchema;
+exports.opportunityKeySchema = opportunityKeySchema;
+exports.opportunityKindSchema = opportunityKindSchema;
+exports.opportunitySchema = opportunitySchema;
+exports.pointRewardsSchema = pointRewardsSchema;
+exports.pointsProgramSchema = pointsProgramSchema;
+exports.poolOpportunityDetailSchema = poolOpportunityDetailSchema;
+exports.poolOpportunityKeySchema = poolOpportunityKeySchema;
+exports.poolOpportunitySchema = poolOpportunitySchema;
+exports.priceFeedDataSchema = priceFeedDataSchema;
+exports.priceFeedSummarySchema = priceFeedSummarySchema;
+exports.quotaAssetSchema = quotaAssetSchema;
+exports.rateCurvePointSchema = rateCurvePointSchema;
+exports.rateCurveSchema = rateCurveSchema;
+exports.rewardsSchema = rewardsSchema;
+exports.strategyOpportunityDetailSchema = strategyOpportunityDetailSchema;
+exports.strategyOpportunityKeySchema = strategyOpportunityKeySchema;
+exports.strategyOpportunitySchema = strategyOpportunitySchema;
+exports.tokenRewardsSchema = tokenRewardsSchema;

package/dist/cjs/model/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

package/dist/cjs/model/positions.js

@@ -0,0 +1 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });

package/dist/cjs/model/primitives.js

@@ -0,0 +1 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });

package/dist/cjs/model/primitives.schema.js

@@ -0,0 +1,85 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_utils_zod = require("../sdk/utils/zod.js");
+let zod_v4 = require("zod/v4");
+//#region src/model/primitives.schema.ts
+/**
+* Runtime schemas for {@link ./primitives.js}.
+*
+* The hand-written types are the contract; these schemas exist so the offchain
+* client can reject a backend response that no longer matches it. The two are
+* kept in sync by the type-level tests in `model.test-d.ts`, not by inferring
+* one from the other.
+**/
+/**
+* {@link ChainId}
+**/
+const chainIdSchema = zod_v4.z.number().int().positive();
+/**
+* {@link Timestamp}
+**/
+const timestampSchema = zod_v4.z.number().int().nonnegative();
+/**
+* {@link Bps}. Integer, not bounded to `0..10000`: rates may exceed 100%.
+**/
+const bpsSchema = zod_v4.z.number().int();
+/**
+* {@link AssetType}
+**/
+const assetTypeSchema = zod_v4.z.union([
+	zod_v4.z.literal("Stable"),
+	zod_v4.z.literal("ETH"),
+	zod_v4.z.literal("BTC")
+]);
+/**
+* {@link Leverage}
+**/
+const leverageSchema = zod_v4.z.number().positive();
+/**
+* {@link Amount}
+**/
+const amountSchema = zod_v4.z.object({
+	value: zod_v4.z.bigint(),
+	valueUsd: zod_v4.z.number().nullable()
+});
+/**
+* {@link Token}
+**/
+const tokenSchema = zod_v4.z.object({
+	chainId: chainIdSchema,
+	address: require_sdk_utils_zod.ZodAddress(),
+	symbol: zod_v4.z.string(),
+	name: zod_v4.z.string(),
+	decimals: zod_v4.z.number().int().nonnegative(),
+	assetType: assetTypeSchema.optional()
+});
+/**
+* {@link TokenAmount}
+**/
+const tokenAmountSchema = amountSchema.extend({ token: tokenSchema });
+/**
+* {@link TxCall}
+**/
+const txCallSchema = zod_v4.z.object({
+	to: require_sdk_utils_zod.ZodAddress(),
+	callData: require_sdk_utils_zod.ZodHex(),
+	value: zod_v4.z.bigint().optional()
+});
+/**
+* {@link Curator}
+**/
+const curatorSchema = zod_v4.z.object({
+	address: require_sdk_utils_zod.ZodAddress(),
+	name: zod_v4.z.string(),
+	url: zod_v4.z.string().nullable()
+});
+//#endregion
+exports.amountSchema = amountSchema;
+exports.assetTypeSchema = assetTypeSchema;
+exports.bpsSchema = bpsSchema;
+exports.chainIdSchema = chainIdSchema;
+exports.curatorSchema = curatorSchema;
+exports.leverageSchema = leverageSchema;
+exports.timestampSchema = timestampSchema;
+exports.tokenAmountSchema = tokenAmountSchema;
+exports.tokenSchema = tokenSchema;
+exports.txCallSchema = txCallSchema;

package/dist/cjs/new-sdk/AbstractNamespace.js

@@ -0,0 +1,158 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_chain_chains = require("../sdk/chain/chains.js");
+const require_new_sdk_types = require("./types.js");
+//#region src/new-sdk/AbstractNamespace.ts
+/**
+* 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.
+**/
+var AbstractNamespace = class {
+	logger;
+	#onchain;
+	#offchain;
+	constructor(name, onchain, offchain, logger) {
+		this.#onchain = onchain;
+		this.#offchain = offchain;
+		this.logger = logger?.child?.({ name }) ?? logger;
+	}
+	/**
+	* 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.
+	**/
+	async read(action, fromChain, fromBackend, combine) {
+		const [onchain, offchain] = await Promise.all([this.fromChain(fromChain), this.fromBackend(fromBackend)]);
+		const meta = toMeta(onchain, offchain);
+		this.assertAnySourceSucceeded(action, meta);
+		return {
+			result: combine(onchain.value, offchain.value),
+			meta
+		};
+	}
+	/**
+	* Reads the namespace's list from both sources, unioned by
+	* {@link AbstractNamespace.mergeList}.
+	**/
+	async readList(action, fromChain, fromBackend) {
+		return this.read(action, fromChain, fromBackend, (onchain, offchain) => this.mergeList(onchain ?? [], offchain ?? []));
+	}
+	/**
+	* 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.
+	**/
+	async readOne(action, chainId, fromChain, fromBackend) {
+		return this.read(action, async (sdk) => {
+			const network = this.networkOf(chainId);
+			if (!network) return { chains: [] };
+			return this.onOneChain(action, network, () => fromChain(sdk));
+		}, fromBackend, (onchain, offchain) => {
+			if (onchain && offchain) return this.mergeOne(onchain, offchain);
+			return onchain ?? offchain;
+		});
+	}
+	/**
+	* 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.
+	**/
+	async readOffchain(action, fromBackend, fallback) {
+		const offchain = await this.fromBackend(fromBackend);
+		const meta = toMeta({ chains: [] }, offchain);
+		this.assertAnySourceSucceeded(action, meta);
+		return {
+			result: offchain.value ?? fallback,
+			meta
+		};
+	}
+	/**
+	* Runs a read against the chain, or reports the chain as absent when the
+	* namespace has no on-chain source at all.
+	**/
+	async fromChain(run) {
+		return this.#onchain ? run(this.#onchain) : { chains: [] };
+	}
+	/**
+	* 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.
+	**/
+	async fromBackend(run) {
+		if (!this.#offchain) return {};
+		try {
+			const { result, meta } = await run(this.#offchain);
+			return {
+				value: meta.status === "success" ? result : void 0,
+				status: meta
+			};
+		} catch (error) {
+			this.logger?.warn(error, "offchain read failed");
+			return { status: {
+				status: "error",
+				error
+			} };
+		}
+	}
+	/**
+	* Runs a read against one chain, turning a rejection into that chain's
+	* metadata entry.
+	**/
+	async onOneChain(action, network, run) {
+		try {
+			return {
+				value: await run(),
+				chains: [{
+					network,
+					status: "success"
+				}]
+			};
+		} catch (error) {
+			this.logger?.warn(error, `failed to ${action} on ${network}`);
+			return { chains: [{
+				network,
+				status: "error",
+				error
+			}] };
+		}
+	}
+	/**
+	* 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".
+	**/
+	assertAnySourceSucceeded(action, meta) {
+		const asked = meta.chains.length > 0 || meta.offchain !== void 0;
+		const answered = meta.chains.some((c) => c.status === "success") || meta.offchain?.status === "success";
+		if (asked && !answered) throw new require_new_sdk_types.AllSourcesFailedError(action, meta);
+	}
+	networkOf(chainId) {
+		try {
+			return require_sdk_chain_chains.getNetworkType(chainId);
+		} catch {
+			this.logger?.debug(`chain ${chainId} is not a Gearbox network, skipping the onchain source`);
+			return;
+		}
+	}
+};
+function toMeta(onchain, offchain) {
+	const meta = { chains: onchain.chains };
+	if (offchain.status) meta.offchain = offchain.status;
+	return meta;
+}
+//#endregion
+exports.AbstractNamespace = AbstractNamespace;

package/dist/cjs/new-sdk/GearboxSDK.js

@@ -0,0 +1,122 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_MultichainSDK = require("../sdk/MultichainSDK.js");
+require("../sdk/index.js");
+const require_offchain_GearboxAPI = require("../offchain/GearboxAPI.js");
+require("../offchain/index.js");
+const require_new_sdk_opportunities_OpportunitiesNamespace = require("./opportunities/OpportunitiesNamespace.js");
+require("./opportunities/index.js");
+//#region src/new-sdk/GearboxSDK.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:
+*
+* ```ts
+* const sdk = new GearboxSDK({
+*   mode: "both",
+*   networks: ["Mainnet"],
+*   onchain: { chains: { Mainnet: { rpcURLs } } },
+*   offchain: { baseUrl: "https://api.gearbox.fi" },
+* });
+* await sdk.attach();
+*
+* const { result, 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.
+**/
+var GearboxSDK = class {
+	/**
+	* Sources this instance reads from.
+	**/
+	mode;
+	/**
+	* Chains this instance covers. Authoritative even when an injected on-chain
+	* SDK covers a different set.
+	**/
+	networks;
+	/**
+	* Namespace for pool and strategy opportunities.
+	**/
+	opportunities;
+	#attachOptions;
+	#onchain;
+	#offchain;
+	/**
+	* Whether this instance built the on-chain SDK, and therefore attaches it.
+	**/
+	#ownsOnchain = false;
+	#attached;
+	constructor(options) {
+		const { mode, networks, onchain, offchain, attach, logger } = options;
+		this.mode = mode;
+		this.networks = [...networks];
+		this.#attachOptions = attach;
+		const needsOnchain = mode === "onchain" || mode === "both";
+		const needsOffchain = mode === "offchain" || mode === "both";
+		if (needsOnchain && !onchain) throw new Error(`GearboxSDK in ${mode} mode needs an onchain source`);
+		if (needsOffchain && !offchain) throw new Error(`GearboxSDK in ${mode} mode needs an offchain source`);
+		if (!needsOnchain && onchain) logger?.warn(`GearboxSDK in ${mode} mode ignores the onchain source it was given`);
+		if (!needsOffchain && offchain) logger?.warn(`GearboxSDK in ${mode} mode ignores the offchain source it was given`);
+		if (needsOnchain && onchain) if (onchain instanceof require_sdk_MultichainSDK.MultichainSDK) this.#onchain = onchain;
+		else {
+			this.#onchain = new require_sdk_MultichainSDK.MultichainSDK({
+				logger,
+				...onchain
+			});
+			this.#ownsOnchain = true;
+		}
+		if (needsOffchain && offchain) this.#offchain = offchain instanceof require_offchain_GearboxAPI.GearboxAPI ? offchain : new require_offchain_GearboxAPI.GearboxAPI({
+			logger,
+			...offchain
+		});
+		this.#attached = !this.#ownsOnchain;
+		this.opportunities = new require_new_sdk_opportunities_OpportunitiesNamespace.OpportunitiesNamespace(this.#onchain, this.#offchain, logger);
+	}
+	/**
+	* 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.
+	**/
+	async attach() {
+		if (this.#attached || !this.#ownsOnchain || !this.#onchain) return;
+		await this.#onchain.attach(this.#attachOptions);
+		this.#attached = true;
+	}
+	/**
+	* Whether the on-chain source is ready to be read from. Always `true` in
+	* `offchain` mode, where there is nothing to wait for.
+	**/
+	get attached() {
+		return this.mode === "offchain" ? true : this.#attached;
+	}
+	/**
+	* 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.
+	**/
+	get onchain() {
+		return this.#onchain;
+	}
+	/**
+	* The underlying backend client. `undefined` in `onchain` mode.
+	**/
+	get offchain() {
+		return this.#offchain;
+	}
+};
+//#endregion
+exports.GearboxSDK = GearboxSDK;

package/dist/cjs/new-sdk/index.js

@@ -0,0 +1,11 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_new_sdk_types = require("./types.js");
+const require_new_sdk_AbstractNamespace = require("./AbstractNamespace.js");
+const require_new_sdk_opportunities_OpportunitiesNamespace = require("./opportunities/OpportunitiesNamespace.js");
+require("./opportunities/index.js");
+const require_new_sdk_GearboxSDK = require("./GearboxSDK.js");
+require("./utils/index.js");
+exports.AbstractNamespace = require_new_sdk_AbstractNamespace.AbstractNamespace;
+exports.AllSourcesFailedError = require_new_sdk_types.AllSourcesFailedError;
+exports.GearboxSDK = require_new_sdk_GearboxSDK.GearboxSDK;
+exports.OpportunitiesNamespace = require_new_sdk_opportunities_OpportunitiesNamespace.OpportunitiesNamespace;