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

package/dist/cjs/sdk/positions/PositionsService.js

@@ -2,6 +2,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_sdk_utils_AddressMap = require("../utils/AddressMap.js");
 require("../constants/math.js");
 require("../constants/index.js");
+const require_sdk_utils_hex = require("../utils/hex.js");
 require("../utils/index.js");
 const require_sdk_base_SDKConstruct = require("../base/SDKConstruct.js");
 require("../base/index.js");
@@ -147,7 +148,11 @@ var PositionsService = class extends require_sdk_base_SDKConstruct.SDKConstruct
 		const { pool } = market.pool;
 		const token = this.sdk.tokensMeta.mustGetToken(market.unwrappedUnderlying);
 		const totalDebtValue = ca.debt + ca.accruedInterest + ca.accruedFees;
-		const collateral = require_sdk_market_credit_dominantCollateral.dominantCollateral(ca, market);
+		let collateral = require_sdk_market_credit_dominantCollateral.dominantCollateral(ca, market);
+		if (collateral) {
+			const source = this.sdk.withdrawalCompressor?.getWithdrawalSourceToken(collateral);
+			if (source) collateral = require_sdk_utils_hex.hexEq(source, market.underlying) ? void 0 : source;
+		}
 		const snapshot = require_sdk_positions_types.accountSnapshotFromCreditAccountData(ca);
 		const borrowRate = this.borrowRate(snapshot);
 		const timeToLiquidation = this.timeToLiquidation(snapshot);

package/dist/esm/dev/AccountOpener.js

@@ -1,9 +1,9 @@
-import { ierc20Abi } from "../abi/iERC20.js";
 import { iCreditFacadeV310Abi } from "../abi/310/generated.js";
 import { AddressMap } from "../sdk/utils/AddressMap.js";
 import { AddressSet } from "../sdk/utils/AddressSet.js";
 import { AssetsMap } from "../sdk/utils/AssetsMap.js";
 import { childLogger } from "../sdk/utils/childLogger.js";
+import { ierc20Abi } from "../abi/iERC20.js";
 import "../sdk/constants/addresses.js";
 import { MAX_UINT256, PERCENTAGE_FACTOR } from "../sdk/constants/math.js";
 import { SDKConstruct } from "../sdk/base/SDKConstruct.js";

package/dist/esm/dev/compareOpportunities.js

@@ -1,14 +1,15 @@
 import { opportunityId } from "../model/opportunities.js";
 import "../model/index.js";
+import { countPaths, diffObjects, isAmountWithinTolerance, isBpsWithinTolerance, isUsdWithinTolerance, toCompareCounts, union, withExpected } from "./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 diff that is expected — a field only the backend
-* can fill, a formula the two sides define differently, a USD value smoothed on
-* one side — is reported like any other, tagged by {@link DiffKind} so that a
-* reader can bucket it afterwards.
+* 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);
@@ -30,6 +31,7 @@ function compareOpportunities(input) {
 			onchainName: row.name,
 			offchainName: counterpart.name,
 			identical: diffs.length === 0,
+			clean: diffs.every((diff) => diff.expected),
 			diffs
 		});
 	}
