@gearbox-protocol/sdk 16.0.0-next.9 → 16.1.0

package/dist/cjs/preview/simulate/simulateOperation.js

@@ -1,8 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_model_result = require("../../model/result.js");
+require("../../model/index.js");
 const require_preview_parse_types = require("../parse/types.js");
 require("../parse/index.js");
-const require_preview_simulate_simulateFacadeOperation = require("./simulateFacadeOperation.js");
 const require_preview_simulate_simulatePoolOperation = require("./simulatePoolOperation.js");
+const require_preview_simulate_simulateFacadeOperation = require("./simulateFacadeOperation.js");
 const require_preview_simulate_simulateRWAOperation = require("./simulateRWAOperation.js");
 //#region src/preview/simulate/simulateOperation.ts
 /**
@@ -14,14 +16,14 @@ async function simulateOperation(input, options) {
 		...input,
 		operation
 	}, options);
-	if (require_preview_parse_types.isRWAOperation(operation)) return require_preview_simulate_simulateRWAOperation.simulateRWAOperation({
+	if (require_preview_parse_types.isRWAOperation(operation)) return require_model_result.sdkOk(await require_preview_simulate_simulateRWAOperation.simulateRWAOperation({
 		...input,
 		operation
-	}, options);
-	return require_preview_simulate_simulateFacadeOperation.simulateFacadeOperation({
+	}, options));
+	return require_model_result.sdkOk(await require_preview_simulate_simulateFacadeOperation.simulateFacadeOperation({
 		...input,
 		operation
-	}, options);
+	}, options));
 }
 //#endregion
 exports.simulateOperation = simulateOperation;

package/dist/cjs/preview/simulate/simulatePoolOperation.js

@@ -1,6 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_abi_iZapper = require("../../abi/iZapper.js");
 const require_abi_310_generated = require("../../abi/310/generated.js");
+const require_model_result = require("../../model/result.js");
+require("../../model/index.js");
 const require_preview_simulate_errors = require("./errors.js");
 //#region src/preview/simulate/simulatePoolOperation.ts
 function previewRead(operation) {
@@ -90,15 +92,18 @@ async function simulatePoolOperation(input, options = {}) {
 	const { sdk, operation } = input;
 	const { blockNumber, logger } = options;
 	try {
-		return amountsInOut(operation, await sdk.client.readContract({
+		const previewAmount = await sdk.client.readContract({
 			blockNumber,
 			...previewContract(operation)
-		}));
+		});
+		return require_model_result.sdkOk(amountsInOut(operation, previewAmount));
 	} catch (cause) {
 		const error = require_preview_simulate_errors.asPreviewSimulationError(cause, "multicall");
 		logger?.error(error, "pool operation simulation failed");
-		throw error;
+		return require_model_result.sdkErr(error);
 	}
 }
 //#endregion
+exports.amountsInOut = amountsInOut;
+exports.previewContract = previewContract;
 exports.simulatePoolOperation = simulatePoolOperation;

package/dist/cjs/preview/trace/extractAdapterCallTraces.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_common_utils_utils_trace = require("../../common-utils/utils/trace.js");
+const require_onchain_utils_trace = require("../../onchain/utils/trace.js");
 let viem = require("viem");
 //#region src/preview/trace/extractAdapterCallTraces.ts
 /**
@@ -67,7 +67,7 @@ function isSynthesizedPhantomWithdrawal(siblings, index) {
 */
 function extractAdapterCallTraces(facadeTrace) {
 	const subtraces = facadeTrace.calls ?? [];
-	return subtraces.filter((sub, index) => require_common_utils_utils_trace.resolveProtocolCall(sub) !== void 0 && !isSynthesizedPhantomWithdrawal(subtraces, index));
+	return subtraces.filter((sub, index) => require_onchain_utils_trace.resolveProtocolCall(sub) !== void 0 && !isSynthesizedPhantomWithdrawal(subtraces, index));
 }
 //#endregion
 exports.extractAdapterCallTraces = extractAdapterCallTraces;

