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

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

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_sdk_utils_zod = require("../sdk/utils/zod.js");
+const require_model_compare_schema = require("./compare.schema.js");
 const require_model_primitives_schema = require("./primitives.schema.js");
 const require_model_filters = require("./filters.js");
 const require_model_filters_schema = require("./filters.schema.js");
@@ -56,8 +57,8 @@ const pnlBreakdownSchema = zod_v4.z.object({
 * {@link PositionCollateral}
 **/
 const positionCollateralSchema = zod_v4.z.object({
-	collateral: require_model_primitives_schema.tokenAmountSchema,
-	quota: require_model_primitives_schema.tokenAmountSchema,
+	collateral: require_model_compare_schema.tolerance(require_model_primitives_schema.tokenAmountSchema, "amount"),
+	quota: require_model_compare_schema.tolerance(require_model_primitives_schema.tokenAmountSchema, "amount"),
 	withdrawals: zod_v4.z.array(require_model_liquidations_schema.delayedReceivedAssetSchema)
 });
 /**
@@ -68,9 +69,9 @@ const poolPositionSchema = zod_v4.z.object({
 	name: zod_v4.z.string(),
 	chainId: require_model_primitives_schema.chainIdSchema,
 	pool: require_sdk_utils_zod.ZodAddress(),
-	netValue: require_model_primitives_schema.tokenAmountSchema,
+	netValue: require_model_compare_schema.tolerance(require_model_primitives_schema.tokenAmountSchema, "amount"),
 	apy: require_model_opportunities_schema.apyBreakdownSchema,
-	pnl: pnlBreakdownSchema.optional()
+	pnl: require_model_compare_schema.offchainOnly(pnlBreakdownSchema).optional()
 });
 /**
 * {@link BorrowRateBreakdown}
@@ -91,16 +92,16 @@ const strategyPositionSchema = zod_v4.z.object({
 	creditManager: require_sdk_utils_zod.ZodAddress(),
 	creditAccount: require_sdk_utils_zod.ZodAddress(),
 	targetCollateral: require_model_primitives_schema.tokenSchema.nullable(),
-	leverage: require_model_primitives_schema.leverageSchema,
-	borrowApy: require_model_primitives_schema.bpsSchema,
-	netApy: require_model_opportunities_schema.apyBreakdownSchema.optional(),
-	totalDebt: require_model_primitives_schema.tokenAmountSchema,
-	totalValue: require_model_primitives_schema.tokenAmountSchema,
-	healthFactor: require_model_primitives_schema.bpsSchema,
-	borrowRate: borrowRateBreakdownSchema.optional(),
-	timeToLiquidation: require_sdk_utils_zod.ZodBigInt().nullable().optional(),
-	liquidationPrice: require_sdk_utils_zod.ZodBigInt().nullable().optional(),
-	pnl: pnlBreakdownSchema.optional(),
+	leverage: require_model_compare_schema.tolerance(require_model_primitives_schema.leverageSchema, "float"),
+	borrowApy: require_model_compare_schema.tolerance(require_model_primitives_schema.bpsSchema, "bps"),
+	netApy: require_model_compare_schema.offchainOnly(require_model_opportunities_schema.apyBreakdownSchema).optional(),
+	totalDebt: require_model_compare_schema.tolerance(require_model_primitives_schema.tokenAmountSchema, "amount"),
+	totalValue: require_model_compare_schema.tolerance(require_model_primitives_schema.tokenAmountSchema, "amount"),
+	healthFactor: require_model_compare_schema.tolerance(require_model_primitives_schema.bpsSchema, "bps"),
+	borrowRate: require_model_compare_schema.onchainOnly(borrowRateBreakdownSchema).optional(),
+	timeToLiquidation: require_model_compare_schema.onchainOnly(require_sdk_utils_zod.ZodBigInt().nullable()).optional(),
+	liquidationPrice: require_model_compare_schema.onchainOnly(require_sdk_utils_zod.ZodBigInt().nullable()).optional(),
+	pnl: require_model_compare_schema.offchainOnly(pnlBreakdownSchema).optional(),
 	collaterals: zod_v4.z.array(positionCollateralSchema)
 });
 /**

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

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_sdk_utils_zod = require("../sdk/utils/zod.js");
+const require_model_compare_schema = require("./compare.schema.js");
 let zod_v4 = require("zod/v4");
 //#region src/model/primitives.schema.ts
 /**
@@ -40,7 +41,7 @@ const leverageSchema = zod_v4.z.number().nonnegative();
 **/
 const amountSchema = zod_v4.z.object({
 	value: require_sdk_utils_zod.ZodBigInt(),
-	valueUsd: zod_v4.z.number().nullable()
+	valueUsd: require_model_compare_schema.tolerance(zod_v4.z.number().nullable(), "usd")
 });
 /**
 * {@link Token}

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

@@ -10,8 +10,8 @@ require("./errors/index.js");
 const require_new_sdk_AbstractNamespace = require("./AbstractNamespace.js");
 const require_new_sdk_execute_ExecuteApi = require("./execute/ExecuteApi.js");
 require("./execute/index.js");
-const require_new_sdk_simulate_SimulateApi = require("./simulate/SimulateApi.js");
-require("./simulate/index.js");
+const require_new_sdk_prepare_PrepareApi = require("./prepare/PrepareApi.js");
+require("./prepare/index.js");
 const require_new_sdk_utils_filterResponse = require("./utils/filterResponse.js");
 const require_new_sdk_utils_mergeChains = require("./utils/mergeChains.js");
 require("./utils/index.js");
@@ -31,7 +31,7 @@ exports.MissingSourceError = require_new_sdk_errors_MissingSourceError.MissingSo
 exports.NoSourceServedError = require_new_sdk_errors_NoSourceServedError.NoSourceServedError;
 exports.OpportunitiesNamespace = require_new_sdk_opportunities_OpportunitiesNamespace.OpportunitiesNamespace;
 exports.PositionsNamespace = require_new_sdk_positions_PositionsNamespace.PositionsNamespace;
-exports.SimulateApi = require_new_sdk_simulate_SimulateApi.SimulateApi;
+exports.PrepareApi = require_new_sdk_prepare_PrepareApi.PrepareApi;
 exports.SourceChainMismatchError = require_new_sdk_errors_SourceChainMismatchError.SourceChainMismatchError;
 exports.SourceUnavailableError = require_new_sdk_errors_SourceUnavailableError.SourceUnavailableError;
 exports.assertSameChains = require_new_sdk_errors_assertSameChains.assertSameChains;

package/dist/cjs/new-sdk/opportunities/OpportunitiesNamespace.js

@@ -6,8 +6,8 @@ require("../errors/index.js");
 const require_new_sdk_AbstractNamespace = require("../AbstractNamespace.js");
 const require_new_sdk_execute_ExecuteApi = require("../execute/ExecuteApi.js");
 require("../execute/index.js");
-const require_new_sdk_simulate_SimulateApi = require("../simulate/SimulateApi.js");
-require("../simulate/index.js");
+const require_new_sdk_prepare_PrepareApi = require("../prepare/PrepareApi.js");
+require("../prepare/index.js");
 const require_new_sdk_utils_filterResponse = require("../utils/filterResponse.js");
 const require_new_sdk_utils_mergeChains = require("../utils/mergeChains.js");
 require("../utils/index.js");
@@ -25,19 +25,19 @@ var OpportunitiesNamespace = class extends require_new_sdk_AbstractNamespace.Abs
 		pool: (onchain, offchain) => require_new_sdk_utils_mergeChains.mergeChainOne(onchain, offchain, this.maxOffchainLagSeconds),
 		strategy: (onchain, offchain) => require_new_sdk_utils_mergeChains.mergeChainOne(onchain, offchain, this.maxOffchainLagSeconds)
 	};
-	#simulate;
+	#prepare;
 	#execute;
 	constructor(onchain, offchain, options) {
 		super("Opportunities", onchain?.opportunities, offchain?.opportunities, options);
-		this.#simulate = onchain && new require_new_sdk_simulate_SimulateApi.SimulateApi(onchain, options.ensureFresh);
+		this.#prepare = onchain && new require_new_sdk_prepare_PrepareApi.PrepareApi(onchain, options.ensureFresh);
 		this.#execute = onchain && new require_new_sdk_execute_ExecuteApi.ExecuteApi((chainId) => onchain.chain(chainId));
 	}
 	/**
-	* {@inheritDoc OpportunitiesOnchainOnly.simulate}
+	* {@inheritDoc OpportunitiesOnchainOnly.prepare}
 	**/
-	get simulate() {
-		if (!this.#simulate) throw new require_new_sdk_errors_SourceUnavailableError.SourceUnavailableError("Opportunities", "onchain");
-		return this.#simulate;
+	get prepare() {
+		if (!this.#prepare) throw new require_new_sdk_errors_SourceUnavailableError.SourceUnavailableError("Opportunities", "onchain");
+		return this.#prepare;
 	}
 	/**
 	* {@inheritDoc OpportunitiesOnchainOnly.execute}

package/dist/cjs/new-sdk/{simulate/SimulateApi.js → prepare/PrepareApi.js}

@@ -4,9 +4,9 @@ const require_sdk_base_MultichainConstruct = require("../../sdk/base/MultichainC
 const require_sdk_accounts_intents_utils_credit_account_slice = require("../../sdk/accounts/intents/utils/credit-account-slice.js");
 const require_sdk_accounts_intents_index = require("../../sdk/accounts/intents/index.js");
 require("../../sdk/index.js");
-//#region src/new-sdk/simulate/SimulateApi.ts
+//#region src/new-sdk/prepare/PrepareApi.ts
 /**
-* {@inheritDoc OpportunitiesSimulate}
+* {@inheritDoc OpportunitiesPrepare}
 *
 * Holds no state of its own: it owns the mapping from the public,
 * read-model-shaped request to the engine's intent, and nothing else. All
@@ -18,7 +18,7 @@ require("../../sdk/index.js");
 * to, hence a chain the SDK does not cover, or one that fails the read, throws
 * rather than answering with empty metadata.
 **/
-var SimulateApi = class extends require_sdk_base_MultichainConstruct.MultichainConstruct {
+var PrepareApi = class extends require_sdk_base_MultichainConstruct.MultichainConstruct {
 	#ensureFresh;
 	constructor(sdk, ensureFresh) {
 		super(sdk);
@@ -29,22 +29,10 @@ var SimulateApi = class extends require_sdk_base_MultichainConstruct.MultichainC
 		return super.queryChain(props);
 	}
 	/**
-	* {@inheritDoc OpportunitiesSimulate.delayed}
+	* {@inheritDoc OpportunitiesPrepare.finalize}
 	**/
-	delayed = {
-		withdrawStrategy: (position, params) => this.#startDelayedIntent(position, params, {
-			type: "WITHDRAW",
-			amount: params.amount,
-			to: params.to,
-			tokenOut: params.tokenOut,
-			sourceToken: params.sourceToken
-		}),
-		adjustLeverage: (position, params) => this.#startDelayedIntent(position, params, {
-			type: "ADJUST_LEVERAGE",
-			targetLeverage: params.targetLeverage,
-			token: params.token
-		}),
-		finish: (position, params) => this.queryChain({
+	async finalize(position, params) {
+		return this.queryChain({
 			network: position.chainId,
 			run: async (sdk) => {
 				const intent = resumable(params.intent ?? params.claimable.intent);
@@ -61,10 +49,10 @@ var SimulateApi = class extends require_sdk_base_MultichainConstruct.MultichainC
 					quotaReserve: params.quotaReserve
 				});
 			}
-		})
-	};
+		});
+	}
 	/**
-	* {@inheritDoc OpportunitiesSimulate.deposit}
+	* {@inheritDoc OpportunitiesPrepare.deposit}
 	**/
 	deposit(pool, params) {
 		const { marketRegister, pools } = this.sdk.chain(pool.chainId);
@@ -98,7 +86,7 @@ var SimulateApi = class extends require_sdk_base_MultichainConstruct.MultichainC
 		};
 	}
 	/**
-	* {@inheritDoc OpportunitiesSimulate.withdraw}
+	* {@inheritDoc OpportunitiesPrepare.withdraw}
 	**/
 	withdraw(pool, params) {
 		const { pools } = this.sdk.chain(pool.chainId);
@@ -130,7 +118,7 @@ var SimulateApi = class extends require_sdk_base_MultichainConstruct.MultichainC
 		};
 	}
 	/**
-	* {@inheritDoc OpportunitiesSimulate.redeem}
+	* {@inheritDoc OpportunitiesPrepare.redeem}
 	**/
 	redeem(pool, params) {
 		const { pools } = this.sdk.chain(pool.chainId);
@@ -162,7 +150,7 @@ var SimulateApi = class extends require_sdk_base_MultichainConstruct.MultichainC
 		};
 	}
 	/**
-	* {@inheritDoc OpportunitiesSimulate.openNewStrategy}
+	* {@inheritDoc OpportunitiesPrepare.openNewStrategy}
 	**/
 	async openNewStrategy(strategy, params) {
 		return this.queryChain({
@@ -180,7 +168,7 @@ var SimulateApi = class extends require_sdk_base_MultichainConstruct.MultichainC
 		});
 	}
 	/**
-	* {@inheritDoc OpportunitiesSimulate.depositStrategy}
+	* {@inheritDoc OpportunitiesPrepare.depositStrategy}
 	**/
 	async depositStrategy(position, params) {
 		return this.#startIntent(position, params, {
@@ -193,7 +181,7 @@ var SimulateApi = class extends require_sdk_base_MultichainConstruct.MultichainC
 		});
 	}
 	/**
-	* {@inheritDoc OpportunitiesSimulate.withdrawStrategy}
+	* {@inheritDoc OpportunitiesPrepare.withdrawStrategy}
 	**/
 	async withdrawStrategy(position, params) {
 		return this.#startRoutes(position, params, {
@@ -205,7 +193,7 @@ var SimulateApi = class extends require_sdk_base_MultichainConstruct.MultichainC
 		});
 	}
 	/**
-	* {@inheritDoc OpportunitiesSimulate.maxWithdraw}
+	* {@inheritDoc OpportunitiesPrepare.maxWithdraw}
 	**/
 	async maxWithdraw(position) {
 		return this.queryChain({
@@ -217,7 +205,7 @@ var SimulateApi = class extends require_sdk_base_MultichainConstruct.MultichainC
 		});
 	}
 	/**
-	* {@inheritDoc OpportunitiesSimulate.repayStrategy}
+	* {@inheritDoc OpportunitiesPrepare.repayStrategy}
 	**/
 	async repayStrategy(position, params) {
 		return this.#startIntent(position, params, {
@@ -228,7 +216,7 @@ var SimulateApi = class extends require_sdk_base_MultichainConstruct.MultichainC
 		});
 	}
 	/**
-	* {@inheritDoc OpportunitiesSimulate.maxRepay}
+	* {@inheritDoc OpportunitiesPrepare.maxRepay}
 	**/
 	async maxRepay(position) {
 		return this.queryChain({
@@ -240,7 +228,7 @@ var SimulateApi = class extends require_sdk_base_MultichainConstruct.MultichainC
 		});
 	}
 	/**
-	* {@inheritDoc OpportunitiesSimulate.adjustLeverage}
+	* {@inheritDoc OpportunitiesPrepare.adjustLeverage}
 	**/
 	async adjustLeverage(position, params) {
 		return this.#startRoutes(position, params, {
@@ -250,7 +238,7 @@ var SimulateApi = class extends require_sdk_base_MultichainConstruct.MultichainC
 		});
 	}
 	/**
-	* {@inheritDoc OpportunitiesSimulate.addCollateral}
+	* {@inheritDoc OpportunitiesPrepare.addCollateral}
 	**/
 	async addCollateral(position, params) {
 		return this.#startIntent(position, params, {
@@ -261,7 +249,7 @@ var SimulateApi = class extends require_sdk_base_MultichainConstruct.MultichainC
 		});
 	}
 	/**
-	* {@inheritDoc OpportunitiesSimulate.withdrawCollateral}
+	* {@inheritDoc OpportunitiesPrepare.withdrawCollateral}
 	**/
 	async withdrawCollateral(position, params) {
 		return this.#startIntent(position, params, {
@@ -288,22 +276,6 @@ var SimulateApi = class extends require_sdk_base_MultichainConstruct.MultichainC
 		});
 	}
 	/**
-	* Shared path of the same two flows when only the delayed route is asked for:
-	* a planner that requests a redemption instead of swapping.
-	**/
-	async #startDelayedIntent(position, options, intent) {
-		return this.queryChain({
-			network: position.chainId,
-			run: async (sdk) => service(sdk).startDelayedIntent({
-				intent,
-				creditAccount: await slice(sdk, position.creditAccount),
-				sdk,
-				slippage: options.slippage,
-				quotaReserve: options.quotaReserve
-			})
-		});
-	}
-	/**
 	* Shared path of the five flows that act on an existing account: read the
 	* account, then run the intent through the engine.
 	**/