@@ -75,142 +77,59 @@ function toRef(row) {
 * Every field two versions of one opportunity disagree on.
 **/
 function diffOpportunity(onchain, offchain) {
-	const diffs = [];
-	diffValue("", onchain, offchain, diffs);
-	return diffs;
-}
-function diffValue(path, onchain, offchain, out) {
-	if (isAbsent(onchain) && isAbsent(offchain)) return;
-	if (isAbsent(onchain) || isAbsent(offchain)) {
-		out.push({
-			path,
-			onchain,
-			offchain,
-			kind: "presence"
-		});
-		return;
-	}
-	if (Array.isArray(onchain) && Array.isArray(offchain)) {
-		diffArray(path, onchain, offchain, out);
-		return;
-	}
-	if (isRecord(onchain) && isRecord(offchain)) {
-		for (const key of union(Object.keys(onchain), Object.keys(offchain))) diffValue(join(path, key), onchain[key], offchain[key], out);
-		return;
-	}
-	if (!sameScalar(onchain, offchain)) out.push({
-		path,
-		onchain,
-		offchain,
-		kind: scalarKind(path, onchain)
-	});
+	return diffObjects(onchain, offchain).map((diff) => tagDiff(diff, onchain.kind));
 }
 /**
-* Arrays whose elements identify themselves — collateral tokens, points
-* programs — are matched by that identity, so a token present on one side only
-* is reported as such rather than shifting every later element into a diff.
+* Paths whose values are basis-point rates that routinely differ by ±1 from
+* truncation vs rounding, plus pool `utilization` for the same reason.
 **/
-function diffArray(path, onchain, offchain, out) {
-	const onchainKeyed = keyElements(onchain);
-	const offchainKeyed = keyElements(offchain);
-	if (!onchainKeyed || !offchainKeyed) {
-		if (onchain.length !== offchain.length) {
-			out.push({
-				path,
-				onchain,
-				offchain,
-				kind: "other"
-			});
-			return;
-		}
-		onchain.forEach((element, index) => {
-			diffValue(`${path}[${index}]`, element, offchain[index], out);
-		});
-		return;
-	}
-	for (const key of union([...onchainKeyed.keys()], [...offchainKeyed.keys()])) diffValue(`${path}[${key}]`, onchainKeyed.get(key), offchainKeyed.get(key), out);
-}
+const BPS_RATE_PATHS = /* @__PURE__ */ new Set([
+	"borrowApy",
+	"supplyApy.organicApy",
+	"additionalBorrowApy",
+	"utilization"
+]);
 /**
-* The array indexed by each element's own identity, or `undefined` when its
-* elements have none and order is all there is to go by.
+* 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.
 **/
-function keyElements(values) {
-	const keyed = /* @__PURE__ */ new Map();
-	for (const value of values) {
-		if (!isRecord(value)) return;
-		const identity = value.address ?? value.id ?? value.token;
-		if (typeof identity !== "string") return;
-		keyed.set(identity.toLowerCase(), value);
-	}
-	return keyed.size === values.length ? keyed : void 0;
-}
-const ADDRESS = /^0x[0-9a-f]{40}$/i;
+const LAG_AMOUNT_PATHS = /* @__PURE__ */ new Set(["totalSupply.value", "availableLiquidity.value"]);
 /**
-* Only addresses are compared case-insensitively: the backend lowercases them
-* while the chain hands out checksummed ones, which is not a disagreement. A
-* symbol or a name spelled differently is.
+* 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 sameScalar(onchain, offchain) {
-	if (typeof onchain === "string" && typeof offchain === "string" && ADDRESS.test(onchain) && ADDRESS.test(offchain)) return onchain.toLowerCase() === offchain.toLowerCase();
-	return onchain === offchain;
-}
-function scalarKind(path, onchain) {
-	if (path.endsWith("valueUsd")) return "usd";
-	return typeof onchain === "number" || typeof onchain === "bigint" ? "numeric" : "other";
+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 withExpected(diff, "mode-scoped");
+	if (withinTolerance(diff)) return withExpected(diff, "tolerance");
+	return diff;
+}
+function withinTolerance(diff) {
+	if (diff.kind === "usd") return isUsdWithinTolerance(diff.onchain, diff.offchain);
+	if (diff.kind !== "numeric") return false;
+	if (BPS_RATE_PATHS.has(diff.path)) return isBpsWithinTolerance(diff.onchain, diff.offchain);
+	if (LAG_AMOUNT_PATHS.has(diff.path)) return isAmountWithinTolerance(diff.onchain, diff.offchain);
+	return false;
 }
 function summarize(onchain, offchain, onlyOnchain, onlyOffchain, matched) {
 	const byChain = union(onchain.map((row) => String(row.chainId)), offchain.map((row) => String(row.chainId))).map((chainId) => ({
 		chainId: Number(chainId),
-		...count(onchain.filter((row) => String(row.chainId) === chainId), offchain.filter((row) => String(row.chainId) === chainId), onlyOnchain.filter((ref) => String(ref.chainId) === chainId), onlyOffchain.filter((ref) => String(ref.chainId) === chainId), matched.filter((match) => String(match.chainId) === chainId))
+		...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 {
-		...count(onchain, offchain, onlyOnchain, onlyOffchain, matched),
+		...toCompareCounts(onchain.length, offchain.length, onlyOnchain.length, onlyOffchain.length, matched),
 		byChain,
-		diffsByPath: countPaths(matched)
+		diffsByPath: countPaths(matched.flatMap((match) => match.diffs))
 	};
 }
-function count(onchain, offchain, onlyOnchain, onlyOffchain, matched) {
-	const identical = matched.filter((match) => match.identical).length;
-	return {
-		onchainRows: onchain.length,
-		offchainRows: offchain.length,
-		matched: matched.length,
-		identical,
-		differing: matched.length - identical,
-		onlyOnchain: onlyOnchain.length,
-		onlyOffchain: onlyOffchain.length
-	};
-}
-/**
-* How often each field differed, with array keys collapsed so that the same
-* field of a hundred collateral tokens counts as one path.
-**/
-function countPaths(matched) {
-	const counts = /* @__PURE__ */ new Map();
-	for (const match of matched) for (const diff of match.diffs) {
-		const path = diff.path.replace(/\[[^\]]*\]/g, "[]");
-		const entry = counts.get(path) ?? {
-			path,
-			kinds: [],
-			count: 0
-		};
-		entry.count += 1;
-		if (!entry.kinds.includes(diff.kind)) entry.kinds.push(diff.kind);
-		counts.set(path, entry);
-	}
-	return [...counts.values()].sort((a, b) => b.count - a.count || a.path.localeCompare(b.path));
-}
-function isAbsent(value) {
-	return value === void 0 || value === null;
-}
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function union(left, right) {
-	return [.../* @__PURE__ */ new Set([...left, ...right])];
-}
-function join(path, key) {
-	return path ? `${path}.${key}` : key;
-}
 //#endregion
 export { compareOpportunities, diffOpportunity };

