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

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

@@ -0,0 +1,209 @@
+import { ChainId } from "../../model/primitives.js";
+import "../../model/index.js";
+//#region src/dev/mode-parity/fieldDiff.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";
+/**
+ * Why a {@link FieldDiff} is expected rather than a real disagreement.
+ *
+ * - `"mode-scoped"` — a field documented `@mode offchain` or `@mode onchain`,
+ *   so the other source has nothing to put there.
+ * - `"tolerance"` — snapshot lag or float-path noise within the thresholds
+ *   below, not a formula or membership mismatch.
+ **/
+type ExpectedDiffReason = "mode-scoped" | "tolerance";
+/**
+ * One field of one row 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;
+  /**
+   * Present when this disagreement is documented or within snapshot-lag noise,
+   * so it does not keep the row from being counted as clean.
+   **/
+  expected?: true;
+  reason?: ExpectedDiffReason;
+}
+/**
+ * The largest numeric disagreement seen for one collapsed field path, on
+ * either the unexpected or the expected side.
+ **/
+interface WorstDiff {
+  /**
+   * Entity id (position/opportunity id) with the biggest relative difference.
+   **/
+  id: string;
+  /**
+   * Uncollapsed path, so the exact array element is named.
+   **/
+  path: string;
+  /**
+   * Relative difference in bps.
+   **/
+  bps: number;
+  onchain: unknown;
+  offchain: unknown;
+}
+/**
+ * One field disagreement together with the matched row it belongs to.
+ **/
+interface EntityFieldDiff {
+  id: string;
+  diff: 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;
+  expected: number;
+  unexpected: number;
+  /**
+   * Largest unexpected numeric disagreement, when any unexpected diff of this
+   * path yields a relative bps value.
+   **/
+  worstUnexpected?: WorstDiff;
+  /**
+   * Largest expected numeric disagreement, see {@link worstUnexpected}.
+   **/
+  worstExpected?: WorstDiff;
+}
+/**
+ * Counts of one chain, one wallet, or of the whole report when those ids are
+ * absent.
+ **/
+interface CompareCounts {
+  onchainRows: number;
+  offchainRows: number;
+  matched: number;
+  identical: number;
+  /**
+   * Matched rows with no unexpected diffs, including the identical ones.
+   **/
+  clean: number;
+  differing: number;
+  onlyOnchain: number;
+  onlyOffchain: number;
+}
+/**
+ * Counts of one chain.
+ **/
+interface ChainCompareCounts extends CompareCounts {
+  chainId: ChainId;
+}
+/**
+ * Identity of an array element, used so a token present on one side only is
+ * reported as such rather than shifting every later element into a diff.
+ *
+ * Return a string to key the element; `undefined` falls back to the default
+ * (`address`, `id`, `token`, or nested `token.address`).
+ **/
+type ArrayElementKey = (path: string, value: unknown) => string | undefined;
+/**
+ * How to walk two values. Callers that need identity-bearing arrays whose
+ * key is not one of the defaults pass {@link DiffOptions.keyOf}.
+ **/
+interface DiffOptions {
+  keyOf?: ArrayElementKey;
+}
+/**
+ * Relative drift allowed on {@link Amount.valueUsd} before a USD float is a
+ * real disagreement: 0.1%.
+ **/
+declare const USD_RELATIVE_EPSILON = 0.001;
+/**
+ * Relative drift allowed on lag-bounded bigint amounts: 0.05%.
+ **/
+declare const AMOUNT_RELATIVE_EPSILON = 0.0005;
+/**
+ * Absolute drift allowed on bps rates before rounding and a one-block lag are
+ * no longer enough to explain it.
+ **/
+declare 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.
+ **/
+declare function diffValue(path: string, onchain: unknown, offchain: unknown, out: FieldDiff[], options?: DiffOptions): void;
+/**
+ * Deep-diff two values and return the disagreements, in path order of
+ * discovery.
+ **/
+declare function diffObjects(onchain: unknown, offchain: unknown, options?: DiffOptions): FieldDiff[];
+/**
+ * Mark a diff expected, so a later `clean` count can ignore it.
+ **/
+declare function withExpected(diff: FieldDiff, reason: ExpectedDiffReason): FieldDiff;
+/**
+ * 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.
+ **/
+declare function countPaths(diffs: Iterable<EntityFieldDiff>): DiffPathCount[];
+/**
+ * Collapse `collateralTokens[0xa0b8...].symbol` to `collateralTokens[].symbol`.
+ **/
+declare function collapseArrayKeys(path: string): string;
+/**
+ * Membership and match totals of one comparison, from already-built lists.
+ **/
+declare function toCompareCounts(onchainRows: number, offchainRows: number, onlyOnchain: number, onlyOffchain: number, matched: ReadonlyArray<{
+  identical: boolean;
+  clean: boolean;
+}>): CompareCounts;
+/**
+ * USD floats within {@link USD_RELATIVE_EPSILON}.
+ **/
+declare function isUsdWithinTolerance(onchain: unknown, offchain: unknown): boolean;
+/**
+ * Bps rates that differ by at most {@link BPS_ABSOLUTE_EPSILON}.
+ **/
+declare function isBpsWithinTolerance(onchain: unknown, offchain: unknown): boolean;
+/**
+ * Bigint amounts within {@link AMOUNT_RELATIVE_EPSILON}.
+ **/
+declare function isAmountWithinTolerance(onchain: unknown, offchain: unknown): boolean;
+/**
+ * Finite numbers within a relative epsilon of each other.
+ **/
+declare function withinRelative(onchain: number | undefined, offchain: number | undefined, epsilon: number): boolean;
+/**
+ * `diff / max(|a|, |b|) <= epsilon`, computed in integer arithmetic so a
+ * 1e18-scale amount does not round through `Number`.
+ **/
+declare function withinRelativeBigint(onchain: bigint, offchain: bigint, epsilon: number): boolean;
+declare function asFiniteNumber(value: unknown): number | undefined;
+/**
+ * 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.
+ **/
+declare function relativeDiffBps(onchain: unknown, offchain: unknown): number | undefined;
+declare function union(left: string[], right: string[]): string[];
+declare function isRecord(value: unknown): value is Record<string, unknown>;
+//#endregion
+export { AMOUNT_RELATIVE_EPSILON, ArrayElementKey, BPS_ABSOLUTE_EPSILON, ChainCompareCounts, CompareCounts, DiffKind, DiffOptions, DiffPathCount, EntityFieldDiff, ExpectedDiffReason, FieldDiff, USD_RELATIVE_EPSILON, WorstDiff, asFiniteNumber, collapseArrayKeys, countPaths, diffObjects, diffValue, isAmountWithinTolerance, isBpsWithinTolerance, isRecord, isUsdWithinTolerance, relativeDiffBps, toCompareCounts, union, withExpected, withinRelative, withinRelativeBigint };

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

