@gearbox-protocol/sdk 15.1.0-next.9 → 16.0.0-next.2

package/dist/cjs/dev/mode-parity/fieldDiff.js

@@ -0,0 +1,288 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/dev/mode-parity/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 { id, 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);
+		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`.
+**/
+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;
+}
+/**
+* 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])];
+}
+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
+exports.AMOUNT_RELATIVE_EPSILON = AMOUNT_RELATIVE_EPSILON;
+exports.BPS_ABSOLUTE_EPSILON = BPS_ABSOLUTE_EPSILON;
+exports.USD_RELATIVE_EPSILON = USD_RELATIVE_EPSILON;
+exports.asFiniteNumber = asFiniteNumber;
+exports.collapseArrayKeys = collapseArrayKeys;
+exports.countPaths = countPaths;
+exports.diffObjects = diffObjects;
+exports.diffValue = diffValue;
+exports.isAmountWithinTolerance = isAmountWithinTolerance;
+exports.isBpsWithinTolerance = isBpsWithinTolerance;
+exports.isRecord = isRecord;
+exports.isUsdWithinTolerance = isUsdWithinTolerance;
+exports.relativeDiffBps = relativeDiffBps;
+exports.toCompareCounts = toCompareCounts;
+exports.union = union;
+exports.withExpected = withExpected;
+exports.withinRelative = withinRelative;
+exports.withinRelativeBigint = withinRelativeBigint;

package/dist/cjs/dev/mode-parity/scriptUtils.js

@@ -0,0 +1,131 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_dev_providers = require("../providers.js");
+let pino = require("pino");
+//#region src/dev/mode-parity/scriptUtils.ts
+const NETWORKS = [
+	"Mainnet",
+	"Monad",
+	"Plasma",
+	"Somnia",
+	"Etherlink"
+];
+const BACKEND_URL = process.env.BACKEND_URL ?? "https://api.gear-dev.dev";
+const TIMEOUT = 48e4;
+function requireEnv(name) {
+	const value = process.env[name];
+	if (!value) throw new Error(`${name} is required to reach the chains this script reads`);
+	return value;
+}
+function rpcUrls() {
+	const alchemyKey = requireEnv("ALCHEMY_KEY");
+	const alchemy = (network) => {
+		const url = require_dev_providers.getAlchemyUrl(network, alchemyKey);
+		if (!url) throw new Error(`Alchemy serves no URL for ${network}`);
+		return url;
+	};
+	return {
+		Mainnet: alchemy("Mainnet"),
+		Monad: alchemy("Monad"),
+		Plasma: alchemy("Plasma"),
+		Somnia: requireEnv("SOMNIA_PROVIDER"),
+		Etherlink: requireEnv("ETHERLINK_PROVIDER")
+	};
+}
+function createLogger() {
+	return (0, pino.pino)({
+		level: process.env.LOG_LEVEL ?? "info",
+		formatters: {
+			bindings: () => ({}),
+			level: (label) => ({ level: label })
+		}
+	});
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/**
+* Runs `fn` over `items` with at most `concurrency` in flight.
+**/
+async function mapPool(items, concurrency, fn) {
+	let next = 0;
+	const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+		while (true) {
+			const index = next;
+			next += 1;
+			if (index >= items.length) return;
+			await fn(items[index]);
+		}
+	});
+	await Promise.all(workers);
+}
+/**
+* Formats a relative difference in bps as a percent, e.g. 12.5 → `"0.125%"`.
+**/
+function formatBpsAsPercent(bps) {
+	if (!Number.isFinite(bps)) return "";
+	const percent = bps / 100;
+	if (percent === 0) return "0%";
+	return `${Math.abs(percent) >= 1 ? trimTrailingZeros(percent.toFixed(3)) : trimTrailingZeros(percent.toPrecision(4))}%`;
+}
+function trimTrailingZeros(value) {
+	return value.includes(".") ? value.replace(/\.?0+$/, "") : value;
+}
+function worstColumns(worst) {
+	return {
+		"max diff": worst ? formatBpsAsPercent(worst.bps) : "",
+		"worst entity": worst?.id ?? ""
+	};
+}
+/**
+* Prints the shared membership table, the fields that differed most often,
+* and any chain that failed to answer.
+**/
+function printCompareSummary(noun, report, extraLines = []) {
+	const { summary } = report;
+	console.log(`\n${noun} from ${report.backendUrl} vs the chain`);
+	console.table(summary.byChain.map((chain) => ({
+		chain: chain.chainId,
+		onchain: chain.onchainRows,
+		offchain: chain.offchainRows,
+		matched: chain.matched,
+		identical: chain.identical,
+		clean: chain.clean,
+		differing: chain.differing,
+		"only onchain": chain.onlyOnchain,
+		"only offchain": chain.onlyOffchain
+	})));
+	for (const line of extraLines) console.log(line);
+	const unexpected = summary.diffsByPath.filter((entry) => entry.unexpected > 0);
+	const expected = summary.diffsByPath.filter((entry) => entry.unexpected === 0 && entry.expected > 0);
+	if (unexpected.length) {
+		console.log("\nunexpected fields that differed most often:");
+		console.table(unexpected.slice(0, 25).map((entry) => ({
+			field: entry.path,
+			unexpected: entry.unexpected,
+			expected: entry.expected,
+			kinds: entry.kinds.join(", "),
+			...worstColumns(entry.worstUnexpected)
+		})));
+	}
+	if (expected.length) {
+		console.log("\nexpected fields (mode-scoped or within tolerance):");
+		console.table(expected.slice(0, 25).map((entry) => ({
+			field: entry.path,
+			rows: entry.expected,
+			kinds: entry.kinds.join(", "),
+			...worstColumns(entry.worstExpected)
+		})));
+	}
+	for (const chain of [...report.onchainChains, ...report.offchainChains]) if (chain.status === "error") console.log(`chain ${chain.chainId} failed on ${chain.source}:`, chain.error);
+}
+//#endregion
+exports.BACKEND_URL = BACKEND_URL;
+exports.NETWORKS = NETWORKS;
+exports.TIMEOUT = TIMEOUT;
+exports.createLogger = createLogger;
+exports.errorMessage = errorMessage;
+exports.formatBpsAsPercent = formatBpsAsPercent;
+exports.mapPool = mapPool;
+exports.printCompareSummary = printCompareSummary;
+exports.requireEnv = requireEnv;
+exports.rpcUrls = rpcUrls;

package/dist/cjs/history/assembleOperations.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_plugins_adapters_contracts_AbstractAdapter = require("../plugins/adapters/contracts/AbstractAdapter.js");
-require("../plugins/adapters/index.js");
+const require_sdk_market_adapters_contracts_AbstractAdapter = require("../sdk/market/adapters/contracts/AbstractAdapter.js");
+require("../sdk/index.js");
 const require_preview_trace_extractAdapterCallTraces = require("../preview/trace/extractAdapterCallTraces.js");
 require("../preview/trace/index.js");
 const require_history_classifyMulticallOperations = require("./classifyMulticallOperations.js");
@@ -73,7 +73,7 @@ function assembleOperations(input) {
 function countAdapterCalls(innerCalls, register) {
 	return innerCalls.filter((call) => {
 		const contract = register.getContract(call.target);
-		return !contract || contract instanceof require_plugins_adapters_contracts_AbstractAdapter.AbstractAdapterContract;
+		return !contract || contract instanceof require_sdk_market_adapters_contracts_AbstractAdapter.AbstractAdapterContract;
 	}).length;
 }
 function countWithdrawCollateralCalls(innerCalls) {

package/dist/cjs/history/classifyMulticallOperations.js

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_plugins_adapters_transferHelpers = require("../plugins/adapters/transferHelpers.js");
-const require_plugins_adapters_contracts_AbstractAdapter = require("../plugins/adapters/contracts/AbstractAdapter.js");
-require("../plugins/adapters/index.js");
+const require_sdk_market_adapters_transferHelpers = require("../sdk/market/adapters/transferHelpers.js");
+const require_sdk_market_adapters_contracts_AbstractAdapter = require("../sdk/market/adapters/contracts/AbstractAdapter.js");
+require("../sdk/index.js");
 const require_preview_trace_errors = require("../preview/trace/errors.js");
 require("../preview/trace/index.js");
 let viem = require("viem");
@@ -34,12 +34,12 @@ function classifyMulticallOperations(input) {
 	const result = [];
 	for (const call of innerCalls) {
 		const contract = register.getContract(call.target);
-		if (contract instanceof require_plugins_adapters_contracts_AbstractAdapter.AbstractAdapterContract) {
+		if (contract instanceof require_sdk_market_adapters_contracts_AbstractAdapter.AbstractAdapterContract) {
 			const idx = transferIdx++;
 			const transfers = executeTransfers[idx];
 			if (!transfers) throw new require_preview_trace_errors.TransferAlignmentError(executeTransfers.length, transferIdx);
 			const protocol = contract.parseProtocolCall(adapterTraces[idx], strict);
-			const legacy = contract.classifyLegacyOperation(call, require_plugins_adapters_transferHelpers.toNetTransfers(transfers, creditAccount));
+			const legacy = contract.classifyLegacyOperation(call, require_sdk_market_adapters_transferHelpers.toNetTransfers(transfers, creditAccount));
 			result.push({
 				operation: "Execute",
 				adapter: call.target,
@@ -63,7 +63,7 @@ function classifyMulticallOperations(input) {
 		if (strict) throw new require_preview_trace_errors.UnknownAdapterError(call.target);
 		const transfers = executeTransfers[transferIdx++];
 		if (!transfers) throw new require_preview_trace_errors.TransferAlignmentError(executeTransfers.length, transferIdx);
-		const netTransfers = require_plugins_adapters_transferHelpers.toNetTransfers(transfers, creditAccount);
+		const netTransfers = require_sdk_market_adapters_transferHelpers.toNetTransfers(transfers, creditAccount);
 		result.push({
 			operation: "Execute",
 			adapter: call.target,
@@ -77,7 +77,7 @@ function classifyMulticallOperations(input) {
 			transfers,
 			legacy: {
 				operation: "Swap",
-				...require_plugins_adapters_transferHelpers.swapFromTransfers(netTransfers)
+				...require_sdk_market_adapters_transferHelpers.swapFromTransfers(netTransfers)
 			}
 		});
 	}

package/dist/cjs/history/populateContractsRegister.js

@@ -3,10 +3,10 @@ const require_sdk_utils_bytes32ToString = require("../sdk/utils/bytes32ToString.
 const require_sdk_chain_chains = require("../sdk/chain/chains.js");
 const require_sdk_constants_versions = require("../sdk/constants/versions.js");
 const require_sdk_base_TokensMeta = require("../sdk/base/TokensMeta.js");
+const require_sdk_market_adapters_createAdapter = require("../sdk/market/adapters/createAdapter.js");
 const require_sdk_market_credit_CreditFacadeV310BaseContract = require("../sdk/market/credit/CreditFacadeV310BaseContract.js");
 const require_sdk_OnchainSDK = require("../sdk/OnchainSDK.js");
 require("../sdk/index.js");
-const require_plugins_adapters_createAdapter = require("../plugins/adapters/createAdapter.js");
 let viem = require("viem");
 //#region src/history/populateContractsRegister.ts
 function populateContractsRegister(options) {
@@ -22,7 +22,7 @@ function populateContractsRegister(options) {
 			version: d.version,
 			contractType
 		});
-		else if (contractType.startsWith("ADAPTER::")) require_plugins_adapters_createAdapter.createAdapter(sdk, { baseParams: {
+		else if (contractType.startsWith("ADAPTER::")) require_sdk_market_adapters_createAdapter.createAdapter(sdk, { baseParams: {
 			addr: d.address,
 			version: d.version,
 			contractType

package/dist/cjs/model/charts.js

@@ -29,11 +29,10 @@ const CHART_RANGES = [
 **/
 const POOL_OPPORTUNITY_CHART_METRICS = [
 	"depositApy",
-	"borrowApy",
+	"depositApyAvg7d",
 	"dieselRate",
 	"supplied",
-	"borrowed",
-	"availableLiquidity"
+	"borrowed"
 ];
 /**
 * Every metric a strategy opportunity can chart.
@@ -42,8 +41,10 @@ const POOL_OPPORTUNITY_CHART_METRICS = [
 * chart draws; the two USD series are the same prices quoted in dollars.
 **/
 const STRATEGY_OPPORTUNITY_CHART_METRICS = [
-	"netApy",
 	"borrowApy",
+	"borrowApyAvg7d",
+	"quotaRate",
+	"liquidationThreshold",
 	"collateralApy",
 	"tvl",
 	"collateralPrice",
@@ -54,42 +55,32 @@ const STRATEGY_OPPORTUNITY_CHART_METRICS = [
 * Every metric a pool position can chart.
 *
 * Nothing to do with {@link POOL_OPPORTUNITY_CHART_METRICS}: an opportunity charts what the
-* pool did, a position charts what one wallet's deposit did in it. `mwr` and
-* `twr` are cumulative returns since the position opened — money-weighted, so
-* sensitive to when deposits and withdrawals landed, and time-weighted, which
-* strips that timing out. Both are anchored at inception, so a narrow `range`
-* only zooms the visible slice and its first point is rarely zero.
+* pool did, a position charts what one wallet's deposit did in it. `mwr` is the
+* money-weighted return since the position opened, so it is sensitive to when
+* deposits and withdrawals landed. It is anchored at inception, so a narrow
+* `range` only zooms the visible slice and its first point is rarely zero.
 **/
 const POOL_POSITION_CHART_METRICS = [
-	"value",
 	"apy",
 	"pnl",
-	"mwr",
-	"twr",
-	"underlyingPrice"
+	"mwr"
 ];
 /**
 * Every metric a strategy position can chart.
 *
-* `twrApy` annualizes `twr` over the position's whole life; the two trailing
-* APYs annualize it over a fixed window instead, so they track the current pace
-* rather than the lifetime rate and are comparable across positions of
-* different ages.
+* `netApy7d` is the trailing seven-day net yield, so it tracks the position's
+* recent pace rather than its lifetime return and is comparable across
+* positions of different ages.
 **/
 const STRATEGY_POSITION_CHART_METRICS = [
-	"totalValueUsd",
 	"totalValueUnderlying",
 	"debt",
 	"healthFactor",
-	"leverage",
 	"borrowApy",
-	"underlyingPrice",
+	"borrowApyAvg7d",
 	"pnl",
 	"mwr",
-	"twr",
-	"twrApy",
-	"trailingApy7d",
-	"trailingApy30d"
+	"netApy7d"
 ];
 /**
 * Unit of every metric, the one place either side decides it.
@@ -100,31 +91,26 @@ const STRATEGY_POSITION_CHART_METRICS = [
 **/
 const CHART_METRIC_UNITS = {
 	depositApy: "bps",
+	depositApyAvg7d: "bps",
 	borrowApy: "bps",
-	netApy: "bps",
+	borrowApyAvg7d: "bps",
+	quotaRate: "bps",
+	liquidationThreshold: "bps",
 	collateralApy: "bps",
 	supplied: "token",
 	borrowed: "token",
-	availableLiquidity: "token",
 	tvl: "token",
 	dieselRate: "ratio",
 	collateralPrice: "ratio",
 	collateralUsdPrice: "usd",
 	underlyingUsdPrice: "usd",
-	value: "token",
 	apy: "bps",
 	pnl: "token",
 	mwr: "bps",
-	twr: "bps",
-	underlyingPrice: "usd",
-	totalValueUsd: "usd",
 	totalValueUnderlying: "token",
 	debt: "token",
 	healthFactor: "bps",
-	leverage: "scalar",
-	twrApy: "bps",
-	trailingApy7d: "bps",
-	trailingApy30d: "bps"
+	netApy7d: "bps"
 };
 /**
 * Reason a series could not be produced at all, which is not the same as a

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

@@ -0,0 +1,33 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/model/compare.schema.ts
+/**
+* Marks a field that only the backend fills.
+**/
+function offchainOnly(schema) {
+	return schema.meta({ compare: "offchainOnly" });
+}
+/**
+* Marks a field that only the chain fills.
+**/
+function onchainOnly(schema) {
+	return schema.meta({ compare: "onchainOnly" });
+}
+/**
+* Marks a numeric field whose two sources may drift within {@link kind}.
+**/
+function tolerance(schema, kind) {
+	return schema.meta({ compare: { tolerance: kind } });
+}
+/**
+* The compare tag registered on a schema, if any.
+**/
+function compareTagOf(schema) {
+	const meta = schema.meta();
+	if (!meta || !("compare" in meta)) return;
+	return meta.compare;
+}
+//#endregion
+exports.compareTagOf = compareTagOf;
+exports.offchainOnly = offchainOnly;
+exports.onchainOnly = onchainOnly;
+exports.tolerance = tolerance;

package/dist/cjs/model/curators.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/curators.schema.ts
 /**
@@ -31,7 +32,7 @@ const curatorNameSchema = zod_v4.z.enum([
 const curatorSchema = zod_v4.z.object({
 	address: require_sdk_utils_zod.ZodAddress(),
 	name: curatorNameSchema.optional(),
-	url: zod_v4.z.string().nullable()
+	url: require_model_compare_schema.offchainOnly(zod_v4.z.string().nullable())
 });
 //#endregion
 exports.curatorNameSchema = curatorNameSchema;