package/dist/esm/dev/comparePositions.js

@@ -0,0 +1,181 @@
+import { positionId } from "../model/positions.js";
+import "../model/index.js";
+import { USD_RELATIVE_EPSILON, asFiniteNumber, countPaths, diffObjects, isAmountWithinTolerance, isBpsWithinTolerance, isRecord, isUsdWithinTolerance, toCompareCounts, union, withExpected, withinRelative } from "./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 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) => [positionId(row), row]));
+}
+function toRef(row) {
+	const base = {
+		id: 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" || !isRecord(value) || !isRecord(value.collateral)) return;
+	const token = value.collateral.token;
+	return 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 withExpected(diff, "mode-scoped");
+	if (withinTolerance(diff)) return withExpected(diff, "tolerance");
+	return diff;
+}
+function withinTolerance(diff) {
+	if (diff.kind === "usd") return isUsdWithinTolerance(diff.onchain, diff.offchain);
+	if (diff.kind !== "numeric") return false;
+	if (diff.path === "leverage") return withinRelative(asFiniteNumber(diff.onchain), asFiniteNumber(diff.offchain), USD_RELATIVE_EPSILON);
+	if (BPS_RATE_PATHS.has(diff.path)) return isBpsWithinTolerance(diff.onchain, diff.offchain);
+	if (isLagAmountPath(diff.path)) return 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 = union(allOnchain.map((row) => String(row.chainId)), allOffchain.map((row) => String(row.chainId))).map((chainId) => ({
+		chainId: Number(chainId),
+		...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 } : {},
+		...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 {
+		...toCompareCounts(allOnchain.length, allOffchain.length, onlyOnchain.length, onlyOffchain.length, matched),
+		wallets: wallets.length,
+		walletsClean,
+		walletsFailed: failed,
+		byChain,
+		byWallet,
+		diffsByPath: 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
+export { comparePositions, diffPosition };

package/dist/esm/dev/fieldDiff.js

@@ -0,0 +1,224 @@
+//#region src/dev/fieldDiff.ts
+/**
+* Relative drift allowed on {@link Amount.valueUsd} before a USD float is a
+* real disagreement: 0.1%.
+**/
+const USD_RELATIVE_EPSILON = .001;
+/**
+* Relative drift allowed on lag-bounded bigint amounts: 0.05%.
+**/
+const AMOUNT_RELATIVE_EPSILON = 5e-4;
+/**
+* Absolute drift allowed on bps rates before rounding and a one-block lag are
+* no longer enough to explain it.
+**/
+const BPS_ABSOLUTE_EPSILON = 1;
+/**
+* Every field two versions of one value disagree on. Nothing is filtered or
+* tagged: the caller marks expected diffs afterwards.
+**/
+function diffValue(path, onchain, offchain, out, options) {
+	if (isAbsent(onchain) && isAbsent(offchain)) return;
+	if (isAbsent(onchain) || isAbsent(offchain)) {
+		out.push({
+			path,
+			onchain,
+			offchain,
+			kind: "presence"
+		});
+		return;
+	}
+	if (Array.isArray(onchain) && Array.isArray(offchain)) {
+		diffArray(path, onchain, offchain, out, options);
+		return;
+	}
+	if (isRecord(onchain) && isRecord(offchain)) {
+		for (const key of union(Object.keys(onchain), Object.keys(offchain))) diffValue(join(path, key), onchain[key], offchain[key], out, options);
+		return;
+	}
+	if (!sameScalar(onchain, offchain)) out.push({
+		path,
+		onchain,
+		offchain,
+		kind: scalarKind(path, onchain)
+	});
+}
+/**
+* Deep-diff two values and return the disagreements, in path order of
+* discovery.
+**/
+function diffObjects(onchain, offchain, options) {
+	const diffs = [];
+	diffValue("", onchain, offchain, diffs, options);
+	return diffs;
+}
+/**
+* Mark a diff expected, so a later `clean` count can ignore it.
+**/
+function withExpected(diff, reason) {
+	return {
+		...diff,
+		expected: true,
+		reason
+	};
+}
+/**
+* How often each field differed, with array keys collapsed so that the same
+* field of a hundred collateral tokens counts as one path. Sorted so the
+* unexpected disagreements come first.
+**/
+function countPaths(diffs) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const diff of diffs) {
+		const path = collapseArrayKeys(diff.path);
+		const entry = counts.get(path) ?? {
+			path,
+			kinds: [],
+			count: 0,
+			expected: 0,
+			unexpected: 0
+		};
+		entry.count += 1;
+		if (diff.expected) entry.expected += 1;
+		else entry.unexpected += 1;
+		if (!entry.kinds.includes(diff.kind)) entry.kinds.push(diff.kind);
+		counts.set(path, entry);
+	}
+	return [...counts.values()].sort((a, b) => b.unexpected - a.unexpected || b.count - a.count || a.path.localeCompare(b.path));
+}
+/**
+* Collapse `collateralTokens[0xa0b8...].symbol` to `collateralTokens[].symbol`.
+**/
+function collapseArrayKeys(path) {
+	return path.replace(/\[[^\]]*\]/g, "[]");
+}
+/**
+* Membership and match totals of one comparison, from already-built lists.
+**/
+function toCompareCounts(onchainRows, offchainRows, onlyOnchain, onlyOffchain, matched) {
+	const identical = matched.filter((match) => match.identical).length;
+	const clean = matched.filter((match) => match.clean).length;
+	return {
+		onchainRows,
+		offchainRows,
+		matched: matched.length,
+		identical,
+		clean,
+		differing: matched.length - identical,
+		onlyOnchain,
+		onlyOffchain
+	};
+}
+/**
+* USD floats within {@link USD_RELATIVE_EPSILON}.
+**/
+function isUsdWithinTolerance(onchain, offchain) {
+	return withinRelative(asFiniteNumber(onchain), asFiniteNumber(offchain), USD_RELATIVE_EPSILON);
+}
+/**
+* Bps rates that differ by at most {@link BPS_ABSOLUTE_EPSILON}.
+**/
+function isBpsWithinTolerance(onchain, offchain) {
+	const left = asFiniteNumber(onchain);
+	const right = asFiniteNumber(offchain);
+	return left !== void 0 && right !== void 0 && Math.abs(left - right) <= 1;
+}
+/**
+* Bigint amounts within {@link AMOUNT_RELATIVE_EPSILON}.
+**/
+function isAmountWithinTolerance(onchain, offchain) {
+	return typeof onchain === "bigint" && typeof offchain === "bigint" && withinRelativeBigint(onchain, offchain, 5e-4);
+}
+/**
+* Finite numbers within a relative epsilon of each other.
+**/
+function withinRelative(onchain, offchain, epsilon) {
+	if (onchain === void 0 || offchain === void 0) return false;
+	const scale = Math.max(Math.abs(onchain), Math.abs(offchain));
+	return scale === 0 ? true : Math.abs(onchain - offchain) / scale <= epsilon;
+}
+/**
+* `diff / max(|a|, |b|) <= epsilon`, computed in integer arithmetic so a
+* 1e18-scale amount does not round through `Number`.
+**/
+function withinRelativeBigint(onchain, offchain, epsilon) {
+	if (onchain === offchain) return true;
+	const diff = onchain > offchain ? onchain - offchain : offchain - onchain;
+	const scale = abs(onchain) > abs(offchain) ? abs(onchain) : abs(offchain);
+	if (scale === 0n) return true;
+	return diff * BigInt(Math.round(1 / epsilon)) <= scale;
+}
+function asFiniteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function union(left, right) {
+	return [.../* @__PURE__ */ new Set([...left, ...right])];
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function diffArray(path, onchain, offchain, out, options) {
+	const onchainKeyed = keyElements(path, onchain, options?.keyOf);
+	const offchainKeyed = keyElements(path, offchain, options?.keyOf);
+	if (!onchainKeyed || !offchainKeyed) {
+		if (onchain.length !== offchain.length) {
+			out.push({
+				path,
+				onchain,
+				offchain,
+				kind: "other"
+			});
+			return;
+		}
+		onchain.forEach((element, index) => {
+			diffValue(`${path}[${index}]`, element, offchain[index], out, options);
+		});
+		return;
+	}
+	for (const key of union([...onchainKeyed.keys()], [...offchainKeyed.keys()])) diffValue(`${path}[${key}]`, onchainKeyed.get(key), offchainKeyed.get(key), out, options);
+}
+/**
+* The array indexed by each element's own identity, or `undefined` when its
+* elements have none and order is all there is to go by.
+**/
+function keyElements(path, values, keyOf) {
+	const keyed = /* @__PURE__ */ new Map();
+	for (const value of values) {
+		const identity = keyOf?.(path, value) ?? defaultIdentity(value);
+		if (typeof identity !== "string") return;
+		keyed.set(identity.toLowerCase(), value);
+	}
+	return keyed.size === values.length ? keyed : void 0;
+}
+function defaultIdentity(value) {
+	if (!isRecord(value)) return;
+	if (typeof value.address === "string") return value.address;
+	if (typeof value.id === "string") return value.id;
+	if (typeof value.token === "string") return value.token;
+	if (isRecord(value.token) && typeof value.token.address === "string") return value.token.address;
+}
+const ADDRESS = /^0x[0-9a-f]{40}$/i;
+/**
+* Only addresses are compared case-insensitively: the backend lowercases them
+* while the chain hands out checksummed ones, which is not a disagreement. A
+* symbol or a name spelled differently is.
+**/
+function sameScalar(onchain, offchain) {
+	if (typeof onchain === "string" && typeof offchain === "string" && ADDRESS.test(onchain) && ADDRESS.test(offchain)) return onchain.toLowerCase() === offchain.toLowerCase();
+	return onchain === offchain;
+}
+function scalarKind(path, onchain) {
+	if (path.endsWith("valueUsd")) return "usd";
+	return typeof onchain === "number" || typeof onchain === "bigint" ? "numeric" : "other";
+}
+function isAbsent(value) {
+	return value === void 0 || value === null;
+}
+function join(path, key) {
+	return path ? `${path}.${key}` : key;
+}
+function abs(value) {
+	return value < 0n ? -value : value;
+}
+//#endregion
+export { AMOUNT_RELATIVE_EPSILON, BPS_ABSOLUTE_EPSILON, USD_RELATIVE_EPSILON, asFiniteNumber, collapseArrayKeys, countPaths, diffObjects, diffValue, isAmountWithinTolerance, isBpsWithinTolerance, isRecord, isUsdWithinTolerance, toCompareCounts, union, withExpected, withinRelative, withinRelativeBigint };

package/dist/esm/dev/withdrawalUtils.js

@@ -1,6 +1,6 @@
-import { iWithdrawalCompressorV313Abi } from "../abi/IWithdrawalCompressorV313.js";
 import { getNetworkType } from "../sdk/chain/chains.js";
 import { getWithdrawalCompressorAddress } from "../sdk/accounts/withdrawal-compressor/addresses.js";
+import { iWithdrawalCompressorV313Abi } from "../abi/IWithdrawalCompressorV313.js";
 import "../sdk/index.js";
 import { iMidasDataFeedAbi, iMidasRedemptionVaultAbi, midasGatewayAbi, midasRedeemerAbi, midasRedemptionVaultPhantomTokenAbi, securitizeRedeemerAbi, securitizeRedemptionGatewayAbi, securitizeRedemptionPhantomTokenAbi } from "./withdrawalAbi.js";
 import { erc20Abi, hexToString, parseAbi, parseEther } from "viem";

package/dist/esm/plugins/adapters/contracts/ERC4626AdapterContract.js

@@ -1,5 +1,5 @@
-import { ierc4626AdapterAbi } from "../../../abi/ierc4626Adapter.js";
 import { MissingSerializedParamsError } from "../../../sdk/base/errors.js";
+import { ierc4626AdapterAbi } from "../../../abi/ierc4626Adapter.js";
 import "../../../sdk/index.js";
 import { fnSigToName, swapFromTransfers } from "../transferHelpers.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";

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

@@ -1,5 +1,5 @@
-import { iZapperAbi } from "../../abi/iZapper.js";
 import { iPoolV310Abi } from "../../abi/310/generated.js";
+import { iZapperAbi } from "../../abi/iZapper.js";
 import { asPreviewSimulationError } from "./errors.js";
 //#region src/preview/simulate/simulatePoolOperation.ts
 function previewRead(operation) {