@@ -358,4 +330,4 @@ function lpRoute(requested, routes) {
 	return options.length === 1 ? options[0] : void 0;
 }
 //#endregion
-exports.SimulateApi = SimulateApi;
+exports.PrepareApi = PrepareApi;

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

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

package/dist/esm/dev/{compareOpportunities.js → mode-parity/compareOpportunities.js}

@@ -1,7 +1,13 @@
-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
+import { opportunityId } from "../../model/opportunities.js";
+import { poolOpportunitySchema, strategyOpportunitySchema } from "../../model/opportunities.schema.js";
+import "../../model/index.js";
+import { countPaths, diffObjects, toCompareCounts, union } from "./fieldDiff.js";
+import { compileCompareRules, makeTagDiff } from "./compareRules.js";
+//#region src/dev/mode-parity/compareOpportunities.ts
+const tagDiff = makeTagDiff({
+	pool: compileCompareRules(poolOpportunitySchema),
+	strategy: compileCompareRules(strategyOpportunitySchema)
+});
 /**
 * Matches two opportunity listings by {@link opportunityId} and reports every
 * field the two sources disagree on.
@@ -79,47 +85,6 @@ function toRef(row) {
 function diffOpportunity(onchain, offchain) {
 	return 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 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),
@@ -128,7 +93,10 @@ function summarize(onchain, offchain, onlyOnchain, onlyOffchain, matched) {
 	return {
 		...toCompareCounts(onchain.length, offchain.length, onlyOnchain.length, onlyOffchain.length, matched),
 		byChain,
-		diffsByPath: countPaths(matched.flatMap((match) => match.diffs))
+		diffsByPath: countPaths(matched.flatMap((match) => match.diffs.map((diff) => ({
+			id: match.id,
+			diff
+		}))))
 	};
 }
 //#endregion

package/dist/esm/dev/{comparePositions.js → mode-parity/comparePositions.js}

@@ -1,7 +1,15 @@
-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
+import { liquidationPositionSchema } from "../../model/liquidations.schema.js";
+import { positionId } from "../../model/positions.js";
+import { poolPositionSchema, strategyPositionSchema } from "../../model/positions.schema.js";
+import "../../model/index.js";
+import { countPaths, diffObjects, isRecord, toCompareCounts, union } from "./fieldDiff.js";
+import { compileCompareRules, makeTagDiff } from "./compareRules.js";
+//#region src/dev/mode-parity/comparePositions.ts
+const tagDiff = makeTagDiff({
+	pool: compileCompareRules(poolPositionSchema),
+	strategy: compileCompareRules(strategyPositionSchema),
+	liquidation: compileCompareRules(liquidationPositionSchema)
+});
 /**
 * Matches two position listings per wallet by {@link positionId} and reports
 * every field the two sources disagree on.
@@ -104,40 +112,6 @@ function keyOfPositionArray(path, value) {
 	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);
@@ -162,7 +136,10 @@ function summarize(inputs, wallets, failed) {
 		walletsFailed: failed,
 		byChain,
 		byWallet,
-		diffsByPath: countPaths(matched.flatMap((match) => match.diffs))
+		diffsByPath: countPaths(matched.flatMap((match) => match.diffs.map((diff) => ({
+			id: match.id,
+			diff
+		}))))
 	};
 }
 /**

package/dist/esm/dev/mode-parity/compareRules.js

@@ -0,0 +1,91 @@
+import { compareTagOf } from "../../model/compare.schema.js";
+import { USD_RELATIVE_EPSILON, asFiniteNumber, collapseArrayKeys, isAmountWithinTolerance, isBpsWithinTolerance, isUsdWithinTolerance, withExpected, withinRelative } from "./fieldDiff.js";
+//#region src/dev/mode-parity/compareRules.ts
+/**
+* Walks a schema and records every field that carries compare metadata.
+*
+* `"amount"` on an object (an Amount / TokenAmount) is stored
+* at `<path>.value`; every other tag is stored at the field's own path.
+**/
+function compileCompareRules(schema) {
+	const rules = /* @__PURE__ */ new Map();
+	walk(schema, "", /* @__PURE__ */ new Set(), rules);
+	return rules;
+}
+/**
+* Tags diffs using the rules compiled for each row kind.
+*
+* Mode tags match the path or anything nested under it. Tolerance tags match
+* the path exactly and dispatch on {@link CompareTolerance}.
+**/
+function makeTagDiff(rulesByKind) {
+	return (diff, kind) => {
+		const rules = rulesByKind[kind];
+		if (!rules) return diff;
+		const path = collapseArrayKeys(diff.path);
+		if (isModeScoped(path, rules)) return withExpected(diff, "mode-scoped");
+		const tag = rules.get(path);
+		if (tag && typeof tag === "object" && withinTolerance(tag.tolerance, diff)) return withExpected(diff, "tolerance");
+		return diff;
+	};
+}
+function isModeScoped(path, rules) {
+	for (const [rulePath, tag] of rules) {
+		if (tag !== "offchainOnly" && tag !== "onchainOnly") continue;
+		if (path === rulePath || path.startsWith(`${rulePath}.`) || path.startsWith(`${rulePath}[`)) return true;
+	}
+	return false;
+}
+function withinTolerance(kind, diff) {
+	switch (kind) {
+		case "usd": return isUsdWithinTolerance(diff.onchain, diff.offchain);
+		case "bps": return isBpsWithinTolerance(diff.onchain, diff.offchain);
+		case "amount": return isAmountWithinTolerance(diff.onchain, diff.offchain);
+		case "float": return withinRelative(asFiniteNumber(diff.onchain), asFiniteNumber(diff.offchain), USD_RELATIVE_EPSILON);
+	}
+}
+function walk(schema, path, seen, rules) {
+	if (seen.has(schema)) return;
+	const nextSeen = new Set(seen);
+	nextSeen.add(schema);
+	const tag = compareTagOf(schema);
+	if (tag) record(path, tag, schema, rules);
+	const def = schema.def;
+	switch (def.type) {
+		case "optional":
+		case "nullable":
+		case "default":
+		case "prefault":
+		case "readonly":
+			if (def.innerType) walk(def.innerType, path, nextSeen, rules);
+			return;
+		case "array":
+			if (def.element) walk(def.element, `${path}[]`, nextSeen, rules);
+			return;
+		case "object":
+			if (def.shape) for (const [key, field] of Object.entries(def.shape)) walk(field, join(path, key), nextSeen, rules);
+			return;
+		case "union":
+			for (const option of def.options ?? []) walk(option, path, nextSeen, rules);
+			return;
+		case "pipe":
+			if (def.out) walk(def.out, path, nextSeen, rules);
+			return;
+		case "lazy":
+			if (def.getter) walk(def.getter(), path, nextSeen, rules);
+			return;
+		default: return;
+	}
+}
+function record(path, tag, schema, rules) {
+	if (typeof tag === "object" && tag.tolerance === "amount" && schema.def.type === "object") {
+		rules.set(join(path, "value"), tag);
+		return;
+	}
+	rules.set(path, tag);
+}
+function join(path, key) {
+	return path ? `${path}.${key}` : key;
+}
+//#endregion
+export { compileCompareRules, makeTagDiff };