package/dist/cjs/preview/trace/findFacadeCalls.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_abi_310_generated = require("../../abi/310/generated.js");
-const require_common_utils_utils_trace = require("../../common-utils/utils/trace.js");
+const require_onchain_utils_trace = require("../../onchain/utils/trace.js");
 const require_preview_trace_errors = require("./errors.js");
 let viem = require("viem");
 //#region src/preview/trace/findFacadeCalls.ts
@@ -33,7 +33,7 @@ function extractCreditAccount(operation, rawArgs, traceOutput) {
 * structured {@link FacadeParsedCall} entries for the given credit account.
 */
 function findFacadeCalls(trace, creditFacade, creditAccount, register, strict) {
-	const facadeTraces = require_common_utils_utils_trace.collectTraces(trace, creditFacade);
+	const facadeTraces = require_onchain_utils_trace.collectTraces(trace, creditFacade);
 	const results = [];
 	for (const trace of facadeTraces) {
 		const parsed = register.parseFunctionDataV2(creditFacade, trace.input, strict);

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

@@ -0,0 +1,187 @@
+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("warning" in preview ? preview.warning : 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.marketRegister.findCreditManager(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(suite) {
+	const creditManager = suite.creditManager.address;
+	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(suite) || require_onchain_validation_checks.checkDebtInBand({
+		debt: preview.totalDebt.value,
+		minDebt: suite.creditFacade.minDebt,
+		maxDebt: suite.creditFacade.maxDebt,
+		underlying,
+		allowZero: !isOpening
+	}) || borrowIssue(suite, preview, underlying) || forbiddenIssue(suite, preview) || quotaCountIssue(suite, preview) || quotaIssue(market, preview, underlying) || collateralIssue({
+		totalDebt: preview.totalDebt,
+		healthFactor: preview.estHealthFactor,
+		safeHealthFactor: preview.estSafeHealthFactor
+	}, options) || fundingIssue(options, preview.collateralAdded);
+}
+/**
+* A bar that reads nothing but the projected account, so a parsed transaction
+* and a simulated one are held to it by the same code.
+*
+* These stay separate functions rather than one block because the order the
+* checks run in is the answer: `checkOperation` interleaves the checks that
+* need an operation's *delta* between them, and the caller acts on the first
+* issue reported.
+*/
+function quotaCountIssue(suite, account) {
+	return require_onchain_validation_checks.checkQuotaCount({
+		count: account.quotas.filter((q) => q.value > 0n).length,
+		max: suite.creditManager.maxEnabledTokens
+	});
+}
+/**
+* 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
+* `totalDebtChange`.
+*
+* 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.totalDebtChange.value : preview.totalDebt.value;
+	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.
+*
+* A loan-free account is nothing to weigh: the health factor reports its
+* zero-debt sentinel and no bar applies.
+*
+* {@inheritDoc quotaCountIssue}
+*/
+function collateralIssue(account, options) {
+	const { minHealthFactor, minSafeHealthFactor, currentHealthFactor } = options;
+	if (account.totalDebt.value === 0n) return null;
+	return (minHealthFactor === void 0 ? null : require_onchain_validation_checks.checkCollateralised({
+		healthFactor: account.healthFactor,
+		required: minHealthFactor,
+		safePrices: false,
+		improvesFrom: currentHealthFactor
+	})) || (minSafeHealthFactor === void 0 ? null : require_onchain_validation_checks.checkCollateralised({
+		healthFactor: account.safeHealthFactor,
+		required: minSafeHealthFactor,
+		safePrices: true
+	}));
+}
+/** 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;
+}
+function forbiddenIssue(suite, preview) {
+	const obtained = preview.operation === "AdjustCreditAccount" ? preview.assetsChange : preview.estAssets;
+	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;
+}
+//#endregion
+exports.checkOperation = checkOperation;
+exports.collateralIssue = collateralIssue;
+exports.marketIssues = marketIssues;
+exports.quotaCountIssue = quotaCountIssue;

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

@@ -0,0 +1,39 @@
+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 } = input;
+	const suite = sdk.marketRegister.findCreditManager(state.creditManager);
+	return require_preview_validate_checkOperation.marketIssues(suite) || require_onchain_validation_checks.checkDebtInBand({
+		debt: state.totalDebt.value,
+		minDebt: suite.creditFacade.minDebt,
+		maxDebt: suite.creditFacade.maxDebt,
+		underlying: require_onchain_validation_token.toToken(sdk, suite.market.pool.underlying),
+		allowZero: true
+	}) || require_preview_validate_checkOperation.quotaCountIssue(suite, state) || require_preview_validate_checkOperation.collateralIssue(state, options);
+}
+//#endregion
+exports.checkSimulation = checkSimulation;

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

@@ -0,0 +1,8 @@
+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.collateralIssue = require_preview_validate_checkOperation.collateralIssue;
+exports.marketIssues = require_preview_validate_checkOperation.marketIssues;
+exports.quotaCountIssue = require_preview_validate_checkOperation.quotaCountIssue;

package/dist/cjs/rewards/errors.js

@@ -0,0 +1,27 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let viem = require("viem");
+//#region src/rewards/errors.ts
+/**
+* Thrown when none of Merkl's domains answered for a chain.
+*
+* Everything a reader needs is in the message: this error travels to consumers
+* inside a chain's {@link ChainFailed} metadata, where it is typed `unknown`
+* and may be serialised by something that turns an arbitrary object into `{}`.
+*/
+var MerklRequestFailedError = class extends viem.BaseError {
+	name = "MerklRequestFailedError";
+	chainId;
+	constructor(chainId, path, attempts) {
+		super(`Merkl could not be reached for chain ${chainId}.`, {
+			cause: attempts.find(([, c]) => c instanceof Error)?.[1],
+			metaMessages: attempts.map(([domain, cause]) => `${domain}${path} — ${describe(cause)}`)
+		});
+		this.chainId = chainId;
+	}
+};
+function describe(cause) {
+	if (cause instanceof Error) return cause.name === "TimeoutError" ? "timed out" : cause.message;
+	return String(cause);
+}
+//#endregion
+exports.MerklRequestFailedError = MerklRequestFailedError;

package/dist/cjs/rewards/index.js

@@ -1,8 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("./apy/index.js");
-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;
+const require_rewards_errors = require("./errors.js");
+const require_rewards_toMerklRewards = require("./toMerklRewards.js");
+const require_rewards_multichain = require("./multichain.js");
+exports.MerklRequestFailedError = require_rewards_errors.MerklRequestFailedError;
+exports.getMerklRewardsMultichain = require_rewards_multichain.getMerklRewardsMultichain;
+exports.toMerklRewards = require_rewards_toMerklRewards.toMerklRewards;

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

@@ -0,0 +1,45 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_rewards_errors = require("./errors.js");
+//#region src/rewards/merkl-api.ts
+/**
+* Merkl's own host and the Angle mirror, tried in this order.
+*/
+const MERKL_DOMAINS = ["https://api.merkl.xyz", "https://api-merkl.angle.money"];
+const MERKL_API_KEY_HEADER = "X-API-Key";
+/**
+* Per-attempt budget. Merkl has no timeout of its own, and a hung connection
+* would otherwise stall its leg of a fan-out for as long as the socket lives.
+*/
+const ATTEMPT_TIMEOUT = 1e4;
+/**
+* The wallet's raw Merkl rewards on one chain.
+*
+* Rejects with {@link MerklRequestFailedError} when neither domain answers, so
+* a caller can tell an unreachable Merkl from a wallet with nothing to claim.
+* A non-2xx counts as no answer and moves to the next domain: it carries no
+* rewards either way, and treating it as success would report emptiness that
+* was never established.
+*/
+async function fetchMerklUserRewards({ chainId, user, apiKey }) {
+	const path = `/v4/users/${user}/rewards?chainId=${chainId}`;
+	const headers = apiKey ? { [MERKL_API_KEY_HEADER]: apiKey } : void 0;
+	const attempts = [];
+	for (const domain of MERKL_DOMAINS) try {
+		const response = await fetch(`${domain}${path}`, {
+			headers,
+			signal: AbortSignal.timeout(ATTEMPT_TIMEOUT)
+		});
+		if (!response.ok) {
+			attempts.push([domain, /* @__PURE__ */ new Error(`answered ${response.status}`)]);
+			continue;
+		}
+		return await response.json();
+	} catch (error) {
+		attempts.push([domain, error]);
+	}
+	throw new require_rewards_errors.MerklRequestFailedError(chainId, path, attempts);
+}
+//#endregion
+exports.MERKL_API_KEY_HEADER = MERKL_API_KEY_HEADER;
+exports.MERKL_DOMAINS = MERKL_DOMAINS;
+exports.fetchMerklUserRewards = fetchMerklUserRewards;

package/dist/cjs/rewards/multichain.js

@@ -0,0 +1,40 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_base_MultichainConstruct = require("../onchain/base/MultichainConstruct.js");
+require("../onchain/index.js");
+const require_rewards_merkl_api = require("./merkl-api.js");
+const require_rewards_toMerklRewards = require("./toMerklRewards.js");
+let viem = require("viem");
+//#region src/rewards/multichain.ts
+/**
+* The fan-out itself. Private because rewards are not an SDK namespace yet:
+* the read is a free function, and this is only how it reaches `queryChains`.
+**/
+var MerklRewardsFanOut = class extends require_onchain_base_MultichainConstruct.MultichainConstruct {
+	async list(wallet, chainIds, apiKey) {
+		const user = (0, viem.getAddress)(wallet);
+		return this.queryChains({
+			chainIds,
+			label: "list rewards",
+			block: "state",
+			run: async (sdk) => require_rewards_toMerklRewards.toMerklRewards(sdk, await require_rewards_merkl_api.fetchMerklUserRewards({
+				chainId: sdk.chainId,
+				user,
+				apiKey
+			}))
+		});
+	}
+};
+/**
+* Every claimable Merkl reward a wallet holds, across the chains the handle
+* carries.
+*
+* Answers the read model's own envelope, so a chain that could not be reached
+* is `status: "error"` in `meta.chains` while a chain with nothing to claim is
+* a `"success"` that contributed no rows. That distinction is the point: the
+* single-chain read this replaces resolved empty either way.
+**/
+async function getMerklRewardsMultichain({ sdk, wallet, chainIds, apiKey }) {
+	return new MerklRewardsFanOut(sdk).list(wallet, chainIds, apiKey);
+}
+//#endregion
+exports.getMerklRewardsMultichain = getMerklRewardsMultichain;

package/dist/cjs/rewards/toMerklRewards.js

@@ -0,0 +1,85 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+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");
+let viem = require("viem");
+//#region src/rewards/toMerklRewards.ts
+/**
+* Merkl's answer for one chain, turned into rows of the read model.
+*/
+function toMerklRewards(sdk, response) {
+	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 response) 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 amounts = toAmounts(reason);
+			if (!amounts) continue;
+			const amount = require_onchain_utils_bigint_math.BigIntMath.max(amounts.total - amounts.claimed, 0n);
+			if (amount === 0n) continue;
+			const key = `${pool}_${rewardTokenAddress}`;
+			const seen = claimable.get(key);
+			if (seen) {
+				seen.value += amount;
+				continue;
+			}
+			const poolToken = sdk.tokensMeta.getToken(pool);
+			if (!poolToken) continue;
+			claimable.set(key, {
+				chainId: sdk.chainId,
+				pool,
+				poolToken,
+				token: toRewardToken(sdk, rewardTokenAddress, reward.token),
+				value: amount,
+				price: reward.token.price
+			});
+		}
+	}
+	return [...claimable.values()].map(toReward);
+}
+/**
+* `toBigInt` throws on anything `BigInt()` cannot parse, and Merkl's amounts
+* are free-form strings.
+*/
+function toAmounts(reason) {
+	try {
+		return {
+			total: require_onchain_utils_formatter.toBigInt(reason.amount || 0),
+			claimed: require_onchain_utils_formatter.toBigInt(reason.claimed || 0)
+		};
+	} catch {
+		return;
+	}
+}
+function toReward({ price, token, value, ...rest }) {
+	return {
+		...rest,
+		amount: {
+			token,
+			value,
+			valueUsd: price === void 0 ? null : Number((0, viem.formatUnits)(value, token.decimals)) * price
+		}
+	};
+}
+/**
+* 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
+	};
+}
+//#endregion
+exports.toMerklRewards = toMerklRewards;

package/dist/cjs/sdk/GearboxSDK.js

@@ -7,6 +7,8 @@ require("../offchain/index.js");
 const require_sdk_errors_assertSameChains = require("./errors/assertSameChains.js");
 const require_sdk_errors_MissingSourceError = require("./errors/MissingSourceError.js");
 require("./errors/index.js");
+const require_sdk_analytics_AnalyticsNamespace = require("./analytics/AnalyticsNamespace.js");
+require("./analytics/index.js");
 const require_sdk_liquidations_LiquidationsNamespace = require("./liquidations/LiquidationsNamespace.js");
 require("./liquidations/index.js");
 require("./utils/mergeChains.js");
@@ -51,6 +53,8 @@ var GearboxSDK = class {
 	* Chains this instance covers, which every read is scoped to.
 	**/
 	networks;
+	/** Protocol-wide analytics. Undefined in `onchain` mode. */
+	analytics;
 	/**
 	* Namespace for pool and strategy opportunities.
 	**/
@@ -131,6 +135,7 @@ var GearboxSDK = class {
 			ensureFresh: this.#onchain ? (chainIds) => this.#ensureFresh(chainIds) : void 0,
 			logger
 		};
+		this.analytics = this.#offchain ? new require_sdk_analytics_AnalyticsNamespace.AnalyticsNamespace(this.#offchain) : void 0;
 		this.opportunities = new require_sdk_opportunities_OpportunitiesNamespace.OpportunitiesNamespace(this.#onchain, this.#offchain, namespaceOptions);
 		this.positions = new require_sdk_positions_PositionsNamespace.PositionsNamespace(this.#onchain, this.#offchain, namespaceOptions);
 		this.liquidations = this.#onchain ? new require_sdk_liquidations_LiquidationsNamespace.LiquidationsNamespace(this.#onchain, namespaceOptions) : void 0;

package/dist/cjs/sdk/analytics/AnalyticsNamespace.js

@@ -0,0 +1,17 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/sdk/analytics/AnalyticsNamespace.ts
+/** Backend-only protocol analytics exposed by {@link GearboxSDK}. */
+var AnalyticsNamespace = class {
+	positions;
+	#backend;
+	constructor(backend) {
+		this.#backend = backend;
+		this.positions = backend.analytics.positions;
+	}
+	/** {@inheritDoc IAnalytics.charts} */
+	async charts(metrics, range, filter) {
+		return this.#backend.analytics.getCharts(metrics, range, filter);
+	}
+};
+//#endregion
+exports.AnalyticsNamespace = AnalyticsNamespace;

package/dist/cjs/sdk/analytics/index.js

@@ -0,0 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_analytics_AnalyticsNamespace = require("./AnalyticsNamespace.js");
+require("./types.js");
+exports.AnalyticsNamespace = require_sdk_analytics_AnalyticsNamespace.AnalyticsNamespace;