@@ -0,0 +1,47 @@
+import { ChainMetadata } from "../../model/response.js";
+import "../../model/index.js";
+import { ChainCompareCounts, CompareCounts, DiffPathCount } from "./fieldDiff.js";
+import { Logger } from "pino";
+//#region src/dev/mode-parity/scriptUtils.d.ts
+/**
+ * Chains the compare scripts attach to.
+ **/
+type ComparedNetwork = "Mainnet" | "Monad" | "Plasma" | "Somnia" | "Etherlink";
+declare const NETWORKS: ComparedNetwork[];
+declare const BACKEND_URL: string;
+declare const TIMEOUT = 480000;
+/**
+ * Totals both compare reports print.
+ **/
+interface PrintableCompareSummary extends CompareCounts {
+  byChain: ChainCompareCounts[];
+  diffsByPath: DiffPathCount[];
+}
+/**
+ * Per-source chain metadata both compare reports carry.
+ **/
+interface PrintableCompareReport {
+  backendUrl: string;
+  summary: PrintableCompareSummary;
+  onchainChains: ChainMetadata[];
+  offchainChains: ChainMetadata[];
+}
+declare function requireEnv(name: string): string;
+declare function rpcUrls(): Record<ComparedNetwork, string>;
+declare function createLogger(): Logger;
+declare function errorMessage(error: unknown): string;
+/**
+ * Runs `fn` over `items` with at most `concurrency` in flight.
+ **/
+declare function mapPool<T>(items: readonly T[], concurrency: number, fn: (item: T) => Promise<void>): Promise<void>;
+/**
+ * Formats a relative difference in bps as a percent, e.g. 12.5 → `"0.125%"`.
+ **/
+declare function formatBpsAsPercent(bps: number): string;
+/**
+ * Prints the shared membership table, the fields that differed most often,
+ * and any chain that failed to answer.
+ **/
+declare function printCompareSummary(noun: string, report: PrintableCompareReport, extraLines?: string[]): void;
+//#endregion
+export { BACKEND_URL, ComparedNetwork, NETWORKS, PrintableCompareReport, PrintableCompareSummary, TIMEOUT, createLogger, errorMessage, formatBpsAsPercent, mapPool, printCompareSummary, requireEnv, rpcUrls };

