@gearbox-protocol/sdk 15.1.0-next.1 → 15.1.0-next.11

package/dist/cjs/abi/iExpirable.js

@@ -0,0 +1,15 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/abi/iExpirable.ts
+const iExpirableAbi = [{
+	type: "function",
+	inputs: [],
+	name: "isExpired",
+	outputs: [{
+		name: "",
+		internalType: "bool",
+		type: "bool"
+	}],
+	stateMutability: "view"
+}];
+//#endregion
+exports.iExpirableAbi = iExpirableAbi;

package/dist/cjs/common-utils/utils/apy/get-single-quota-borrow-rate.js

@@ -5,6 +5,8 @@ const require_common_utils_utils_creditAccount_calc_quota_borrow_rate = require(
 /**
 * Under the hood sums up rates for all given quotas and then multiplies them by 1+feeInterest,
 * but it is expected that the ONLY quota will be passed
+*
+* @deprecated Use `calcBorrowRate` from `sdk/positions` instead.
 */
 function getSingleQuotaBorrowRate(props) {
 	const qr = require_common_utils_utils_creditAccount_calc_quota_borrow_rate.calcQuotaBorrowRate(props);

package/dist/cjs/common-utils/utils/creditAccount/calc-health-factor.js

@@ -1,10 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sdk_utils_bigint_math = require("../../../sdk/utils/bigint-math.js");
-const require_sdk_constants_math = require("../../../sdk/constants/math.js");
-require("../../../sdk/index.js");
-const require_common_utils_utils_price_math = require("../price-math.js");
+const require_sdk_positions_calcHealthFactor = require("../../../sdk/positions/calcHealthFactor.js");
 //#region src/common-utils/utils/creditAccount/calc-health-factor.ts
-const MAX_UINT16 = 65535;
 /**
 * Computes account health factor in percentage-factor units.
 *
@@ -15,25 +11,31 @@ const MAX_UINT16 = 65535;
 * @param props Credit account balances, quotas, prices, thresholds, and debt context.
 * @returns Health factor as a number in `PERCENTAGE_FACTOR` scale,
 * or `65535` when debt is zero.
+*
+* @deprecated Use `calcHealthFactor` from `sdk/positions` instead; this
+* wrapper only maps the legacy props onto an `AccountSnapshot`.
 */
 function calcHealthFactor({ assets, quotas, quotasInfo, liquidationThresholds, underlyingToken, debt, prices, tokensList }) {
-	if (debt === 0n) return MAX_UINT16;
-	const underlyingDecimals = tokensList[underlyingToken]?.decimals || 18;
-	const underlyingPrice = prices[underlyingToken] || 0n;
-	const assetMoney = assets.reduce((acc, { token: tokenAddress, balance: amount }) => {
-		const tokenDecimals = tokensList[tokenAddress]?.decimals || 18;
-		const lt = liquidationThresholds[tokenAddress] || 0n;
-		const price = prices[tokenAddress] || 0n;
-		const tokenLtMoney = require_common_utils_utils_price_math.PriceUtils.calcTotalPrice(price, amount, tokenDecimals) * lt / require_sdk_constants_math.PERCENTAGE_FACTOR;
-		const { isActive = false } = quotasInfo?.[tokenAddress] || {};
-		const quota = quotas[tokenAddress];
-		const quotaBalance = isActive ? quota?.balance || 0n : 0n;
-		const quotaMoney = require_common_utils_utils_price_math.PriceUtils.calcTotalPrice(underlyingPrice, quotaBalance, underlyingDecimals);
-		return acc + (quota ? require_sdk_utils_bigint_math.BigIntMath.min(quotaMoney, tokenLtMoney) : tokenLtMoney);
-	}, 0n);
-	const borrowedMoney = require_common_utils_utils_price_math.PriceUtils.calcTotalPrice(underlyingPrice || require_sdk_constants_math.PRICE_DECIMALS, debt, underlyingDecimals);
-	const hfInPercent = borrowedMoney > 0n ? assetMoney * require_sdk_constants_math.PERCENTAGE_FACTOR / borrowedMoney : 0n;
-	return Number(hfInPercent);
+	const decimals = {};
+	for (const [token, meta] of Object.entries(tokensList)) decimals[token] = meta.decimals;
+	const lts = {};
+	for (const [token, lt] of Object.entries(liquidationThresholds)) lts[token] = Number(lt);
+	const activeQuotas = {};
+	for (const [token, info] of Object.entries(quotasInfo)) if (info?.isActive) activeQuotas[token] = true;
+	return require_sdk_positions_calcHealthFactor.calcHealthFactor({
+		snapshot: {
+			creditManager: underlyingToken,
+			assets,
+			quotas: Object.values(quotas),
+			totalDebt: debt,
+			totalValue: 0n
+		},
+		underlying: underlyingToken,
+		decimals,
+		prices,
+		liquidationThresholds: lts,
+		activeQuotas
+	});
 }
 //#endregion
 exports.calcHealthFactor = calcHealthFactor;

package/dist/cjs/common-utils/utils/creditAccount/calc-quota-borrow-rate.js

@@ -9,6 +9,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 *
 * @param props Quota balances and per-token quota rates.
 * @returns Sum of `balance * rate` terms in percentage-factor scale.
+*
+* @deprecated Use `calcBorrowRate` from `sdk/positions` instead.
 */
 function calcQuotaBorrowRate({ quotas, quotaRates }) {
 	return Object.values(quotas).reduce((acc, { token, balance }) => {

package/dist/cjs/common-utils/utils/creditAccount/get-time-to-liquidation.js

@@ -1,6 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sdk_constants_math = require("../../../sdk/constants/math.js");
-require("../../../sdk/index.js");
+const require_sdk_positions_calcTimeToLiquidationMs = require("../../../sdk/positions/calcTimeToLiquidationMs.js");
 //#region src/common-utils/utils/creditAccount/get-time-to-liquidation.ts
 /**
 * Estimates time remaining until health factor reaches liquidation level.
@@ -9,13 +8,17 @@ require("../../../sdk/index.js");
 * and returns a millisecond duration until `healthFactor` decays to `1.0`
 * (`PERCENTAGE_FACTOR` in internal scale).
 *
-* @param props Current health factor and `totalBorrowRate * debt` term.
+* @param props Current health factor and `totalBorrowRate_debt`, both `Bps`
+* (`10000` = 100%) — not the legacy `PERCENTAGE_FACTOR_1KK` (`1_000_000` =
+* 100%) scale the pre-rewrite frontend fed this under the same name.
 * @returns Milliseconds to liquidation as `bigint`, or `null` when already at/under
 * liquidation threshold or when borrow-rate exposure is zero.
+*
+* @deprecated Use `calcTimeToLiquidationMs` from `sdk/positions` instead;
+* this wrapper only forwards to the new implementation.
 */
 function getTimeToLiquidation({ healthFactor, totalBorrowRate_debt }) {
-	if (healthFactor <= 10000n || totalBorrowRate_debt === 0n) return null;
-	return (BigInt(healthFactor) - require_sdk_constants_math.PERCENTAGE_FACTOR) * (BigInt(require_sdk_constants_math.SECONDS_PER_YEAR) * require_sdk_constants_math.PERCENTAGE_FACTOR * require_sdk_constants_math.PERCENTAGE_DECIMALS / totalBorrowRate_debt) * 1000n / require_sdk_constants_math.PERCENTAGE_FACTOR;
+	return require_sdk_positions_calcTimeToLiquidationMs.calcTimeToLiquidationMs(healthFactor, totalBorrowRate_debt);
 }
 //#endregion
 exports.getTimeToLiquidation = getTimeToLiquidation;

package/dist/cjs/common-utils/utils/creditAccount/liquidation-price.js

@@ -1,6 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sdk_constants_math = require("../../../sdk/constants/math.js");
-require("../../../sdk/index.js");
+const require_sdk_positions_calcLiquidationPriceForTarget = require("../../../sdk/positions/calcLiquidationPriceForTarget.js");
 //#region src/common-utils/utils/creditAccount/liquidation-price.ts
 /**
 * Calculates target token liquidation price for a credit account.
@@ -13,17 +12,28 @@ require("../../../sdk/index.js");
 * @param props Debt context, assets, thresholds, and token metadata.
 * @returns Target token price in `PRICE_DECIMALS` precision that corresponds
 * to liquidation boundary; returns `0n` when target balance or LT is non-positive.
+*
+* @deprecated Use `calcLiquidationPriceForTarget` from `sdk/positions`
+* instead; this wrapper only maps the legacy props onto an `AccountSnapshot`.
 */
 function liquidationPrice({ liquidationThresholds, debt, underlyingToken, targetToken, assets, tokensList }) {
-	const underlyingDecimals = tokensList[underlyingToken]?.decimals || 18;
-	const { balance: underlyingBalance = 0n } = assets[underlyingToken] || {};
-	const effectiveDebt = (debt - underlyingBalance * (liquidationThresholds[underlyingToken] || 0n) / require_sdk_constants_math.PERCENTAGE_FACTOR) * require_sdk_constants_math.WAD / 10n ** BigInt(underlyingDecimals);
-	const targetDecimals = tokensList[targetToken]?.decimals || 18;
-	const { balance: targetBalance = 0n } = assets[targetToken] || {};
-	const effectiveTargetBalance = targetBalance * require_sdk_constants_math.WAD / 10n ** BigInt(targetDecimals);
-	const lpLT = liquidationThresholds[targetToken] || 0n;
-	if (targetBalance <= 0n || lpLT <= 0n) return 0n;
-	return effectiveDebt * require_sdk_constants_math.PRICE_DECIMALS * require_sdk_constants_math.PERCENTAGE_FACTOR / (effectiveTargetBalance * lpLT);
+	const decimals = {};
+	for (const [token, meta] of Object.entries(tokensList)) decimals[token] = meta.decimals;
+	const lts = {};
+	for (const [token, lt] of Object.entries(liquidationThresholds)) lts[token] = Number(lt);
+	return require_sdk_positions_calcLiquidationPriceForTarget.calcLiquidationPriceForTarget({
+		snapshot: {
+			creditManager: underlyingToken,
+			assets: Object.values(assets),
+			quotas: [],
+			totalDebt: debt,
+			totalValue: 0n
+		},
+		targetToken,
+		underlying: underlyingToken,
+		decimals,
+		liquidationThresholds: lts
+	});
 }
 //#endregion
 exports.liquidationPrice = liquidationPrice;

package/dist/cjs/dev/AccountOpener.js

@@ -87,7 +87,6 @@ var AccountOpener = class extends require_sdk_base_SDKConstruct.SDKConstruct {
 			depositIntoPools,
 			claimFromFaucet
 		}, "opening credit accounts");
-		await Promise.all([this.sdk.tokensMeta.loadTokenData(), this.sdk.marketRegister.loadZappers()]);
 		let deposits = [];
 		if (depositIntoPools) try {
 			deposits = await this.#depositIntoPools(targets);

package/dist/cjs/dev/compareOpportunities.js

@@ -0,0 +1,137 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_model_opportunities = require("../model/opportunities.js");
+require("../model/index.js");
+const require_dev_fieldDiff = require("./fieldDiff.js");
+//#region src/dev/compareOpportunities.ts
+/**
+* Matches two opportunity listings by {@link opportunityId} and reports every
+* field the two sources disagree on.
+*
+* Nothing is filtered out. A field only the backend can fill, or a USD value
+* that drifted within snapshot-lag noise, is still reported — tagged
+* {@link FieldDiff.expected} so that {@link CompareCounts.clean} can ignore it
+* while {@link CompareCounts.identical} stays strict.
+**/
+function compareOpportunities(input) {
+	const onchainRows = indexById(input.onchain.data);
+	const offchainRows = indexById(input.offchain.data);
+	const onlyOnchain = [];
+	const onlyOffchain = [];
+	const matched = [];
+	for (const [id, row] of onchainRows) {
+		const counterpart = offchainRows.get(id);
+		if (!counterpart) {
+			onlyOnchain.push(toRef(row));
+			continue;
+		}
+		const diffs = diffOpportunity(row, counterpart);
+		matched.push({
+			id,
+			kind: row.kind,
+			chainId: row.chainId,
+			onchainName: row.name,
+			offchainName: counterpart.name,
+			identical: diffs.length === 0,
+			clean: diffs.every((diff) => diff.expected),
+			diffs
+		});
+	}
+	for (const [id, row] of offchainRows) if (!onchainRows.has(id)) onlyOffchain.push(toRef(row));
+	byId(onlyOnchain);
+	byId(onlyOffchain);
+	matched.sort((a, b) => a.id.localeCompare(b.id));
+	return {
+		generatedAt: input.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+		backendUrl: input.backendUrl,
+		networks: [...input.networks],
+		onchainChains: input.onchain.meta.chains,
+		offchainChains: input.offchain.meta.chains,
+		summary: summarize(input.onchain.data, input.offchain.data, onlyOnchain, onlyOffchain, matched),
+		onlyOnchain,
+		onlyOffchain,
+		matched
+	};
+}
+function indexById(rows) {
+	return new Map(rows.map((row) => [require_model_opportunities.opportunityId(row), row]));
+}
+function byId(refs) {
+	refs.sort((a, b) => a.id.localeCompare(b.id));
+}
+function toRef(row) {
+	const base = {
+		id: require_model_opportunities.opportunityId(row),
+		kind: row.kind,
+		chainId: row.chainId,
+		name: row.name
+	};
+	return row.kind === "pool" ? {
+		...base,
+		pool: row.pool
+	} : {
+		...base,
+		creditManager: row.creditManager,
+		targetCollateral: row.targetCollateral.address
+	};
+}
+/**
+* Every field two versions of one opportunity disagree on.
+**/
+function diffOpportunity(onchain, offchain) {
+	return require_dev_fieldDiff.diffObjects(onchain, offchain).map((diff) => tagDiff(diff, onchain.kind));
+}
+/**
+* Paths whose values are basis-point rates that routinely differ by ±1 from
+* truncation vs rounding, plus pool `utilization` for the same reason.
+**/
+const BPS_RATE_PATHS = /* @__PURE__ */ new Set([
+	"borrowApy",
+	"supplyApy.organicApy",
+	"additionalBorrowApy",
+	"utilization"
+]);
+/**
+* Amount fields whose bigint `value` moves with expected-liquidity accrual
+* between the backend's last sync and the current block. Strategy
+* `totalBorrow.value` and `maxBorrowAmount.value` are not in this set: those
+* disagreements are formula bugs, not lag.
+**/
+const LAG_AMOUNT_PATHS = /* @__PURE__ */ new Set(["totalSupply.value", "availableLiquidity.value"]);
+/**
+* Fields documented `@mode offchain` in the model: the chain has nothing to
+* put there, so a presence (or nested) mismatch is expected. Strategy
+* `utilization` is in this set; pool `utilization` is not.
+**/
+function isModeScoped(path, kind) {
+	if (path === "curator.url") return true;
+	if (path === "totalApy" || path.endsWith(".totalApy")) return true;
+	if (path === "rewards" || path.startsWith("rewards[") || path.includes(".rewards[") || path.endsWith(".rewards")) return true;
+	if (kind !== "strategy") return false;
+	return path === "utilization" || path === "collateralApy" || path.startsWith("collateralApy.") || path === "maxLeverageApy" || path.startsWith("maxLeverageApy.") || path === "totalValue" || path.startsWith("totalValue.");
+}
+function tagDiff(diff, kind) {
+	if (isModeScoped(diff.path, kind)) return require_dev_fieldDiff.withExpected(diff, "mode-scoped");
+	if (withinTolerance(diff)) return require_dev_fieldDiff.withExpected(diff, "tolerance");
+	return diff;
+}
+function withinTolerance(diff) {
+	if (diff.kind === "usd") return require_dev_fieldDiff.isUsdWithinTolerance(diff.onchain, diff.offchain);
+	if (diff.kind !== "numeric") return false;
+	if (BPS_RATE_PATHS.has(diff.path)) return require_dev_fieldDiff.isBpsWithinTolerance(diff.onchain, diff.offchain);
+	if (LAG_AMOUNT_PATHS.has(diff.path)) return require_dev_fieldDiff.isAmountWithinTolerance(diff.onchain, diff.offchain);
+	return false;
+}
+function summarize(onchain, offchain, onlyOnchain, onlyOffchain, matched) {
+	const byChain = require_dev_fieldDiff.union(onchain.map((row) => String(row.chainId)), offchain.map((row) => String(row.chainId))).map((chainId) => ({
+		chainId: Number(chainId),
+		...require_dev_fieldDiff.toCompareCounts(onchain.filter((row) => String(row.chainId) === chainId).length, offchain.filter((row) => String(row.chainId) === chainId).length, onlyOnchain.filter((ref) => String(ref.chainId) === chainId).length, onlyOffchain.filter((ref) => String(ref.chainId) === chainId).length, matched.filter((match) => String(match.chainId) === chainId))
+	})).sort((a, b) => a.chainId - b.chainId);
+	return {
+		...require_dev_fieldDiff.toCompareCounts(onchain.length, offchain.length, onlyOnchain.length, onlyOffchain.length, matched),
+		byChain,
+		diffsByPath: require_dev_fieldDiff.countPaths(matched.flatMap((match) => match.diffs))
+	};
+}
+//#endregion
+exports.compareOpportunities = compareOpportunities;
+exports.diffOpportunity = diffOpportunity;

package/dist/cjs/dev/comparePositions.js

@@ -0,0 +1,183 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_model_positions = require("../model/positions.js");
+require("../model/index.js");
+const require_dev_fieldDiff = require("./fieldDiff.js");
+//#region src/dev/comparePositions.ts
+/**
+* Matches two position listings per wallet by {@link positionId} and reports
+* every field the two sources disagree on.
+*
+* Nothing is filtered out. A field only one mode can fill, or a USD value that
+* drifted within snapshot-lag noise, is still reported — tagged
+* {@link FieldDiff.expected} so that {@link CompareCounts.clean} can ignore it
+* while {@link CompareCounts.identical} stays strict.
+**/
+function comparePositions(input) {
+	const failures = input.failures ?? [];
+	const wallets = [...input.wallets.map(compareWallet), ...failures.map((failure) => ({
+		wallet: failure.wallet,
+		error: failure.error,
+		onlyOnchain: [],
+		onlyOffchain: [],
+		matched: []
+	}))];
+	wallets.sort((a, b) => a.wallet.localeCompare(b.wallet));
+	return {
+		generatedAt: input.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+		backendUrl: input.backendUrl,
+		networks: [...input.networks],
+		onchainChains: collectChains(input.wallets, "onchain"),
+		offchainChains: collectChains(input.wallets, "offchain"),
+		summary: summarize(input.wallets, wallets, failures.length),
+		wallets
+	};
+}
+/**
+* Every field two versions of one position disagree on.
+**/
+function diffPosition(onchain, offchain) {
+	return require_dev_fieldDiff.diffObjects(onchain, offchain, { keyOf: keyOfPositionArray }).map((diff) => tagDiff(diff, onchain.kind));
+}
+function compareWallet(input) {
+	const onchainRows = indexById(input.onchain.data);
+	const offchainRows = indexById(input.offchain.data);
+	const onlyOnchain = [];
+	const onlyOffchain = [];
+	const matched = [];
+	for (const [id, row] of onchainRows) {
+		const counterpart = offchainRows.get(id);
+		if (!counterpart) {
+			onlyOnchain.push(toRef(row));
+			continue;
+		}
+		const diffs = diffPosition(row, counterpart);
+		matched.push({
+			id,
+			kind: row.kind,
+			chainId: row.chainId,
+			onchainName: row.name,
+			offchainName: counterpart.name,
+			identical: diffs.length === 0,
+			clean: diffs.every((diff) => diff.expected),
+			diffs
+		});
+	}
+	for (const [id, row] of offchainRows) if (!onchainRows.has(id)) onlyOffchain.push(toRef(row));
+	onlyOnchain.sort((a, b) => a.id.localeCompare(b.id));
+	onlyOffchain.sort((a, b) => a.id.localeCompare(b.id));
+	matched.sort((a, b) => a.id.localeCompare(b.id));
+	return {
+		wallet: input.wallet,
+		onlyOnchain,
+		onlyOffchain,
+		matched
+	};
+}
+function indexById(rows) {
+	return new Map(rows.map((row) => [require_model_positions.positionId(row), row]));
+}
+function toRef(row) {
+	const base = {
+		id: require_model_positions.positionId(row),
+		kind: row.kind,
+		chainId: row.chainId,
+		name: row.name
+	};
+	switch (row.kind) {
+		case "pool": return {
+			...base,
+			pool: row.pool
+		};
+		case "strategy": return {
+			...base,
+			creditAccount: row.creditAccount,
+			creditManager: row.creditManager
+		};
+		case "liquidation": return base;
+	}
+}
+/**
+* `collaterals[]` is keyed by the collateral token, not by a top-level
+* address. Rewards-points programs already identify themselves by `id`.
+**/
+function keyOfPositionArray(path, value) {
+	if (path !== "collaterals" || !require_dev_fieldDiff.isRecord(value) || !require_dev_fieldDiff.isRecord(value.collateral)) return;
+	const token = value.collateral.token;
+	return require_dev_fieldDiff.isRecord(token) && typeof token.address === "string" ? token.address : void 0;
+}
+const BPS_RATE_PATHS = /* @__PURE__ */ new Set([
+	"borrowApy",
+	"apy.organicApy",
+	"healthFactor"
+]);
+/**
+* Amount fields whose bigint `value` moves with interest accrual between the
+* backend's last sync and the current block.
+**/
+function isLagAmountPath(path) {
+	return path === "totalDebt.value" || path === "totalValue.value" || path === "netValue.value" || path.endsWith(".collateral.value") || path.endsWith(".quota.value");
+}
+/**
+* Fields documented `@mode offchain` or `@mode onchain` in the model.
+**/
+function isModeScoped(path, kind) {
+	if (path === "pnl" || path.startsWith("pnl.")) return true;
+	if (kind === "pool") return path === "apy.totalApy" || path.startsWith("apy.rewards");
+	if (kind === "strategy") return path === "netApy" || path.startsWith("netApy.") || path === "borrowRate" || path.startsWith("borrowRate.") || path === "timeToLiquidation" || path === "liquidationPrice";
+	return false;
+}
+function tagDiff(diff, kind) {
+	if (isModeScoped(diff.path, kind)) return require_dev_fieldDiff.withExpected(diff, "mode-scoped");
+	if (withinTolerance(diff)) return require_dev_fieldDiff.withExpected(diff, "tolerance");
+	return diff;
+}
+function withinTolerance(diff) {
+	if (diff.kind === "usd") return require_dev_fieldDiff.isUsdWithinTolerance(diff.onchain, diff.offchain);
+	if (diff.kind !== "numeric") return false;
+	if (diff.path === "leverage") return require_dev_fieldDiff.withinRelative(require_dev_fieldDiff.asFiniteNumber(diff.onchain), require_dev_fieldDiff.asFiniteNumber(diff.offchain), require_dev_fieldDiff.USD_RELATIVE_EPSILON);
+	if (BPS_RATE_PATHS.has(diff.path)) return require_dev_fieldDiff.isBpsWithinTolerance(diff.onchain, diff.offchain);
+	if (isLagAmountPath(diff.path)) return require_dev_fieldDiff.isAmountWithinTolerance(diff.onchain, diff.offchain);
+	return false;
+}
+function summarize(inputs, wallets, failed) {
+	const compared = wallets.filter((wallet) => !wallet.error);
+	const allOnchain = inputs.flatMap((input) => input.onchain.data);
+	const allOffchain = inputs.flatMap((input) => input.offchain.data);
+	const onlyOnchain = compared.flatMap((wallet) => wallet.onlyOnchain);
+	const onlyOffchain = compared.flatMap((wallet) => wallet.onlyOffchain);
+	const matched = compared.flatMap((wallet) => wallet.matched);
+	const byChain = require_dev_fieldDiff.union(allOnchain.map((row) => String(row.chainId)), allOffchain.map((row) => String(row.chainId))).map((chainId) => ({
+		chainId: Number(chainId),
+		...require_dev_fieldDiff.toCompareCounts(allOnchain.filter((row) => String(row.chainId) === chainId).length, allOffchain.filter((row) => String(row.chainId) === chainId).length, onlyOnchain.filter((ref) => String(ref.chainId) === chainId).length, onlyOffchain.filter((ref) => String(ref.chainId) === chainId).length, matched.filter((match) => String(match.chainId) === chainId))
+	})).sort((a, b) => a.chainId - b.chainId);
+	const byWallet = wallets.map((wallet) => ({
+		wallet: wallet.wallet,
+		...wallet.error ? { error: wallet.error } : {},
+		...require_dev_fieldDiff.toCompareCounts(wallet.matched.length + wallet.onlyOnchain.length, wallet.matched.length + wallet.onlyOffchain.length, wallet.onlyOnchain.length, wallet.onlyOffchain.length, wallet.matched)
+	}));
+	const walletsClean = compared.filter((wallet) => wallet.onlyOnchain.length === 0 && wallet.onlyOffchain.length === 0 && wallet.matched.every((match) => match.clean)).length;
+	return {
+		...require_dev_fieldDiff.toCompareCounts(allOnchain.length, allOffchain.length, onlyOnchain.length, onlyOffchain.length, matched),
+		wallets: wallets.length,
+		walletsClean,
+		walletsFailed: failed,
+		byChain,
+		byWallet,
+		diffsByPath: require_dev_fieldDiff.countPaths(matched.flatMap((match) => match.diffs))
+	};
+}
+/**
+* One metadata entry per chain, preferring a success so the report names the
+* block. Later wallets of the same chain are ignored.
+**/
+function collectChains(wallets, side) {
+	const byChain = /* @__PURE__ */ new Map();
+	for (const wallet of wallets) for (const chain of wallet[side].meta.chains) {
+		const existing = byChain.get(chain.chainId);
+		if (!existing || existing.status !== "success" && chain.status === "success") byChain.set(chain.chainId, chain);
+	}
+	return [...byChain.values()].sort((a, b) => a.chainId - b.chainId);
+}
+//#endregion
+exports.comparePositions = comparePositions;
+exports.diffPosition = diffPosition;