@gearbox-protocol/sdk 16.0.0-next.2 → 16.0.0-next.21

package/dist/cjs/preview/validate/checkOperation.js

@@ -0,0 +1,173 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_validation_checks = require("../../onchain/validation/checks.js");
+const require_onchain_validation_token = require("../../onchain/validation/token.js");
+const require_onchain_accounts_intents_guards = require("../../onchain/accounts/intents/guards.js");
+require("../../onchain/index.js");
+let viem = require("viem");
+//#region src/preview/validate/checkOperation.ts
+/**
+* Whether a parsed operation may be signed at all — the protocol state that
+* `checkPrerequisites` leaves out, since that one covers only what the sender
+* can fix themselves.
+*
+* Synchronous: the preview carries the numbers and the market is attached.
+* Reports the most fundamental issue it finds and stops there, which is the one
+* a caller acts on.
+*/
+function checkOperation(input, options = {}) {
+	const { sdk, preview } = input;
+	const malformed = require_onchain_validation_checks.checkPreviewError("error" in preview ? preview.error : void 0);
+	if (malformed) return malformed;
+	switch (preview.operation) {
+		case "Deposit":
+		case "Mint": return poolIssues(sdk, preview, options, true);
+		case "Withdraw":
+		case "Redeem": return poolIssues(sdk, preview, options, false);
+		case "DelayedCreditAccountOperation": return checkOperation({
+			sdk,
+			preview: preview.instantPreview
+		}, options);
+		case "OpenCreditAccount":
+		case "RWAOpenCreditAccount":
+		case "AdjustCreditAccount": return creditIssues(sdk, preview, options);
+		case "CloseCreditAccount":
+		case "RepayCreditAccount": return marketIssues(sdk, preview.creditManager);
+	}
+}
+function poolIssues(sdk, preview, options, isDeposit) {
+	const market = sdk.marketRegister.findByPool(preview.pool);
+	return require_onchain_validation_checks.checkPoolPaused({
+		isPaused: market.pool.pool.isPaused,
+		pool: preview.pool
+	}) || require_onchain_validation_checks.checkPoolSunset({
+		isSunset: market.sunset,
+		isDeposit,
+		pool: preview.pool
+	}) || (isDeposit ? null : require_onchain_validation_checks.checkPoolPayout({
+		requested: preview.tokenOut.value,
+		available: market.pool.pool.availableLiquidity,
+		underlying: preview.tokenOut.token
+	})) || fundingIssue(options, [preview.tokenIn]);
+}
+/** What the market itself refuses, whatever the operation does. */
+function marketIssues(sdk, creditManager) {
+	const suite = sdk.marketRegister.findCreditManager(creditManager);
+	return require_onchain_validation_checks.checkCreditManagerPaused({
+		isPaused: suite.isPaused,
+		creditManager
+	}) || require_onchain_validation_checks.checkMarketExpired({
+		isExpired: suite.isExpired,
+		creditManager,
+		expirationDate: suite.creditFacade.expirationDate
+	});
+}
+function creditIssues(sdk, preview, options) {
+	const suite = sdk.marketRegister.findCreditManager(preview.creditManager);
+	const market = suite.market;
+	const underlying = require_onchain_validation_token.toToken(sdk, market.pool.underlying);
+	const isOpening = preview.operation === "OpenCreditAccount" || preview.operation === "RWAOpenCreditAccount";
+	return marketIssues(sdk, preview.creditManager) || require_onchain_validation_checks.checkDebtInBand({
+		debt: preview.debt,
+		minDebt: suite.creditFacade.minDebt,
+		maxDebt: suite.creditFacade.maxDebt,
+		underlying,
+		allowZero: !isOpening
+	}) || borrowIssue(suite, preview, underlying) || forbiddenIssue(suite, preview) || require_onchain_validation_checks.checkQuotaCount({
+		count: preview.quotas.filter((q) => q.value > 0n).length,
+		max: suite.creditManager.maxEnabledTokens
+	}) || quotaIssue(market, preview, underlying) || (preview.debt === 0n ? null : collateralIssue(preview, options)) || fundingIssue(options, collateralOf(preview));
+}
+/**
+* What the transaction draws, against what the market can lend right now.
+*
+* Only a draw is weighed: repaying, or leaving the debt alone, can never exceed
+* a ceiling. Opening borrows the whole debt; adjusting borrows `debtChange`.
+*
+* The engine holds every simulation to this already (`assertCanBorrow`), so
+* this is here for the transactions it never saw — a pasted calldata reaches
+* the confirm screen with nothing else standing between it and a revert.
+*/
+function borrowIssue(suite, preview, underlying) {
+	const drawn = preview.operation === "AdjustCreditAccount" ? preview.debtChange : preview.debt;
+	if (drawn <= 0n) return null;
+	const { limit, binding } = require_onchain_accounts_intents_guards.borrowable(suite);
+	return require_onchain_validation_checks.checkBorrowLimit({
+		requested: drawn,
+		available: limit,
+		binding,
+		underlying
+	});
+}
+/** The account against whichever bars the caller holds it to. */
+function collateralIssue(preview, options) {
+	return collateralIssuesOf({
+		healthFactor: preview.healthFactor,
+		safeHealthFactor: preview.safeHealthFactor
+	}, options);
+}
+/** The wallet's side of the operation, against the balances it was given. */
+function fundingIssue(options, puts) {
+	const { balances } = options;
+	if (!balances) return null;
+	for (const { token, value } of puts) {
+		const issue = require_onchain_validation_checks.checkFunding({
+			token,
+			required: value,
+			held: balances.get(token.address) ?? 0n
+		});
+		if (issue) return issue;
+	}
+	return null;
+}
+/** What the wallet puts in, which is what its balances have to cover. */
+function collateralOf(preview) {
+	if ("collateral" in preview) return preview.collateral;
+	if ("collateralAdded" in preview) return preview.collateralAdded;
+	return [];
+}
+function forbiddenIssue(suite, preview) {
+	const obtained = preview.operation === "AdjustCreditAccount" ? preview.assetsChange : preview.assets;
+	const forbidden = suite.forbiddenTokens;
+	for (const asset of obtained) {
+		if (asset.value <= 0n) continue;
+		const issue = require_onchain_validation_checks.checkForbiddenToken({
+			token: asset.token,
+			isForbidden: forbidden.some((f) => (0, viem.isAddressEqual)(f, asset.token.address))
+		});
+		if (issue) return issue;
+	}
+	return null;
+}
+function quotaIssue(market, preview, underlying) {
+	const increases = preview.operation === "AdjustCreditAccount" ? preview.quotasChange : preview.quotas;
+	const { pqk } = market.pool;
+	for (const q of increases) {
+		if (q.value <= 0n) continue;
+		const quota = pqk.hasActiveQuota(q.token.address) ? pqk.quotas.get(q.token.address) : void 0;
+		const issue = require_onchain_validation_checks.checkQuotaLimit({
+			token: q.token,
+			requested: quota ? q.value : void 0,
+			available: (quota?.limit ?? 0n) - (quota?.totalQuoted ?? 0n),
+			underlying
+		});
+		if (issue) return issue;
+	}
+	return null;
+}
+/** The two collateral bars, shared by the preview and the simulation paths. */
+function collateralIssuesOf(factors, options) {
+	const { minHealthFactor, minSafeHealthFactor, currentHealthFactor } = options;
+	return (minHealthFactor === void 0 ? null : require_onchain_validation_checks.checkCollateralised({
+		healthFactor: factors.healthFactor,
+		required: minHealthFactor,
+		safePrices: false,
+		improvesFrom: currentHealthFactor
+	})) || (minSafeHealthFactor === void 0 || factors.safeHealthFactor === void 0 ? null : require_onchain_validation_checks.checkCollateralised({
+		healthFactor: factors.safeHealthFactor,
+		required: minSafeHealthFactor,
+		safePrices: true
+	}));
+}
+//#endregion
+exports.checkOperation = checkOperation;
+exports.collateralIssuesOf = collateralIssuesOf;

