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

package/dist/esm/model/index.js

@@ -1,4 +1,5 @@
 import { CHART_METRIC_UNITS, CHART_RANGES, CHART_UNAVAILABLE_CODES, POOL_OPPORTUNITY_CHART_METRICS, POOL_POSITION_CHART_METRICS, STRATEGY_OPPORTUNITY_CHART_METRICS, STRATEGY_POSITION_CHART_METRICS } from "./charts.js";
+import { compareTagOf, offchainOnly, onchainOnly, tolerance } from "./compare.schema.js";
 import { amountSchema, assetTypeSchema, bpsSchema, chainIdSchema, leverageSchema, timestampSchema, tokenAmountSchema, tokenSchema, txCallSchema } from "./primitives.schema.js";
 import { chartBundleSchemaFor, chartDenominationSchema, chartMetricSchema, chartQueryCodec, chartQueryParamsSchema, chartQuerySchema, chartRangeSchema, chartSeriesSchema, chartValueSchema, chartWindowSchema, poolOpportunityChartMetricSchema, poolPositionChartMetricSchema, strategyOpportunityChartMetricSchema, strategyPositionChartMetricSchema } from "./charts.schema.js";
 import "./curators.js";
@@ -16,4 +17,4 @@ import { borrowRateBreakdownSchema, pnlBreakdownSchema, pointsProgramPnLSchema,
 import "./primitives.js";
 import "./response.js";
 import { chainFailedSchema, chainMetadataSchema, chainSucceededSchema, dataSourceSchema, responseMetadataSchema, responseSchema } from "./response.schema.js";
-export { CHART_METRIC_UNITS, CHART_RANGES, CHART_UNAVAILABLE_CODES, FILTER_ALL, POOL_OPPORTUNITY_CHART_METRICS, POOL_POSITION_CHART_METRICS, STRATEGY_OPPORTUNITY_CHART_METRICS, STRATEGY_POSITION_CHART_METRICS, amountSchema, apyBreakdownSchema, assetTypeSchema, booleanParamSchema, borrowRateBreakdownSchema, bpsSchema, chainFailedSchema, chainIdSchema, chainMetadataSchema, chainSucceededSchema, chartBundleSchemaFor, chartDenominationSchema, chartMetricSchema, chartQueryCodec, chartQueryParamsSchema, chartQuerySchema, chartRangeSchema, chartSeriesSchema, chartValueSchema, chartWindowSchema, curatorNameSchema, curatorSchema, dataSourceSchema, delayedReceivedAssetSchema, encodeFlag, filterAllSchema, filterable, instantReceivedAssetSchema, isFilterSet, leverageSchema, liquidatableAccountFilterSchema, liquidatableAccountSchema, liquidationApprovalSchema, liquidationDetailsSchema, liquidationPositionId, liquidationPositionSchema, matchesLiquidatableAccountFilter, matchesOpportunityFilter, matchesPositionFilter, noticeKindSchema, noticeSchema, opportunityBaseSchema, opportunityDetailSchema, opportunityFilterQueryParamsSchema, opportunityFilterQuerySchema, opportunityFilterSchema, opportunityId, opportunityKeySchema, opportunityKindSchema, opportunitySchema, pnlBreakdownSchema, pointRewardsSchema, pointsProgramPnLSchema, pointsProgramSchema, pointsRewardsPnLSchema, poolOpportunityChartMetricSchema, poolOpportunityDetailSchema, poolOpportunityId, poolOpportunityKeySchema, poolOpportunitySchema, poolPositionChartMetricSchema, poolPositionId, poolPositionKeySchema, poolPositionSchema, positionCollateralSchema, positionFilterQueryParamsSchema, positionFilterQuerySchema, positionFilterSchema, positionId, positionKeySchema, positionKindSchema, positionSchema, positionTransactionKindSchema, positionTransactionSchema, positionsTotalsSchema, priceFeedDataSchema, priceFeedSummarySchema, quotaAssetSchema, rateCurvePointSchema, rateCurveSchema, receivedAssetSchema, responseMetadataSchema, responseSchema, rewardsPnLSchema, rewardsSchema, strategyOpportunityChartMetricSchema, strategyOpportunityDetailSchema, strategyOpportunityId, strategyOpportunityKeySchema, strategyOpportunitySchema, strategyPositionChartMetricSchema, strategyPositionId, strategyPositionKeySchema, strategyPositionSchema, timestampSchema, tokenAmountSchema, tokenRewardsPnLSchema, tokenRewardsSchema, tokenSchema, txCallSchema };
+export { CHART_METRIC_UNITS, CHART_RANGES, CHART_UNAVAILABLE_CODES, FILTER_ALL, POOL_OPPORTUNITY_CHART_METRICS, POOL_POSITION_CHART_METRICS, STRATEGY_OPPORTUNITY_CHART_METRICS, STRATEGY_POSITION_CHART_METRICS, amountSchema, apyBreakdownSchema, assetTypeSchema, booleanParamSchema, borrowRateBreakdownSchema, bpsSchema, chainFailedSchema, chainIdSchema, chainMetadataSchema, chainSucceededSchema, chartBundleSchemaFor, chartDenominationSchema, chartMetricSchema, chartQueryCodec, chartQueryParamsSchema, chartQuerySchema, chartRangeSchema, chartSeriesSchema, chartValueSchema, chartWindowSchema, compareTagOf, curatorNameSchema, curatorSchema, dataSourceSchema, delayedReceivedAssetSchema, encodeFlag, filterAllSchema, filterable, instantReceivedAssetSchema, isFilterSet, leverageSchema, liquidatableAccountFilterSchema, liquidatableAccountSchema, liquidationApprovalSchema, liquidationDetailsSchema, liquidationPositionId, liquidationPositionSchema, matchesLiquidatableAccountFilter, matchesOpportunityFilter, matchesPositionFilter, noticeKindSchema, noticeSchema, offchainOnly, onchainOnly, opportunityBaseSchema, opportunityDetailSchema, opportunityFilterQueryParamsSchema, opportunityFilterQuerySchema, opportunityFilterSchema, opportunityId, opportunityKeySchema, opportunityKindSchema, opportunitySchema, pnlBreakdownSchema, pointRewardsSchema, pointsProgramPnLSchema, pointsProgramSchema, pointsRewardsPnLSchema, poolOpportunityChartMetricSchema, poolOpportunityDetailSchema, poolOpportunityId, poolOpportunityKeySchema, poolOpportunitySchema, poolPositionChartMetricSchema, poolPositionId, poolPositionKeySchema, poolPositionSchema, positionCollateralSchema, positionFilterQueryParamsSchema, positionFilterQuerySchema, positionFilterSchema, positionId, positionKeySchema, positionKindSchema, positionSchema, positionTransactionKindSchema, positionTransactionSchema, positionsTotalsSchema, priceFeedDataSchema, priceFeedSummarySchema, quotaAssetSchema, rateCurvePointSchema, rateCurveSchema, receivedAssetSchema, responseMetadataSchema, responseSchema, rewardsPnLSchema, rewardsSchema, strategyOpportunityChartMetricSchema, strategyOpportunityDetailSchema, strategyOpportunityId, strategyOpportunityKeySchema, strategyOpportunitySchema, strategyPositionChartMetricSchema, strategyPositionId, strategyPositionKeySchema, strategyPositionSchema, timestampSchema, tokenAmountSchema, tokenRewardsPnLSchema, tokenRewardsSchema, tokenSchema, tolerance, txCallSchema };

package/dist/esm/model/opportunities.schema.js

@@ -1,4 +1,5 @@
 import { ZodAddress } from "../sdk/utils/zod.js";
+import { offchainOnly, tolerance } from "./compare.schema.js";
 import { amountSchema, assetTypeSchema, bpsSchema, chainIdSchema, leverageSchema, timestampSchema, tokenSchema } from "./primitives.schema.js";
 import { curatorSchema } from "./curators.schema.js";
 import { isFilterSet } from "./filters.js";
@@ -45,9 +46,9 @@ const rewardsSchema = z.discriminatedUnion("kind", [tokenRewardsSchema, pointRew
 * {@link ApyBreakdown}
 **/
 const apyBreakdownSchema = z.object({
-	totalApy: bpsSchema.optional(),
-	organicApy: bpsSchema,
-	rewards: z.array(rewardsSchema).optional()
+	totalApy: offchainOnly(bpsSchema).optional(),
+	organicApy: tolerance(bpsSchema, "bps"),
+	rewards: offchainOnly(z.array(rewardsSchema)).optional()
 });
 /**
 * {@link OpportunityBase}
@@ -70,9 +71,9 @@ const poolOpportunitySchema = z.object({
 	...opportunityBaseSchema.shape,
 	kind: z.literal("pool"),
 	pool: ZodAddress(),
-	totalSupply: amountSchema,
-	availableLiquidity: amountSchema,
-	utilization: bpsSchema,
+	totalSupply: tolerance(amountSchema, "amount"),
+	availableLiquidity: tolerance(amountSchema, "amount"),
+	utilization: tolerance(bpsSchema, "bps"),
 	supplyApy: apyBreakdownSchema
 });
 /**
@@ -87,12 +88,12 @@ const strategyOpportunitySchema = z.object({
 	liquidationPremium: bpsSchema,
 	liquidationFee: bpsSchema,
 	expirationDate: timestampSchema.nullable(),
-	collateralApy: apyBreakdownSchema.optional(),
-	maxLeverageApy: apyBreakdownSchema.optional(),
-	borrowApy: bpsSchema.optional(),
-	additionalBorrowApy: bpsSchema.optional(),
-	totalValue: amountSchema.optional(),
-	utilization: bpsSchema.optional(),
+	collateralApy: offchainOnly(apyBreakdownSchema).optional(),
+	maxLeverageApy: offchainOnly(apyBreakdownSchema).optional(),
+	borrowApy: tolerance(bpsSchema, "bps").optional(),
+	additionalBorrowApy: tolerance(bpsSchema, "bps").optional(),
+	totalValue: offchainOnly(amountSchema).optional(),
+	utilization: offchainOnly(bpsSchema).optional(),
 	maxBorrowAmount: amountSchema,
 	maxLeverage: leverageSchema
 });

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

@@ -1,4 +1,5 @@
 import { ZodAddress, ZodBigInt, ZodHex } from "../sdk/utils/zod.js";
+import { offchainOnly, onchainOnly, tolerance } from "./compare.schema.js";
 import { assetTypeSchema, bpsSchema, chainIdSchema, leverageSchema, timestampSchema, tokenAmountSchema, tokenSchema } from "./primitives.schema.js";
 import { isFilterSet } from "./filters.js";
 import { booleanParamSchema, encodeFlag, filterable } from "./filters.schema.js";
@@ -55,8 +56,8 @@ const pnlBreakdownSchema = z.object({
 * {@link PositionCollateral}
 **/
 const positionCollateralSchema = z.object({
-	collateral: tokenAmountSchema,
-	quota: tokenAmountSchema,
+	collateral: tolerance(tokenAmountSchema, "amount"),
+	quota: tolerance(tokenAmountSchema, "amount"),
 	withdrawals: z.array(delayedReceivedAssetSchema)
 });
 /**
@@ -67,9 +68,9 @@ const poolPositionSchema = z.object({
 	name: z.string(),
 	chainId: chainIdSchema,
 	pool: ZodAddress(),
-	netValue: tokenAmountSchema,
+	netValue: tolerance(tokenAmountSchema, "amount"),
 	apy: apyBreakdownSchema,
-	pnl: pnlBreakdownSchema.optional()
+	pnl: offchainOnly(pnlBreakdownSchema).optional()
 });
 /**
 * {@link BorrowRateBreakdown}
@@ -90,16 +91,16 @@ const strategyPositionSchema = z.object({
 	creditManager: ZodAddress(),
 	creditAccount: ZodAddress(),
 	targetCollateral: tokenSchema.nullable(),
-	leverage: leverageSchema,
-	borrowApy: bpsSchema,
-	netApy: apyBreakdownSchema.optional(),
-	totalDebt: tokenAmountSchema,
-	totalValue: tokenAmountSchema,
-	healthFactor: bpsSchema,
-	borrowRate: borrowRateBreakdownSchema.optional(),
-	timeToLiquidation: ZodBigInt().nullable().optional(),
-	liquidationPrice: ZodBigInt().nullable().optional(),
-	pnl: pnlBreakdownSchema.optional(),
+	leverage: tolerance(leverageSchema, "float"),
+	borrowApy: tolerance(bpsSchema, "bps"),
+	netApy: offchainOnly(apyBreakdownSchema).optional(),
+	totalDebt: tolerance(tokenAmountSchema, "amount"),
+	totalValue: tolerance(tokenAmountSchema, "amount"),
+	healthFactor: tolerance(bpsSchema, "bps"),
+	borrowRate: onchainOnly(borrowRateBreakdownSchema).optional(),
+	timeToLiquidation: onchainOnly(ZodBigInt().nullable()).optional(),
+	liquidationPrice: onchainOnly(ZodBigInt().nullable()).optional(),
+	pnl: offchainOnly(pnlBreakdownSchema).optional(),
 	collaterals: z.array(positionCollateralSchema)
 });
 /**

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

@@ -1,4 +1,5 @@
 import { ZodAddress, ZodBigInt, ZodHex } from "../sdk/utils/zod.js";
+import { tolerance } from "./compare.schema.js";
 import { z } from "zod/v4";
 //#region src/model/primitives.schema.ts
 /**
@@ -39,7 +40,7 @@ const leverageSchema = z.number().nonnegative();
 **/
 const amountSchema = z.object({
 	value: ZodBigInt(),
-	valueUsd: z.number().nullable()
+	valueUsd: tolerance(z.number().nullable(), "usd")
 });
 /**
 * {@link Token}

package/dist/esm/plugins/apy/ApyPlugin.js

@@ -1,5 +1,3 @@
-import { AxiosCache } from "../../common-utils/axios-cache/AxiosCache.js";
-import "../../common-utils/axios-cache/index.js";
 import { AddressMap } from "../../sdk/utils/AddressMap.js";
 import { AP_MARKET_COMPRESSOR } from "../../sdk/constants/address-provider.js";
 import { PERCENTAGE_DECIMALS } from "../../sdk/constants/math.js";
@@ -10,6 +8,8 @@ import { hexEq } from "../../sdk/utils/hex.js";
 import { marketCompressorAbi } from "../../abi/compressors/marketCompressor.js";
 import { BasePlugin } from "../../sdk/plugins/BasePlugin.js";
 import "../../sdk/index.js";
+import { AxiosCache } from "../../common-utils/axios-cache/AxiosCache.js";
+import "../../common-utils/axios-cache/index.js";
 import { getStrategyCreditManagersListCore } from "../../common-utils/utils/strategies/credit-managers/get-strategy-credit-managers-list-core.js";
 import { getAvailableAndDisabledStrategies } from "../../common-utils/utils/strategies/lists/get-available-and-disabled-strategies.js";
 import { getReleasedStrategiesListCore } from "../../common-utils/utils/strategies/lists/get-released-strategies-list-core.js";

package/dist/esm/sdk/market/math.js

@@ -23,8 +23,15 @@ function rayToBps(ray) {
 	return Number(ray * PERCENTAGE_FACTOR / RAY);
 }
 /**
+* Raw 8-decimal USD values below this are compressor leftover dust (typically
+* 1-wei balances on empty accounts) and report as `0`.
+**/
+const USD_DUST_THRESHOLD = 1000n;
+/**
 * Converts a USD value in the oracle's 8-decimal fixed point to a float.
 *
+* Values below {@link USD_DUST_THRESHOLD} report as `0`.
+*
 * @example
 * ```ts
 * // usd: $1500.50 in 8-decimal fixed point
@@ -32,7 +39,7 @@ function rayToBps(ray) {
 * ```
 **/
 function usdToNumber(usd) {
-	return Number(usd) / Number(PRICE_DECIMALS);
+	return usd < USD_DUST_THRESHOLD ? 0 : Number(usd) / Number(PRICE_DECIMALS);
 }
 /**
 * Share of capital currently borrowed, in basis points. Returns `0` when there

package/dist/esm/sdk/pools/PoolService.js

@@ -414,7 +414,7 @@ var PoolService = class extends SDKConstruct {
 		const { pool } = market.pool;
 		return {
 			kind: "pool",
-			name: market.poolName,
+			name: this.sdk.tokensMeta.mustGetToken(pool.address).name,
 			chainId: this.chainId,
 			pool: pool.address,
 			netValue: {

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

@@ -1,6 +1,7 @@
 import { AddressMap } from "../utils/AddressMap.js";
 import "../constants/math.js";
 import "../constants/index.js";
+import { hexEq } from "../utils/hex.js";
 import "../utils/index.js";
 import { SDKConstruct } from "../base/SDKConstruct.js";
 import "../base/index.js";
@@ -146,7 +147,11 @@ var PositionsService = class extends SDKConstruct {
 		const { pool } = market.pool;
 		const token = this.sdk.tokensMeta.mustGetToken(market.unwrappedUnderlying);
 		const totalDebtValue = ca.debt + ca.accruedInterest + ca.accruedFees;
-		const collateral = dominantCollateral(ca, market);
+		let collateral = dominantCollateral(ca, market);
+		if (collateral) {
+			const source = this.sdk.withdrawalCompressor?.getWithdrawalSourceToken(collateral);
+			if (source) collateral = hexEq(source, market.underlying) ? void 0 : source;
+		}
 		const snapshot = accountSnapshotFromCreditAccountData(ca);
 		const borrowRate = this.borrowRate(snapshot);
 		const timeToLiquidation = this.timeToLiquidation(snapshot);

package/dist/types/dev/{compareOpportunities.d.ts → mode-parity/compareOpportunities.d.ts}

@@ -1,38 +1,10 @@
-import { ChainId } from "../model/primitives.js";
-import { Opportunity, OpportunityId, OpportunityKind } from "../model/opportunities.js";
-import { ChainMetadata, DataResponse } from "../model/response.js";
-import "../model/index.js";
+import { ChainId } from "../../model/primitives.js";
+import { Opportunity, OpportunityId, OpportunityKind } from "../../model/opportunities.js";
+import { ChainMetadata, DataResponse } from "../../model/response.js";
+import "../../model/index.js";
+import { ChainCompareCounts, CompareCounts, DiffKind, DiffPathCount, ExpectedDiffReason, FieldDiff } from "./fieldDiff.js";
 import { Address } from "viem";
-//#region src/dev/compareOpportunities.d.ts
-/**
- * What kind of disagreement a {@link FieldDiff} describes, so that a reader can
- * bucket the report without re-deriving it from the values.
- *
- * - `"presence"` — one side has no value at all (`undefined` or `null`).
- * - `"usd"` — an {@link Amount.valueUsd}, i.e. a price-derived float.
- * - `"numeric"` — any other number or bigint.
- * - `"other"` — everything else: strings, booleans, array shapes.
- **/
-type DiffKind = "presence" | "usd" | "numeric" | "other";
-/**
- * One field of one opportunity where the two sources disagree.
- **/
-interface FieldDiff {
-  /**
-   * Dotted path into the row, with array elements keyed by their own identity
-   * rather than by index, e.g. `collateralTokens[0xa0b8...].symbol`.
-   **/
-  path: string;
-  /**
-   * Value the chain reported, `undefined` when it has no such field.
-   **/
-  onchain: unknown;
-  /**
-   * Value the backend reported, see {@link onchain}.
-   **/
-  offchain: unknown;
-  kind: DiffKind;
-}
+//#region src/dev/mode-parity/compareOpportunities.d.ts
 /**
  * Enough of an opportunity to identify it in a report without carrying the
  * whole row.
@@ -64,36 +36,16 @@ interface OpportunityMatch {
    **/
   onchainName: string;
   offchainName: string;
+  /**
+   * No diffs at all, including the documented offchain-only ones.
+   **/
   identical: boolean;
+  /**
+   * No unexpected diffs: every disagreement is mode-scoped or within tolerance.
+   **/
+  clean: boolean;
   diffs: FieldDiff[];
 }
-/**
- * How often one field disagreed across all matched rows, with array keys
- * collapsed, e.g. `collateralTokens[].symbol`.
- **/
-interface DiffPathCount {
-  path: string;
-  kinds: DiffKind[];
-  count: number;
-}
-/**
- * Counts of one chain, or of the whole report when `chainId` is absent.
- **/
-interface CompareCounts {
-  onchainRows: number;
-  offchainRows: number;
-  matched: number;
-  identical: number;
-  differing: number;
-  onlyOnchain: number;
-  onlyOffchain: number;
-}
-/**
- * Counts of one chain.
- **/
-interface ChainCompareCounts extends CompareCounts {
-  chainId: ChainId;
-}
 /**
  * Totals of the comparison plus the fields that differed most often.
  **/
@@ -139,10 +91,10 @@ interface CompareOpportunitiesInput {
  * 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.
  **/
 declare function compareOpportunities(input: CompareOpportunitiesInput): OpportunityCompareReport;
 /**
@@ -150,4 +102,4 @@ declare function compareOpportunities(input: CompareOpportunitiesInput): Opportu
  **/
 declare function diffOpportunity(onchain: Opportunity, offchain: Opportunity): FieldDiff[];
 //#endregion
-export { ChainCompareCounts, CompareCounts, CompareOpportunitiesInput, CompareSummary, DiffKind, DiffPathCount, FieldDiff, OpportunityCompareReport, OpportunityMatch, OpportunityRef, compareOpportunities, diffOpportunity };
+export { type ChainCompareCounts, type CompareCounts, CompareOpportunitiesInput, CompareSummary, type DiffKind, type DiffPathCount, type ExpectedDiffReason, type FieldDiff, OpportunityCompareReport, OpportunityMatch, OpportunityRef, compareOpportunities, diffOpportunity };

package/dist/types/dev/mode-parity/comparePositions.d.ts

@@ -0,0 +1,149 @@
+import { ChainId } from "../../model/primitives.js";
+import { Position, PositionId, PositionKind } from "../../model/positions.js";
+import { ChainMetadata, DataResponse } from "../../model/response.js";
+import "../../model/index.js";
+import { ChainCompareCounts, CompareCounts, DiffPathCount, FieldDiff } from "./fieldDiff.js";
+import { Address } from "viem";
+//#region src/dev/mode-parity/comparePositions.d.ts
+/**
+ * Enough of a position to identify it in a report without carrying the whole
+ * row.
+ **/
+interface PositionRef {
+  id: PositionId;
+  kind: PositionKind;
+  chainId: ChainId;
+  name: string;
+  /**
+   * Set on a pool position.
+   **/
+  pool?: Address;
+  /**
+   * Set on a strategy position.
+   **/
+  creditAccount?: Address;
+  creditManager?: Address;
+}
+/**
+ * One position both sources listed for a wallet, and everything they disagree
+ * on.
+ **/
+interface PositionMatch {
+  id: PositionId;
+  kind: PositionKind;
+  chainId: ChainId;
+  onchainName: string;
+  offchainName: string;
+  /**
+   * No diffs at all, including the documented mode-scoped ones.
+   **/
+  identical: boolean;
+  /**
+   * No unexpected diffs: every disagreement is mode-scoped or within tolerance.
+   **/
+  clean: boolean;
+  diffs: FieldDiff[];
+}
+/**
+ * One wallet's comparison, or the error that stopped it.
+ **/
+interface WalletComparison {
+  wallet: Address;
+  /**
+   * Why both listings of this wallet could not be read. When set, the rest of
+   * the fields are empty.
+   **/
+  error?: string;
+  onlyOnchain: PositionRef[];
+  onlyOffchain: PositionRef[];
+  matched: PositionMatch[];
+}
+/**
+ * Counts of one wallet.
+ **/
+interface WalletCompareCounts extends CompareCounts {
+  wallet: Address;
+  /**
+   * Present when the wallet's listings could not be read.
+   **/
+  error?: string;
+}
+/**
+ * Totals of the comparison plus the fields that differed most often.
+ **/
+interface PositionsCompareSummary extends CompareCounts {
+  wallets: number;
+  /**
+   * Wallets whose listings were read and that have no membership gaps and no
+   * unexpected field diffs.
+   **/
+  walletsClean: number;
+  walletsFailed: number;
+  byChain: ChainCompareCounts[];
+  byWallet: WalletCompareCounts[];
+  diffsByPath: DiffPathCount[];
+}
+/**
+ * Everything one comparison run produced, ready to be written out as JSON.
+ **/
+interface PositionsCompareReport {
+  generatedAt: string;
+  backendUrl: string;
+  networks: string[];
+  /**
+   * Per-chain metadata collected from the on-chain reads, which says which
+   * block each chain answered from. Taken from the first successful wallet
+   * listing of each chain.
+   **/
+  onchainChains: ChainMetadata[];
+  /**
+   * Per-chain metadata of the backend reads, see {@link onchainChains}.
+   **/
+  offchainChains: ChainMetadata[];
+  summary: PositionsCompareSummary;
+  wallets: WalletComparison[];
+}
+/**
+ * Both listings of one wallet.
+ **/
+interface WalletPositions {
+  wallet: Address;
+  onchain: DataResponse<Position[]>;
+  offchain: DataResponse<Position[]>;
+}
+/**
+ * A wallet whose listings could not be read from one or both sources.
+ **/
+interface WalletPositionsFailure {
+  wallet: Address;
+  error: string;
+}
+/**
+ * The per-wallet listings to compare, plus what the run was pointed at.
+ **/
+interface ComparePositionsInput {
+  wallets: WalletPositions[];
+  failures?: WalletPositionsFailure[];
+  backendUrl: string;
+  networks: string[];
+  /**
+   * ISO timestamp stamped onto the report, defaulting to now. Pinned by tests.
+   **/
+  generatedAt?: string;
+}
+/**
+ * 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.
+ **/
+declare function comparePositions(input: ComparePositionsInput): PositionsCompareReport;
+/**
+ * Every field two versions of one position disagree on.
+ **/
+declare function diffPosition(onchain: Position, offchain: Position): FieldDiff[];
+//#endregion
+export { ComparePositionsInput, PositionMatch, PositionRef, PositionsCompareReport, PositionsCompareSummary, WalletCompareCounts, WalletComparison, WalletPositions, WalletPositionsFailure, comparePositions, diffPosition };

package/dist/types/dev/mode-parity/compareRules.d.ts

@@ -0,0 +1,33 @@
+import { CompareTag } from "../../model/compare.schema.js";
+import { FieldDiff } from "./fieldDiff.js";
+import { z } from "zod/v4";
+//#region src/dev/mode-parity/compareRules.d.ts
+/**
+ * Collapsed-path → tag map compiled from a zod schema, e.g.
+ * `apy.totalApy` → `"offchainOnly"`, `totalDebt.value` → `{ tolerance: amount }`.
+ **/
+type CompareRuleMap = Map<string, CompareTag>;
+/**
+ * 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.
+ **/
+declare function compileCompareRules(schema: z.ZodType): CompareRuleMap;
+/**
+ * Rules compiled for each row kind, e.g. `"pool"` vs `"strategy"`.
+ **/
+type CompareRulesByKind = Record<string, CompareRuleMap>;
+/**
+ * Tags one field diff using the rules compiled for its row kind.
+ **/
+type TagDiff = (diff: FieldDiff, kind: string) => FieldDiff;
+/**
+ * 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}.
+ **/
+declare function makeTagDiff(rulesByKind: CompareRulesByKind): TagDiff;
+//#endregion
+export { CompareRuleMap, CompareRulesByKind, TagDiff, compileCompareRules, makeTagDiff };