package/dist/types/model/compare.schema.d.ts

@@ -0,0 +1,47 @@
+import { z } from "zod/v4";
+//#region src/model/compare.schema.d.ts
+/**
+ * How close two numeric values may be before a disagreement counts as real.
+ *
+ * The compare scripts pick a formula from this union; the schemas only name
+ * which formula a field uses.
+ *
+ * - `"amount"` — accrual lag on an {@link Amount.value} / {@link TokenAmount.value}.
+ * - `"bps"` — truncation vs rounding on a basis-point rate, ±1.
+ * - `"float"` — relative float drift within 0.1% (leverage).
+ * - `"usd"` — price-derived {@link Amount.valueUsd} / {@link TokenAmount.valueUsd}.
+ **/
+type CompareTolerance = "amount" | "bps" | "float" | "usd";
+/**
+ * A numeric field whose two sources may drift within {@link tolerance}.
+ **/
+interface ToleranceCompareTag {
+  tolerance: CompareTolerance;
+}
+/**
+ * Compare metadata a schema field may carry.
+ *
+ * - `"offchainOnly"` / `"onchainOnly"` — the other source typically leaves
+ *   the field empty, so a disagreement is expected.
+ * - {@link ToleranceCompareTag} — a numeric disagreement within the named
+ *   formula is expected snapshot noise.
+ **/
+type CompareTag = "offchainOnly" | "onchainOnly" | ToleranceCompareTag;
+/**
+ * Marks a field that only the backend fills.
+ **/
+declare function offchainOnly<S extends z.ZodType>(schema: S): S;
+/**
+ * Marks a field that only the chain fills.
+ **/
+declare function onchainOnly<S extends z.ZodType>(schema: S): S;
+/**
+ * Marks a numeric field whose two sources may drift within {@link kind}.
+ **/
+declare function tolerance<S extends z.ZodType>(schema: S, kind: CompareTolerance): S;
+/**
+ * The compare tag registered on a schema, if any.
+ **/
+declare function compareTagOf(schema: z.ZodType): CompareTag | undefined;
+//#endregion
+export { CompareTag, CompareTolerance, ToleranceCompareTag, compareTagOf, offchainOnly, onchainOnly, tolerance };

package/dist/types/model/index.d.ts