package/dist/cjs/preview/validate/checkSimulation.js

@@ -0,0 +1,52 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_validation_checks = require("../../onchain/validation/checks.js");
+const require_onchain_validation_token = require("../../onchain/validation/token.js");
+require("../../onchain/index.js");
+const require_preview_validate_checkOperation = require("./checkOperation.js");
+//#region src/preview/validate/checkSimulation.ts
+/**
+* Whether a simulated operation clears the caller's own bars.
+*
+* The engine holds an account to the facade's `1.0`, because its guards answer
+* "would this revert". A form is wiser to ask for more, and the engine's own
+* note says so — a caller wanting the stricter bar applies it itself. This is
+* that second opinion, over the numbers the engine already reported.
+*
+* Three of the checks below the engine does not make at all: both health-factor
+* bars are its own `1.0`, and the quota count it never weighs. The other two run
+* against the same numbers the engine used, and are here so that a change in the
+* engine cannot pass silently.
+*
+* What is deliberately absent: the forbidden-token, quota-limit and funding
+* checks all need the *delta* an operation applies, and `OperationState` reports
+* only the state after it. Weighing them against absolutes would refuse a
+* forbidden token the account merely holds, or a quota the operation never
+* touched. The engine performed all three during the walk, so a simulation that
+* came back `ok` has already passed them.
+*/
+function checkSimulation(input, options = {}) {
+	const { sdk, state, creditManager } = input;
+	const suite = sdk.marketRegister.findCreditManager(creditManager);
+	return require_onchain_validation_checks.checkCreditManagerPaused({
+		isPaused: suite.isPaused,
+		creditManager
+	}) || require_onchain_validation_checks.checkMarketExpired({
+		isExpired: suite.isExpired,
+		creditManager,
+		expirationDate: suite.creditFacade.expirationDate
+	}) || require_onchain_validation_checks.checkDebtInBand({
+		debt: state.accountDebt,
+		minDebt: suite.creditFacade.minDebt,
+		maxDebt: suite.creditFacade.maxDebt,
+		underlying: require_onchain_validation_token.toToken(sdk, suite.market.pool.underlying),
+		allowZero: true
+	}) || require_onchain_validation_checks.checkQuotaCount({
+		count: Object.values(state.quotas).filter((q) => q.balance > 0n).length,
+		max: suite.creditManager.maxEnabledTokens
+	}) || (state.accountDebt === 0n ? null : require_preview_validate_checkOperation.collateralIssuesOf({
+		healthFactor: state.healthFactor,
+		safeHealthFactor: state.safeHealthFactor
+	}, options));
+}
+//#endregion
+exports.checkSimulation = checkSimulation;