package/dist/esm/dev/{fieldDiff.js → mode-parity/fieldDiff.js}

@@ -1,4 +1,4 @@
-//#region src/dev/fieldDiff.ts
+//#region src/dev/mode-parity/fieldDiff.ts
 /**
 * Relative drift allowed on {@link Amount.valueUsd} before a USD float is a
 * real disagreement: 0.1%.
@@ -69,7 +69,7 @@ function withExpected(diff, reason) {
 **/
 function countPaths(diffs) {
 	const counts = /* @__PURE__ */ new Map();
-	for (const diff of diffs) {
+	for (const { id, diff } of diffs) {
 		const path = collapseArrayKeys(diff.path);
 		const entry = counts.get(path) ?? {
 			path,
@@ -82,10 +82,31 @@ function countPaths(diffs) {
 		if (diff.expected) entry.expected += 1;
 		else entry.unexpected += 1;
 		if (!entry.kinds.includes(diff.kind)) entry.kinds.push(diff.kind);
+		recordWorst(entry, id, diff);
 		counts.set(path, entry);
 	}
 	return [...counts.values()].sort((a, b) => b.unexpected - a.unexpected || b.count - a.count || a.path.localeCompare(b.path));
 }
+function recordWorst(entry, id, diff) {
+	const bps = relativeDiffBps(diff.onchain, diff.offchain);
+	if (bps === void 0) return;
+	const worst = {
+		id,
+		path: diff.path,
+		bps,
+		onchain: diff.onchain,
+		offchain: diff.offchain
+	};
+	if (diff.expected) {
+		if (isWorse(worst, entry.worstExpected)) entry.worstExpected = worst;
+		return;
+	}
+	if (isWorse(worst, entry.worstUnexpected)) entry.worstUnexpected = worst;
+}
+function isWorse(candidate, current) {
+	if (!current) return true;
+	return candidate.bps > current.bps || candidate.bps === current.bps && candidate.id.localeCompare(current.id) < 0;
+}
 /**
 * Collapse `collateralTokens[0xa0b8...].symbol` to `collateralTokens[].symbol`.
 **/
@@ -151,6 +172,31 @@ function withinRelativeBigint(onchain, offchain, epsilon) {
 function asFiniteNumber(value) {
 	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
+/**
+* Relative difference of two numbers or bigints, in bps:
+* `|a − b| / max(|a|, |b|) * 10_000`. `undefined` when the values are not
+* a comparable pair of finite numbers or of bigints.
+**/
+function relativeDiffBps(onchain, offchain) {
+	if (typeof onchain === "bigint" && typeof offchain === "bigint") return relativeDiffBpsBigint(onchain, offchain);
+	const left = asFiniteNumber(onchain);
+	const right = asFiniteNumber(offchain);
+	if (left === void 0 || right === void 0) return;
+	const scale = Math.max(Math.abs(left), Math.abs(right));
+	return scale === 0 ? 0 : Math.abs(left - right) / scale * 1e4;
+}
+/**
+* Same formula as {@link relativeDiffBps} for bigints, computed in integer
+* arithmetic to milli-bps so a 1e18-scale amount does not round through
+* `Number`.
+**/
+function relativeDiffBpsBigint(onchain, offchain) {
+	if (onchain === offchain) return 0;
+	const diff = onchain > offchain ? onchain - offchain : offchain - onchain;
+	const scale = abs(onchain) > abs(offchain) ? abs(onchain) : abs(offchain);
+	if (scale === 0n) return 0;
+	return Number(diff * 10000n * 1000n / scale) / 1e3;
+}
 function union(left, right) {
 	return [.../* @__PURE__ */ new Set([...left, ...right])];
 }
@@ -221,4 +267,4 @@ 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 };
+export { AMOUNT_RELATIVE_EPSILON, BPS_ABSOLUTE_EPSILON, USD_RELATIVE_EPSILON, asFiniteNumber, collapseArrayKeys, countPaths, diffObjects, diffValue, isAmountWithinTolerance, isBpsWithinTolerance, isRecord, isUsdWithinTolerance, relativeDiffBps, toCompareCounts, union, withExpected, withinRelative, withinRelativeBigint };