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

package/dist/esm/dev/compareOpportunities.js

@@ -1,216 +0,0 @@
-import { opportunityId } from "../model/opportunities.js";
-import "../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) => [opportunityId(row), row]));
-}
-function byId(refs) {
-	refs.sort((a, b) => a.id.localeCompare(b.id));
-}
-function toRef(row) {
-	const base = {
-		id: 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
-export { compareOpportunities, diffOpportunity };