package/dist/cjs/preview/validate/index.js

@@ -0,0 +1,6 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_preview_validate_checkOperation = require("./checkOperation.js");
+const require_preview_validate_checkSimulation = require("./checkSimulation.js");
+exports.checkOperation = require_preview_validate_checkOperation.checkOperation;
+exports.checkSimulation = require_preview_validate_checkSimulation.checkSimulation;
+exports.collateralIssuesOf = require_preview_validate_checkOperation.collateralIssuesOf;

package/dist/cjs/rewards/index.js

@@ -4,5 +4,5 @@ const require_rewards_rewards_api = require("./rewards/api.js");
 const require_rewards_rewards_extra_apy = require("./rewards/extra-apy.js");
 require("./rewards/index.js");
 exports.PoolPointsAPI = require_rewards_rewards_extra_apy.PoolPointsAPI;
-exports.RewardAmountAPI = require_rewards_rewards_api.RewardAmountAPI;
 exports.getKeyForPoolPointsInfo = require_rewards_rewards_extra_apy.getKeyForPoolPointsInfo;
+exports.getMerklRewards = require_rewards_rewards_api.getMerklRewards;

package/dist/cjs/rewards/rewards/api.js

@@ -1,70 +1,80 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sdk_utils_bigint_math = require("../../sdk/utils/bigint-math.js");
-const require_sdk_chain_chains = require("../../sdk/chain/chains.js");
-const require_sdk_utils_formatter = require("../../sdk/utils/formatter.js");
-require("../../sdk/index.js");
+const require_onchain_utils_AddressMap = require("../../onchain/utils/AddressMap.js");
+const require_onchain_utils_bigint_math = require("../../onchain/utils/bigint-math.js");
+const require_onchain_utils_formatter = require("../../onchain/utils/formatter.js");
+require("../../onchain/index.js");
 require("../../common-utils/index.js");
 const require_rewards_rewards_merkl_api = require("./merkl-api.js");
 let viem = require("viem");
 //#region src/rewards/rewards/api.ts