@@ -2,6 +2,7 @@ import { Amount, AssetType, Bps, ChainId, Leverage, Timestamp, Token, TokenAmoun
 import { Curator, CuratorName } from "./curators.js";
 import { CHART_METRIC_UNITS, CHART_RANGES, CHART_UNAVAILABLE_CODES, ChartBundle, ChartDenomination, ChartMetric, ChartQuery, ChartRange, ChartSeries, ChartSeriesOk, ChartSeriesUnavailable, ChartUnavailableCode, ChartUnit, ChartValue, ChartWindow, GridSampling, OpportunityChartMetric, POOL_OPPORTUNITY_CHART_METRICS, POOL_POSITION_CHART_METRICS, PoolOpportunityChartMetric, PoolPositionChartMetric, PositionChartMetric, STRATEGY_OPPORTUNITY_CHART_METRICS, STRATEGY_POSITION_CHART_METRICS, StrategyOpportunityChartMetric, StrategyPositionChartMetric } from "./charts.js";
 import { chartBundleSchemaFor, chartDenominationSchema, chartMetricSchema, chartQueryCodec, chartQueryParamsSchema, chartQuerySchema, chartRangeSchema, chartSeriesSchema, chartValueSchema, chartWindowSchema, poolOpportunityChartMetricSchema, poolPositionChartMetricSchema, strategyOpportunityChartMetricSchema, strategyPositionChartMetricSchema } from "./charts.schema.js";
+import { CompareTag, CompareTolerance, ToleranceCompareTag, compareTagOf, offchainOnly, onchainOnly, tolerance } from "./compare.schema.js";
 import { curatorNameSchema, curatorSchema } from "./curators.schema.js";
 import { ChainScopedFilter, FILTER_ALL, FilterAll, Filterable, isFilterSet } from "./filters.js";
 import { booleanParamSchema, encodeFlag, filterAllSchema, filterable } from "./filters.schema.js";
@@ -16,4 +17,4 @@ import { borrowRateBreakdownSchema, pnlBreakdownSchema, pointsProgramPnLSchema,
 import { amountSchema, assetTypeSchema, bpsSchema, chainIdSchema, leverageSchema, timestampSchema, tokenAmountSchema, tokenSchema, txCallSchema } from "./primitives.schema.js";
 import { ChainFailed, ChainMetadata, ChainScoped, ChainSucceeded, DataResponse, DataSource, ResponseMetadata } from "./response.js";
 import { chainFailedSchema, chainMetadataSchema, chainSucceededSchema, dataSourceSchema, responseMetadataSchema, responseSchema } from "./response.schema.js";
-export { Amount, ApyBreakdown, AssetType, BorrowRateBreakdown, Bps, CHART_METRIC_UNITS, CHART_RANGES, CHART_UNAVAILABLE_CODES, ChainFailed, ChainId, ChainMetadata, ChainScoped, ChainScopedFilter, ChainSucceeded, ChartBundle, ChartDenomination, ChartMetric, ChartQuery, ChartRange, ChartSeries, ChartSeriesOk, ChartSeriesUnavailable, ChartUnavailableCode, ChartUnit, ChartValue, ChartWindow, Curator, CuratorName, DataResponse, DataSource, DelayedReceivedAsset, FILTER_ALL, FilterAll, Filterable, GridSampling, InstantReceivedAsset, Leverage, LiquidatableAccount, LiquidatableAccountFilter, LiquidationApproval, LiquidationDetails, LiquidationPosition, Notice, NoticeKind, NoticeSubject, Opportunity, OpportunityBase, OpportunityChartMetric, OpportunityDetail, OpportunityFilter, OpportunityId, OpportunityKey, OpportunityKind, POOL_OPPORTUNITY_CHART_METRICS, POOL_POSITION_CHART_METRICS, PnlBreakdown, PointRewards, PointsProgram, PointsProgramPnL, PointsRewardsPnL, PoolOpportunity, PoolOpportunityChartMetric, PoolOpportunityDetail, PoolOpportunityKey, PoolOpportunityRef, PoolPosition, PoolPositionChartMetric, PoolPositionKey, PoolPositionRef, Position, PositionChartMetric, PositionCollateral, PositionFilter, PositionId, PositionKey, PositionKind, PositionMetrics, PositionTransaction, PositionTransactionKind, PositionsTotals, PriceFeedData, PriceFeedSummary, QuotaAsset, RateCurve, RateCurvePoint, ReceivedAsset, ResponseMetadata, Rewards, RewardsPnL, STRATEGY_OPPORTUNITY_CHART_METRICS, STRATEGY_POSITION_CHART_METRICS, StrategyOpportunity, StrategyOpportunityChartMetric, StrategyOpportunityDetail, StrategyOpportunityKey, StrategyOpportunityRef, StrategyPosition, StrategyPositionChartMetric, StrategyPositionKey, StrategyPositionRef, Timestamp, Token, TokenAmount, TokenRewards, TokenRewardsPnL, TxCall, 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 { Amount, ApyBreakdown, AssetType, BorrowRateBreakdown, Bps, CHART_METRIC_UNITS, CHART_RANGES, CHART_UNAVAILABLE_CODES, ChainFailed, ChainId, ChainMetadata, ChainScoped, ChainScopedFilter, ChainSucceeded, ChartBundle, ChartDenomination, ChartMetric, ChartQuery, ChartRange, ChartSeries, ChartSeriesOk, ChartSeriesUnavailable, ChartUnavailableCode, ChartUnit, ChartValue, ChartWindow, CompareTag, CompareTolerance, Curator, CuratorName, DataResponse, DataSource, DelayedReceivedAsset, FILTER_ALL, FilterAll, Filterable, GridSampling, InstantReceivedAsset, Leverage, LiquidatableAccount, LiquidatableAccountFilter, LiquidationApproval, LiquidationDetails, LiquidationPosition, Notice, NoticeKind, NoticeSubject, Opportunity, OpportunityBase, OpportunityChartMetric, OpportunityDetail, OpportunityFilter, OpportunityId, OpportunityKey, OpportunityKind, POOL_OPPORTUNITY_CHART_METRICS, POOL_POSITION_CHART_METRICS, PnlBreakdown, PointRewards, PointsProgram, PointsProgramPnL, PointsRewardsPnL, PoolOpportunity, PoolOpportunityChartMetric, PoolOpportunityDetail, PoolOpportunityKey, PoolOpportunityRef, PoolPosition, PoolPositionChartMetric, PoolPositionKey, PoolPositionRef, Position, PositionChartMetric, PositionCollateral, PositionFilter, PositionId, PositionKey, PositionKind, PositionMetrics, PositionTransaction, PositionTransactionKind, PositionsTotals, PriceFeedData, PriceFeedSummary, QuotaAsset, RateCurve, RateCurvePoint, ReceivedAsset, ResponseMetadata, Rewards, RewardsPnL, STRATEGY_OPPORTUNITY_CHART_METRICS, STRATEGY_POSITION_CHART_METRICS, StrategyOpportunity, StrategyOpportunityChartMetric, StrategyOpportunityDetail, StrategyOpportunityKey, StrategyOpportunityRef, StrategyPosition, StrategyPositionChartMetric, StrategyPositionKey, StrategyPositionRef, Timestamp, Token, TokenAmount, TokenRewards, TokenRewardsPnL, ToleranceCompareTag, TxCall, 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/types/sdk/market/math.d.ts

@@ -15,6 +15,8 @@ declare function rayToBps(ray: bigint): Bps;
 /**
  * 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "15.1.0-next.10",
+  "version": "15.1.0-next.12",
   "description": "Gearbox SDK",
   "license": "MIT",
   "repository": {

package/dist/cjs/dev/compareOpportunities.js

@@ -1,218 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_model_opportunities = require("../model/opportunities.js");
-require("../model/index.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.
-**/
-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,
-			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) {
-	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)
-	});
-}
-/**
-* 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.
-**/
-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);
-}
-/**
-* 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(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;
-/**
-* 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 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))
-	})).sort((a, b) => a.chainId - b.chainId);
-	return {
-		...count(onchain, offchain, onlyOnchain, onlyOffchain, matched),
-		byChain,
-		diffsByPath: countPaths(matched)
-	};
-}
-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
-exports.compareOpportunities = compareOpportunities;
-exports.diffOpportunity = diffOpportunity;