@gearbox-protocol/sdk 15.1.0-next.4 → 15.1.0-next.5

package/dist/cjs/dev/compareOpportunities.js

@@ -0,0 +1,218 @@
+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;

package/dist/cjs/sdk/market/credit/CreditSuite.js

@@ -249,7 +249,7 @@ var CreditSuite = class extends require_sdk_base_SDKConstruct.SDKConstruct {
 			curator: market.curator,
 			underlyingToken: market.underlyingToken,
 			totalBorrow: oracle.toAmount(pool.underlying, borrowed),
-			collateralTokens: market.collateralTokens,
+			collateralTokens: this.strategyCollaterals.map((t) => this.tokensMeta.mustGetToken(t)),
 			paused: this.isPaused,
 			rwa: market.rwa,
 			sunset: market.sunset || require_sdk_chain_chains.isSunsetStrategy(cm.address, collateral, this.sdk.networkType),

package/dist/esm/dev/compareOpportunities.js

@@ -0,0 +1,216 @@
+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 };

package/dist/esm/sdk/market/credit/CreditSuite.js

@@ -248,7 +248,7 @@ var CreditSuite = class extends SDKConstruct {
 			curator: market.curator,
 			underlyingToken: market.underlyingToken,
 			totalBorrow: oracle.toAmount(pool.underlying, borrowed),
-			collateralTokens: market.collateralTokens,
+			collateralTokens: this.strategyCollaterals.map((t) => this.tokensMeta.mustGetToken(t)),
 			paused: this.isPaused,
 			rwa: market.rwa,
 			sunset: market.sunset || isSunsetStrategy(cm.address, collateral, this.sdk.networkType),

package/dist/types/dev/compareOpportunities.d.ts

@@ -0,0 +1,153 @@
+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 { 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;
+}
+/**
+ * Enough of an opportunity to identify it in a report without carrying the
+ * whole row.
+ **/
+interface OpportunityRef {
+  id: OpportunityId;
+  kind: OpportunityKind;
+  chainId: ChainId;
+  name: string;
+  /**
+   * Set on a pool opportunity.
+   **/
+  pool?: Address;
+  /**
+   * Set on a strategy opportunity, together with {@link targetCollateral}.
+   **/
+  creditManager?: Address;
+  targetCollateral?: Address;
+}
+/**
+ * One opportunity both sources listed, and everything they disagree on.
+ **/
+interface OpportunityMatch {
+  id: OpportunityId;
+  kind: OpportunityKind;
+  chainId: ChainId;
+  /**
+   * Name each source gave the row, which is itself a frequent diff.
+   **/
+  onchainName: string;
+  offchainName: string;
+  identical: 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.
+ **/
+interface CompareSummary extends CompareCounts {
+  byChain: ChainCompareCounts[];
+  diffsByPath: DiffPathCount[];
+}
+/**
+ * Everything one comparison run produced, ready to be written out as JSON.
+ **/
+interface OpportunityCompareReport {
+  generatedAt: string;
+  backendUrl: string;
+  networks: string[];
+  /**
+   * Per-chain metadata of the on-chain read, which says which block each chain
+   * answered from.
+   **/
+  onchainChains: ChainMetadata[];
+  /**
+   * Per-chain metadata of the backend read, see {@link onchainChains}.
+   **/
+  offchainChains: ChainMetadata[];
+  summary: CompareSummary;
+  onlyOnchain: OpportunityRef[];
+  onlyOffchain: OpportunityRef[];
+  matched: OpportunityMatch[];
+}
+/**
+ * The two listings to compare, plus what the run was pointed at.
+ **/
+interface CompareOpportunitiesInput {
+  onchain: DataResponse<Opportunity[]>;
+  offchain: DataResponse<Opportunity[]>;
+  backendUrl: string;
+  networks: string[];
+  /**
+   * ISO timestamp stamped onto the report, defaulting to now. Pinned by tests.
+   **/
+  generatedAt?: string;
+}
+/**
+ * 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.
+ **/
+declare function compareOpportunities(input: CompareOpportunitiesInput): OpportunityCompareReport;
+/**
+ * Every field two versions of one opportunity disagree on.
+ **/
+declare function diffOpportunity(onchain: Opportunity, offchain: Opportunity): FieldDiff[];
+//#endregion
+export { ChainCompareCounts, CompareCounts, CompareOpportunitiesInput, CompareSummary, DiffKind, DiffPathCount, FieldDiff, OpportunityCompareReport, OpportunityMatch, OpportunityRef, compareOpportunities, diffOpportunity };

package/package.json

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