-var RewardAmountAPI = class RewardAmountAPI {
-	constructor() {}
-	static async getLmRewardsMerkle({ pools, account, network, reportError, apiKey }) {
-		const [merkleXYZLMResponse] = await Promise.allSettled([require_rewards_rewards_merkl_api.MerkleXYZApi.fetchWithFallback(require_rewards_rewards_merkl_api.MerkleXYZApi.getUserRewardsUrl({ params: {
-			chainId: require_sdk_chain_chains.chains[network].id,
-			user: (0, viem.getAddress)(account)
-		} }), apiKey)]);
-		const merkleXYZLm = RewardAmountAPI.extractFulfilled(merkleXYZLMResponse, reportError, "merkleXYZLm")?.data;
-		const poolByItsToken = Object.values(pools).reduce((acc, p) => {
-			p.stakedDieselToken.forEach((t) => {
-				if (t) acc[t] = p.address;
-			});
-			p.stakedDieselToken_old.forEach((t) => {
-				if (t) acc[t] = p.address;
-			});
-			acc[p.dieselToken] = p.address;
-			return acc;
-		}, {});
-		const extraRewards = (merkleXYZLm || []).reduce((acc, chainRewards) => {
-			chainRewards.rewards.forEach((reward) => {
-				const rewardToken = reward.token.address.toLowerCase();
-				reward.breakdowns.forEach((reason) => {
-					const poolToken = ((reason.reason || "").split("_").find((part) => part.startsWith("0x")) || "").toLowerCase();
-					const pool = poolByItsToken[poolToken];
-					const total = require_sdk_utils_formatter.toBigInt(reason.amount || 0);
-					const claimed = require_sdk_utils_formatter.toBigInt(reason.claimed || 0);
-					const claimable = require_sdk_utils_bigint_math.BigIntMath.max(total - claimed, 0n);
-					const key = [
-						pool,
-						poolToken,
-						rewardToken
-					].join("_");
-					if (pool && claimable > 0n) {
-						const prevAmount = acc[key]?.amount || 0n;
-						acc[key] = {
-							pool,
-							poolToken,
-							rewardToken,
-							rewardTokenSymbol: reward.token.symbol,
-							rewardTokenDecimals: reward.token.decimals || 18,
-							amount: prevAmount + claimable,
-							type: "extraMerkle"
-						};
-					}
+/**
+* The wallet's claimable Merkl rewards on one chain.
+*
+* Never rejects on a transport failure: the fetch is settled rather than
+* awaited, and a failure goes to `reportError` and yields an empty list. A
+* caller that must tell "this chain is down" from "this chain has no rewards"
+* has to watch that callback.
+*/
+async function getMerklRewards({ sdk, account, reportError, apiKey }) {
+	const [merkleXYZLMResponse] = await Promise.allSettled([require_rewards_rewards_merkl_api.MerkleXYZApi.fetchWithFallback(require_rewards_rewards_merkl_api.MerkleXYZApi.getUserRewardsUrl({ params: {
+		chainId: sdk.chainId,
+		user: (0, viem.getAddress)(account)
+	} }), apiKey)]);
+	const merkleXYZLm = extractFulfilled(merkleXYZLMResponse, reportError, "merkleXYZLm")?.data;
+	const poolByItsToken = require_onchain_utils_AddressMap.AddressMap.fromMappedArray(sdk.marketRegister.pools.map(({ pool }) => pool.address), (address) => address);
+	const claimable = /* @__PURE__ */ new Map();
+	for (const chainRewards of merkleXYZLm || []) for (const reward of chainRewards.rewards) {
+		if (!(0, viem.isAddress)(reward.token.address, { strict: false })) continue;
+		const rewardTokenAddress = (0, viem.getAddress)(reward.token.address);
+		for (const reason of reward.breakdowns) {
+			const poolTokenAddress = (reason.reason || "").split("_").find((part) => part.startsWith("0x")) ?? "";
+			if (!(0, viem.isAddress)(poolTokenAddress, { strict: false })) continue;
+			const pool = poolByItsToken.get(poolTokenAddress);
+			if (!pool) continue;
+			const total = require_onchain_utils_formatter.toBigInt(reason.amount || 0);
+			const claimed = require_onchain_utils_formatter.toBigInt(reason.claimed || 0);
+			const amount = require_onchain_utils_bigint_math.BigIntMath.max(total - claimed, 0n);
+			if (amount === 0n) continue;
+			const key = `${pool}_${rewardTokenAddress}`;
+			const seen = claimable.get(key);
+			if (seen) {
+				claimable.set(key, {
+					...seen,
+					amount: seen.amount + amount
 				});
+				continue;
+			}
+			const poolToken = sdk.tokensMeta.getToken(pool);
+			if (!poolToken) continue;
+			claimable.set(key, {
+				chainId: sdk.chainId,
+				pool,
+				poolToken,
+				rewardToken: toRewardToken(sdk, rewardTokenAddress, reward.token),
+				amount
 			});
-			return acc;
-		}, {});
-		return Object.values(extraRewards);
-	}
-	static extractFulfilled(r, reportError, description) {
-		if (r.status === "fulfilled") return r.value;
-		else {
-			if (reportError) reportError(r.reason, description);
-			else console.error(r.reason);
-			return;
 		}
 	}
-};
+	return [...claimable.values()];
+}
+/**
+* A campaign's incentive token is not protocol collateral, so the registry
+* usually has no entry for it — and Merkl always names it. The one place the
+* two sources are reconciled.
+*/
+function toRewardToken(sdk, address, merkl) {
+	return sdk.tokensMeta.getToken(address) ?? {
+		chainId: sdk.chainId,
+		address,
+		symbol: merkl.symbol,
+		name: merkl.symbol,
+		decimals: merkl.decimals || 18
+	};
+}
+function extractFulfilled(r, reportError, description) {
+	if (r.status === "fulfilled") return r.value;
+	if (reportError) reportError(r.reason, description);
+	else console.error(r.reason);
+}
 //#endregion
-exports.RewardAmountAPI = RewardAmountAPI;
+exports.getMerklRewards = getMerklRewards;

package/dist/cjs/rewards/rewards/extra-apy.js

@@ -1,10 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_runtime = require("../../_virtual/_rolldown/runtime.js");
-const require_sdk_utils_bigint_math = require("../../sdk/utils/bigint-math.js");
-const require_sdk_chain_chains = require("../../sdk/chain/chains.js");
-const require_sdk_constants_math = require("../../sdk/constants/math.js");
-const require_sdk_utils_formatter = require("../../sdk/utils/formatter.js");
-require("../../sdk/index.js");
+const require_onchain_utils_bigint_math = require("../../onchain/utils/bigint-math.js");
+const require_onchain_chain_chains = require("../../onchain/chain/chains.js");
+const require_onchain_constants_math = require("../../onchain/constants/math.js");
+const require_onchain_utils_formatter = require("../../onchain/utils/formatter.js");
+require("../../onchain/index.js");
 require("../../common-utils/index.js");
 let axios = require("axios");
 axios = require_runtime.__toESM(axios);
@@ -29,12 +29,12 @@ var PoolPointsAPI = class PoolPointsAPI {
 		return (await Promise.allSettled(list.map((t) => PoolPointsAPI.getTokenTotal(t, network, tokensList, backendUrl)))).map((r, i) => [list[i], r]);
 	}
 	static async getTokenTotal(token, network, tokensList, backendUrl) {
-		const url = `${backendUrl}/v1/getBalanceAt?asset=${token}&chainId=${require_sdk_chain_chains.chains[network]?.id}`;
+		const url = `${backendUrl}/v1/getBalanceAt?asset=${token}&chainId=${require_onchain_chain_chains.chains[network]?.id}`;
 		const balance = (await axios.default.get(url)).data.result.reduce((sum, r) => r.effective_balance + sum, 0);
 		const { decimals = 18 } = tokensList[token] || {};
 		return {
 			token,
-			balance: require_sdk_utils_formatter.toBN(String(balance), decimals)
+			balance: require_onchain_utils_formatter.toBN(String(balance), decimals)
 		};
 	}
 	static getPointsByPool({ poolRewards, totalTokenBalances, pools, tokensList }) {
@@ -59,12 +59,12 @@ var PoolPointsAPI = class PoolPointsAPI {
 		if (pointsInfo.estimation === "relative" && !tokenBalanceInPool) return null;
 		const { decimals = 18 } = tokensList.get(pointsInfo.token) || {};
 		const targetFactor = 10n ** BigInt(decimals);
-		const defaultPoints = pointsInfo.amount * targetFactor / require_sdk_constants_math.PERCENTAGE_FACTOR;
+		const defaultPoints = pointsInfo.amount * targetFactor / require_onchain_constants_math.PERCENTAGE_FACTOR;
 		if (pointsInfo.estimation === "absolute") return defaultPoints;
 		const { decimals: underlyingDecimals = 18 } = tokensList.get(pool.pool.pool.underlying) || {};
 		const underlyingFactor = 10n ** BigInt(underlyingDecimals);
 		const points = (tokenBalanceInPool?.balance || 0n) * defaultPoints / (pool.pool.pool.expectedLiquidity * targetFactor / underlyingFactor);
-		return require_sdk_utils_bigint_math.BigIntMath.min(points, defaultPoints);
+		return require_onchain_utils_bigint_math.BigIntMath.min(points, defaultPoints);
 	}
 };
 //#endregion

package/dist/cjs/rewards/rewards/index.js

@@ -2,5 +2,5 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_rewards_rewards_api = require("./api.js");
 const require_rewards_rewards_extra_apy = require("./extra-apy.js");
 exports.PoolPointsAPI = require_rewards_rewards_extra_apy.PoolPointsAPI;
-exports.RewardAmountAPI = require_rewards_rewards_api.RewardAmountAPI;
 exports.getKeyForPoolPointsInfo = require_rewards_rewards_extra_apy.getKeyForPoolPointsInfo;
+exports.getMerklRewards = require_rewards_rewards_api.getMerklRewards;

package/dist/cjs/sdk/AbstractNamespace.js

@@ -0,0 +1,106 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_errors_AllSourcesFailedError = require("./errors/AllSourcesFailedError.js");
+const require_sdk_errors_everyChainFailed = require("./errors/everyChainFailed.js");
+const require_sdk_errors_SourceUnavailableError = require("./errors/SourceUnavailableError.js");
+require("./errors/index.js");
+//#region src/sdk/AbstractNamespace.ts
+/**
+* Base class of every {@link GearboxSDK} namespace: holds the two source
+* namespaces, exposes each on its own, and runs merged reads over both.
+*
+* @typeParam Onchain - On-chain source namespace, e.g.
+*   `MultichainOpportunitiesService`.
+* @typeParam Offchain - Backend source namespace, e.g. `OffchainOpportunities`.
+**/
+var AbstractNamespace = class {
+	/**
+	* How far the backend may lag the chain and still serve a chain.
+	**/
+	maxOffchainLagSeconds;
+	logger;
+	/**
+	* The SDK's loading policy, awaited before every on-chain leg: attached, and
+	* the touched chains no older than the SDK allows.
+	**/
+	ensureFresh;
+	#name;
+	#onchain;
+	#offchain;
+	/** {@link onchain}, built once: the source's methods behind the loading policy. */
+	#onchainView;
+	constructor(name, onchain, offchain, options) {
+		this.#name = name;
+		this.#onchain = onchain;
+		this.#offchain = offchain;
+		this.maxOffchainLagSeconds = options.maxOffchainLagSeconds;
+		this.ensureFresh = options.ensureFresh;
+		this.logger = options.logger?.child?.({ name }) ?? options.logger;
+		this.#onchainView = onchain && options.ensureFresh ? behindLoadingPolicy(onchain, options.ensureFresh) : onchain;
+	}
+	/**
+	* The on-chain source namespace on its own — every read of it attaches and
+	* revalidates like a merged read does, so a consumer showing the two sources
+	* separately still gets the SDK's loading policy. Throws
+	* {@link SourceUnavailableError} in `offchain` mode.
+	**/
+	get onchain() {
+		if (!this.#onchainView) throw new require_sdk_errors_SourceUnavailableError.SourceUnavailableError(this.#name, "onchain");
+		return this.#onchainView;
+	}
+	/**
+	* The backend source namespace on its own. Throws
+	* {@link SourceUnavailableError} in `onchain` mode.
+	**/
+	get offchain() {
+		if (!this.#offchain) throw new require_sdk_errors_SourceUnavailableError.SourceUnavailableError(this.#name, "offchain");
+		return this.#offchain;
+	}
+	/**
+	* Asks both sources at once and merges what came back, failing only when no
+	* chain was served at all.
+	**/
+	async merged(action, query) {
+		const onchain = this.#onchain;
+		const offchain = this.#offchain;
+		const [fromChain, fromBackend] = await Promise.all([this.#ask(action, "onchain", onchain, async (source) => {
+			await this.ensureFresh?.(query.chainIds);
+			return query.fromChain(source);
+		}), this.#ask(action, "offchain", offchain, query.fromBackend)]);
+		const merged = query.merge(fromChain.response, fromBackend.response);
+		if (merged && !require_sdk_errors_everyChainFailed.everyChainFailed(merged.meta)) return merged;
+		const sole = onchain && offchain ? void 0 : fromChain.error ?? fromBackend.error;
+		if (sole !== void 0) throw sole;
+		throw new require_sdk_errors_AllSourcesFailedError.AllSourcesFailedError(action, [fromChain.error, fromBackend.error], merged?.meta);
+	}
+	/**
+	* Runs one source's leg of a read, skipping a source this mode does not have
+	* and turning a rejection into an outcome.
+	**/
+	async #ask(action, label, source, run) {
+		if (source === void 0) return {};
+		try {
+			return { response: await run(source) };
+		} catch (error) {
+			this.logger?.warn(error, `failed to ${action} from the ${label} source`);
+			return { error };
+		}
+	}
+};
+/**
+* The source's every method, awaiting the loading policy first. The policy is
+* asked for every chain — an escape hatch does not tell which chains a call
+* touches (the merged reads do, and scope it); the object identity differs
+* from the source's, its type does not.
+**/
+function behindLoadingPolicy(source, ensureFresh) {
+	return new Proxy(source, { get(target, property, receiver) {
+		const value = Reflect.get(target, property, receiver);
+		if (typeof value !== "function") return value;
+		return async (...args) => {
+			await ensureFresh();
+			return Reflect.apply(value, target, args);
+		};
+	} });
+}
+//#endregion
+exports.AbstractNamespace = AbstractNamespace;