@gearbox-protocol/sdk 16.0.0-next.8 → 16.0.0

package/dist/cjs/sdk/prepare/errors.js

@@ -0,0 +1,93 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/sdk/prepare/errors.ts
+/**
+* One sentence per refusal, naming what was ruled out rather than restating the
+* numbers the error already carries.
+*
+* English and loggable, not a string to put on a screen: a form renders the
+* code and the amounts in its own words, see {@link IGearboxError.message}.
+**/
+const MESSAGES = {
+	debtOutOfRange: "The debt this request implies is outside the market's band.",
+	leverageOutOfRange: "The leverage asked for cannot be expressed as a plan.",
+	insufficientSourceBalance: "Neither the account nor the wallet holds enough to fund this request.",
+	unsupportedCollateralToken: "This flow does not accept that token.",
+	unsupportedTokenPair: "No route exists between these two tokens.",
+	noDelayedRoute: "This request cannot be served as a delayed redemption.",
+	multipleDelayedWithdrawals: "The source asset has several redemption venues and none was named.",
+	withdrawalInProgress: "A redemption of this asset is already in flight on the account.",
+	noRecordedIntent: "The claim names no operation to resume.",
+	marketPaused: "The market is paused.",
+	marketExpired: "The market is past its expiration date.",
+	insufficientPoolLiquidity: "The pool cannot lend what this plan draws.",
+	quotaLimitReached: "The market takes no more quota for a token this plan holds.",
+	forbiddenToken: "This plan would increase the balance of a forbidden token.",
+	insufficientCollateral: "The account would end this transaction under-collateralised.",
+	poolSunset: "The pool is winding down and takes no more deposits.",
+	quotaCountExceeded: "The account would hold more quoted tokens than the facade enables at once.",
+	malformedTransaction: "The transaction could not be replayed."
+};
+/**
+* The engine's refusal, as the error the namespace answers with.
+*
+* One place does the lifting, so the two shapes cannot drift: `reason` becomes
+* `code`, the detail is spread onto the error, and the sentence comes from
+* {@link MESSAGES}. A malformed transaction is spelled out rather than spread,
+* because its detail names a `code` and a `message` of its own and they are not
+* the envelope's.
+*
+* Generic over the issue it is handed, so a call site that already knows the
+* reason gets that reason's error back rather than a union to narrow again.
+**/
+function toRefusalError(issue) {
+	if (issue.reason === "malformedTransaction") return {
+		code: "malformedTransaction",
+		message: MESSAGES.malformedTransaction,
+		previewCode: issue.detail.code,
+		detail: issue.detail.message
+	};
+	return {
+		code: issue.reason,
+		message: MESSAGES[issue.reason],
+		...issue.detail
+	};
+}
+/**
+* {@inheritDoc NoStrategyTargetCollateralError}
+**/
+function noStrategyTargetCollateral(creditManager) {
+	return {
+		code: "noStrategyTargetCollateral",
+		message: `Credit manager ${creditManager} has no strategy target collateral, and none was named.`,
+		creditManager
+	};
+}
+/**
+* {@inheritDoc CreditAccountNotFoundError}
+**/
+function creditAccountNotFound(creditAccount) {
+	return {
+		code: "creditAccountNotFound",
+		message: `Credit account not found: ${creditAccount}.`,
+		creditAccount
+	};
+}
+/**
+* {@inheritDoc UnexpectedFailureError}
+*
+* Takes what was thrown, whatever that is: a `throw` is not obliged to raise an
+* `Error`, and `cause` promises one.
+**/
+function unexpectedFailure(thrown) {
+	const cause = thrown instanceof Error ? thrown : new Error(String(thrown));
+	return {
+		code: "unexpectedFailure",
+		message: `The SDK could not prepare this operation: ${cause.message}`,
+		cause
+	};
+}
+//#endregion
+exports.creditAccountNotFound = creditAccountNotFound;
+exports.noStrategyTargetCollateral = noStrategyTargetCollateral;
+exports.toRefusalError = toRefusalError;
+exports.unexpectedFailure = unexpectedFailure;

package/dist/cjs/sdk/prepare/index.js

@@ -1,4 +1,13 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_validation_refusal = require("../../onchain/validation/refusal.js");
+const require_sdk_prepare_errors = require("./errors.js");
 const require_sdk_prepare_PrepareApi = require("./PrepareApi.js");
 require("./types.js");
+exports.IntentPreviewError = require_onchain_validation_refusal.IntentPreviewError;
 exports.PrepareApi = require_sdk_prepare_PrepareApi.PrepareApi;
+exports.creditAccountNotFound = require_sdk_prepare_errors.creditAccountNotFound;
+exports.noStrategyTargetCollateral = require_sdk_prepare_errors.noStrategyTargetCollateral;
+exports.raise = require_onchain_validation_refusal.raise;
+exports.refuse = require_onchain_validation_refusal.refuse;
+exports.toRefusalError = require_sdk_prepare_errors.toRefusalError;
+exports.unexpectedFailure = require_sdk_prepare_errors.unexpectedFailure;

package/dist/cjs/sdk/prepare/types.js

@@ -1 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_validation_refusal = require("../../onchain/validation/refusal.js");
+exports.IntentPreviewError = require_onchain_validation_refusal.IntentPreviewError;
+exports.raise = require_onchain_validation_refusal.raise;
+exports.refuse = require_onchain_validation_refusal.refuse;

package/dist/cjs/sdk/prepare/withdrawable-collaterals.js

@@ -0,0 +1,23 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_accounts_intents_utils_pick_token = require("../../onchain/accounts/intents/utils/pick-token.js");
+require("../../onchain/index.js");
+//#region src/sdk/prepare/withdrawable-collaterals.ts
+/**
+* {@inheritDoc IOpportunitiesPrepare.withdrawableCollaterals}
+**/
+function withdrawableCollaterals(sdk, position) {
+	return position.collaterals.filter((c) => !require_onchain_accounts_intents_utils_pick_token.isPhantomToken(sdk, c.collateral.token.address)).sort(byValueThenAddress);
+}
+/**
+* Most valuable first. Address breaks a tie so the order is stable: two
+* collaterals can share a value — a pair of unpriced ones share `null` — and a
+* picker that seeds its default from the first row would otherwise change it
+* between reads.
+*/
+function byValueThenAddress(a, b) {
+	const byValue = (b.collateral.valueUsd ?? 0) - (a.collateral.valueUsd ?? 0);
+	if (byValue !== 0) return byValue;
+	return a.collateral.token.address < b.collateral.token.address ? -1 : 1;
+}
+//#endregion
+exports.withdrawableCollaterals = withdrawableCollaterals;

package/dist/cjs/sdk/preview/PreviewNamespace.js

@@ -3,7 +3,7 @@ const require_preview_preview_previewOperation = require("../../preview/preview/
 require("../../preview/index.js");
 //#region src/sdk/preview/PreviewNamespace.ts
 /**
-* {@inheritDoc Preview}
+* {@inheritDoc IPreview}
 **/
 var PreviewNamespace = class {
 	#onchain;
@@ -15,7 +15,7 @@ var PreviewNamespace = class {
 		this.#logger = options.logger?.child?.({ name: "Preview" }) ?? options.logger;
 	}
 	/**
-	* {@inheritDoc Preview.previewOperation}
+	* {@inheritDoc IPreview.previewOperation}
 	**/
 	async previewOperation(input, options) {
 		await this.#ensureFresh?.([input.chainId]);

package/dist/esm/abi/compressors/subcompressors/withdrawal/mellowWithdrawalSubcompressor.js

@@ -79,6 +79,11 @@ const mellowWithdrawalSubcompressorAbi = [
 						internalType: "bytes"
 					}]
 				},
+				{
+					name: "redeemer",
+					type: "address",
+					internalType: "address"
+				},
 				{
 					name: "extraData",
 					type: "bytes",
@@ -127,6 +132,11 @@ const mellowWithdrawalSubcompressorAbi = [
 					type: "uint256",
 					internalType: "uint256"
 				},
+				{
+					name: "redeemer",
+					type: "address",
+					internalType: "address"
+				},
 				{
 					name: "extraData",
 					type: "bytes",
@@ -204,6 +214,11 @@ const mellowWithdrawalSubcompressorAbi = [
 						internalType: "bytes"
 					}]
 				},
+				{
+					name: "redeemer",
+					type: "address",
+					internalType: "address"
+				},
 				{
 					name: "extraData",
 					type: "bytes",
@@ -252,6 +267,11 @@ const mellowWithdrawalSubcompressorAbi = [
 					type: "uint256",
 					internalType: "uint256"
 				},
+				{
+					name: "redeemer",
+					type: "address",
+					internalType: "address"
+				},
 				{
 					name: "extraData",
 					type: "bytes",

package/dist/esm/dev/AccountOpener.js

@@ -1,5 +1,5 @@
-import { ierc20Abi } from "../abi/iERC20.js";
 import { iCreditFacadeV310Abi } from "../abi/310/generated.js";
+import { ierc20Abi } from "../abi/iERC20.js";
 import { AddressMap } from "../onchain/utils/AddressMap.js";
 import { AddressSet } from "../onchain/utils/AddressSet.js";
 import { AssetsMap } from "../onchain/utils/AssetsMap.js";

package/dist/esm/dev/mode-parity/compareOpportunities.js

@@ -1,5 +1,5 @@
-import { opportunityId } from "../../model/opportunities.js";
 import { poolOpportunitySchema, strategyOpportunitySchema } from "../../model/opportunities.schema.js";
+import { opportunityId } from "../../model/opportunities.js";
 import "../../model/index.js";
 import { countPaths, diffObjects, toCompareCounts, union } from "./fieldDiff.js";
 import { compileCompareRules, makeTagDiff } from "./compareRules.js";
@@ -14,8 +14,8 @@ const tagDiff = makeTagDiff({
 *
 * 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.
+* {@link FieldDiff.expected} so that {@link CompareCounts.similar} can ignore
+* it.
 **/
 function compareOpportunities(input) {
 	const onchainRows = indexById(input.onchain.data);
@@ -36,8 +36,7 @@ function compareOpportunities(input) {
 			chainId: row.chainId,
 			onchainName: row.name,
 			offchainName: counterpart.name,
-			identical: diffs.length === 0,
-			clean: diffs.every((diff) => diff.expected),
+			similar: diffs.every((diff) => diff.expected),
 			diffs
 		});
 	}

package/dist/esm/dev/mode-parity/comparePositions.js

@@ -1,6 +1,6 @@
 import { liquidationPositionSchema } from "../../model/liquidations.schema.js";
-import { positionId } from "../../model/positions.js";
 import { poolPositionSchema, strategyPositionSchema } from "../../model/positions.schema.js";
+import { positionId } from "../../model/positions.js";
 import "../../model/index.js";
 import { countPaths, diffObjects, isRecord, toCompareCounts, union } from "./fieldDiff.js";
 import { compileCompareRules, makeTagDiff } from "./compareRules.js";
@@ -14,10 +14,11 @@ const tagDiff = makeTagDiff({
 * 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.
+* Nothing is filtered out. A field only one mode can fill, a strategy field
+* both-mode merge overlays from the backend, or a USD value that drifted
+* within snapshot-lag noise, is still reported — tagged
+* {@link FieldDiff.expected} so that {@link CompareCounts.similar} can ignore
+* it.
 **/
 function comparePositions(input) {
 	const failures = input.failures ?? [];
@@ -64,8 +65,7 @@ function compareWallet(input) {
 			chainId: row.chainId,
 			onchainName: row.name,
 			offchainName: counterpart.name,
-			identical: diffs.length === 0,
-			clean: diffs.every((diff) => diff.expected),
+			similar: diffs.every((diff) => diff.expected),
 			diffs
 		});
 	}
@@ -128,11 +128,11 @@ function summarize(inputs, wallets, failed) {
 		...wallet.error ? { error: wallet.error } : {},
 		...toCompareCounts(wallet.matched.length + wallet.onlyOnchain.length, wallet.matched.length + wallet.onlyOffchain.length, wallet.onlyOnchain.length, wallet.onlyOffchain.length, wallet.matched)
 	}));
-	const walletsClean = compared.filter((wallet) => wallet.onlyOnchain.length === 0 && wallet.onlyOffchain.length === 0 && wallet.matched.every((match) => match.clean)).length;
+	const walletsSimilar = compared.filter((wallet) => wallet.onlyOnchain.length === 0 && wallet.onlyOffchain.length === 0 && wallet.matched.every((match) => match.similar)).length;
 	return {
 		...toCompareCounts(allOnchain.length, allOffchain.length, onlyOnchain.length, onlyOffchain.length, matched),
 		wallets: wallets.length,
-		walletsClean,
+		walletsSimilar,
 		walletsFailed: failed,
 		byChain,
 		byWallet,

package/dist/esm/dev/mode-parity/compareRules.js

@@ -24,15 +24,26 @@ function makeTagDiff(rulesByKind) {
 		if (!rules) return diff;
 		const path = collapseArrayKeys(diff.path);
 		if (isModeScoped(path, rules)) return withExpected(diff, "mode-scoped");
+		if (isBackendPreferred(path, rules)) return withExpected(diff, "backend-preferred");
 		const tag = rules.get(path);
 		if (tag && typeof tag === "object" && withinTolerance(tag.tolerance, diff)) return withExpected(diff, "tolerance");
 		return diff;
 	};
 }
+function pathMatchesRule(path, rulePath) {
+	return path === rulePath || path.startsWith(`${rulePath}.`) || path.startsWith(`${rulePath}[`);
+}
 function isModeScoped(path, rules) {
 	for (const [rulePath, tag] of rules) {
 		if (tag !== "offchainOnly" && tag !== "onchainOnly") continue;
-		if (path === rulePath || path.startsWith(`${rulePath}.`) || path.startsWith(`${rulePath}[`)) return true;
+		if (pathMatchesRule(path, rulePath)) return true;
+	}
+	return false;
+}
+function isBackendPreferred(path, rules) {
+	for (const [rulePath, tag] of rules) {
+		if (tag !== "backendPreferred") continue;
+		if (pathMatchesRule(path, rulePath)) return true;
 	}
 	return false;
 }

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

@@ -53,7 +53,7 @@ function diffObjects(onchain, offchain, options) {
 	return diffs;
 }
 /**
-* Mark a diff expected, so a later `clean` count can ignore it.
+* Mark a diff expected, so a later `similar` count can ignore it.
 **/
 function withExpected(diff, reason) {
 	return {
@@ -117,15 +117,13 @@ function collapseArrayKeys(path) {
 * 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;
+	const similar = matched.filter((match) => match.similar).length;
 	return {
 		onchainRows,
 		offchainRows,
 		matched: matched.length,
-		identical,
-		clean,
-		differing: matched.length - identical,
+		similar,
+		different: matched.length - similar,
 		onlyOnchain,
 		onlyOffchain
 	};

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

@@ -1,4 +1,5 @@
 import { getAlchemyUrl } from "../providers.js";
+import { appendFileSync } from "node:fs";
 import { pino } from "pino";
 //#region src/dev/mode-parity/scriptUtils.ts
 const NETWORKS = [
@@ -76,6 +77,40 @@ function worstColumns(worst) {
 	};
 }
 /**
+* Reasons a compare run should fail CI: unexpected membership or field diffs,
+* both sources empty, a chain that could not be read, or wallets that failed
+* to list. Expected diffs (mode-scoped, backend-preferred, tolerance) do not
+* fail the run.
+**/
+function evaluateCompareFailure(report) {
+	const { summary } = report;
+	const reasons = [];
+	if (summary.onchainRows === 0 && summary.offchainRows === 0) reasons.push("both sources produced no data");
+	if (summary.different > 0) reasons.push(`${summary.different} matched rows are different`);
+	if (summary.onlyOnchain > 0) reasons.push(`${summary.onlyOnchain} rows only onchain`);
+	if (summary.onlyOffchain > 0) reasons.push(`${summary.onlyOffchain} rows only offchain`);
+	if ((summary.walletsFailed ?? 0) > 0) reasons.push(`${summary.walletsFailed} wallets failed to list`);
+	for (const chain of [...report.onchainChains, ...report.offchainChains]) if (chain.status === "error") reasons.push(`chain ${chain.chainId} failed on ${chain.source ?? "unknown"}: ${errorMessage(chain.error)}`);
+	return reasons;
+}
+function splitDiffs(summary) {
+	return {
+		unexpected: summary.diffsByPath.filter((entry) => entry.unexpected > 0),
+		expected: summary.diffsByPath.filter((entry) => entry.unexpected === 0 && entry.expected > 0)
+	};
+}
+function markdownCell(value) {
+	return String(value).replaceAll("|", "\\|").replaceAll("\n", " ");
+}
+function markdownTable(headers, rows) {
+	const line = (cells) => `| ${cells.map(markdownCell).join(" | ")} |`;
+	return [
+		line(headers),
+		line(headers.map(() => "---")),
+		...rows.map(line)
+	].join("\n");
+}
+/**
 * Prints the shared membership table, the fields that differed most often,
 * and any chain that failed to answer.
 **/
@@ -87,15 +122,13 @@ function printCompareSummary(noun, report, extraLines = []) {
 		onchain: chain.onchainRows,
 		offchain: chain.offchainRows,
 		matched: chain.matched,
-		identical: chain.identical,
-		clean: chain.clean,
-		differing: chain.differing,
+		similar: chain.similar,
+		different: chain.different,
 		"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);
+	const { unexpected, expected } = splitDiffs(summary);
 	if (unexpected.length) {
 		console.log("\nunexpected fields that differed most often:");
 		console.table(unexpected.slice(0, 25).map((entry) => ({
@@ -107,7 +140,7 @@ function printCompareSummary(noun, report, extraLines = []) {
 		})));
 	}
 	if (expected.length) {
-		console.log("\nexpected fields (mode-scoped or within tolerance):");
+		console.log("\nexpected fields (mode-scoped, backend-preferred, or within tolerance):");
 		console.table(expected.slice(0, 25).map((entry) => ({
 			field: entry.path,
 			rows: entry.expected,
@@ -117,5 +150,108 @@ function printCompareSummary(noun, report, extraLines = []) {
 	}
 	for (const chain of [...report.onchainChains, ...report.offchainChains]) if (chain.status === "error") console.log(`chain ${chain.chainId} failed on ${chain.source}:`, chain.error);
 }
+/**
+* Markdown of the same summary printed to the console, for GitHub job summaries.
+**/
+function formatCompareMarkdown(noun, report, extraLines = [], reasons = []) {
+	const { summary } = report;
+	const { unexpected, expected } = splitDiffs(summary);
+	const parts = [
+		`# ${noun} compare`,
+		"",
+		reasons.length ? "**Failed**" : "**Passed**",
+		"",
+		`${noun} from \`${report.backendUrl}\` vs the chain`,
+		""
+	];
+	if (reasons.length) {
+		parts.push("## Failures", "");
+		for (const reason of reasons) parts.push(`- ${reason}`);
+		parts.push("");
+	}
+	if (extraLines.length) {
+		for (const line of extraLines) parts.push(line);
+		parts.push("");
+	}
+	if (summary.byChain.length) parts.push(markdownTable([
+		"chain",
+		"onchain",
+		"offchain",
+		"matched",
+		"similar",
+		"different",
+		"only onchain",
+		"only offchain"
+	], summary.byChain.map((chain) => [
+		chain.chainId,
+		chain.onchainRows,
+		chain.offchainRows,
+		chain.matched,
+		chain.similar,
+		chain.different,
+		chain.onlyOnchain,
+		chain.onlyOffchain
+	])), "");
+	if (unexpected.length) parts.push("## Unexpected fields that differed most often", "", markdownTable([
+		"field",
+		"unexpected",
+		"expected",
+		"kinds",
+		"max diff",
+		"worst entity"
+	], unexpected.slice(0, 25).map((entry) => {
+		const worst = worstColumns(entry.worstUnexpected);
+		return [
+			entry.path,
+			entry.unexpected,
+			entry.expected,
+			entry.kinds.join(", "),
+			worst["max diff"],
+			worst["worst entity"]
+		];
+	})), "");
+	if (expected.length) parts.push("## Expected fields (mode-scoped, backend-preferred, or within tolerance)", "", markdownTable([
+		"field",
+		"rows",
+		"kinds",
+		"max diff",
+		"worst entity"
+	], expected.slice(0, 25).map((entry) => {
+		const worst = worstColumns(entry.worstExpected);
+		return [
+			entry.path,
+			entry.expected,
+			entry.kinds.join(", "),
+			worst["max diff"],
+			worst["worst entity"]
+		];
+	})), "");
+	const failedChains = [...report.onchainChains, ...report.offchainChains].filter((chain) => chain.status === "error");
+	if (failedChains.length) {
+		parts.push("## Chain errors", "");
+		for (const chain of failedChains) parts.push(`- chain ${chain.chainId} failed on ${chain.source ?? "unknown"}: ${errorMessage(chain.error)}`);
+		parts.push("");
+	}
+	return parts.join("\n");
+}
+/**
+* Appends {@link formatCompareMarkdown} to `GITHUB_STEP_SUMMARY` when running
+* in GitHub Actions. No-op locally.
+**/
+function writeGithubJobSummary(noun, report, extraLines = [], reasons = []) {
+	const path = process.env.GITHUB_STEP_SUMMARY;
+	if (!path) return;
+	appendFileSync(path, `${formatCompareMarkdown(noun, report, extraLines, reasons)}\n`);
+}
+/**
+* Console + job-summary output for a compare run. Returns the failure reasons
+* so the caller can exit 1 when the report is not similar.
+**/
+function reportCompare(noun, report, extraLines = []) {
+	printCompareSummary(noun, report, extraLines);
+	const reasons = evaluateCompareFailure(report);
+	writeGithubJobSummary(noun, report, extraLines, reasons);
+	return reasons;
+}
 //#endregion
-export { BACKEND_URL, NETWORKS, TIMEOUT, createLogger, errorMessage, formatBpsAsPercent, mapPool, printCompareSummary, requireEnv, rpcUrls };
+export { BACKEND_URL, NETWORKS, TIMEOUT, createLogger, errorMessage, evaluateCompareFailure, formatBpsAsPercent, formatCompareMarkdown, mapPool, printCompareSummary, reportCompare, requireEnv, rpcUrls, writeGithubJobSummary };

package/dist/esm/dev/withdrawalUtils.js

@@ -1,6 +1,6 @@
-import { iWithdrawalCompressorV313Abi } from "../abi/IWithdrawalCompressorV313.js";
 import { getNetworkType } from "../onchain/chain/chains.js";
 import { getWithdrawalCompressorAddress } from "../onchain/accounts/withdrawal-compressor/addresses.js";
+import { iWithdrawalCompressorV313Abi } from "../abi/IWithdrawalCompressorV313.js";
 import "../onchain/index.js";
 import { iMidasDataFeedAbi, iMidasRedemptionVaultAbi, midasGatewayAbi, midasRedeemerAbi, midasRedemptionVaultPhantomTokenAbi, securitizeRedeemerAbi, securitizeRedemptionGatewayAbi, securitizeRedemptionPhantomTokenAbi } from "./withdrawalAbi.js";
 import { erc20Abi, hexToString, parseAbi, parseEther } from "viem";

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

@@ -0,0 +1,108 @@
+import { ZodAddress } from "../onchain/utils/zod.js";
+import { isFilterSet } from "./filters.js";
+import { encodeFlag, filterable } from "./filters.schema.js";
+import { assetTypeSchema, chainIdSchema } from "./primitives.schema.js";
+import { liquidationPositionSchema } from "./liquidations.schema.js";
+import { poolPositionSchema, positionKindSchema, strategyPositionSchema } from "./positions.schema.js";
+import { isAddress } from "viem";
+import { z } from "zod/v4";
+//#region src/model/analytics.schema.ts
+/** Default page size of the protocol-wide positions list. */
+const ANALYTICS_POSITIONS_DEFAULT_LIMIT = 25;
+/** Largest page the protocol-wide positions list accepts. */
+const ANALYTICS_POSITIONS_MAX_LIMIT = 100;
+/** {@link AnalyticsPositionSortField} */
+const analyticsPositionSortFieldSchema = z.enum([
+	"netValueUsd",
+	"totalValueUsd",
+	"totalDebtUsd",
+	"pnlUsd",
+	"apy",
+	"healthFactor",
+	"leverage",
+	"chainId",
+	"name",
+	"borrower"
+]);
+/** {@link AnalyticsSortDirection} */
+const analyticsSortDirectionSchema = z.enum(["asc", "desc"]);
+const analyticsOwnerShape = { borrower: ZodAddress() };
+const addressSchema = z.custom((value) => typeof value === "string" && isAddress(value, { strict: false }));
+/** {@link AnalyticsPosition} */
+const analyticsPositionSchema = z.discriminatedUnion("kind", [
+	z.object({
+		...poolPositionSchema.shape,
+		...analyticsOwnerShape
+	}),
+	z.object({
+		...strategyPositionSchema.shape,
+		...analyticsOwnerShape
+	}),
+	z.object({
+		...liquidationPositionSchema.shape,
+		...analyticsOwnerShape
+	})
+]);
+/** {@link AnalyticsPositionListOptions} */
+const analyticsPositionListOptionsSchema = z.object({
+	borrower: addressSchema.optional(),
+	kind: filterable(positionKindSchema).optional(),
+	isZeroDebt: filterable(z.boolean()).optional(),
+	chainIds: z.array(chainIdSchema).optional(),
+	underlyingType: filterable(assetTypeSchema).optional(),
+	sortBy: analyticsPositionSortFieldSchema.optional(),
+	sortDirection: analyticsSortDirectionSchema.optional(),
+	offset: z.number().int().nonnegative().optional(),
+	limit: z.number().int().positive().max(100).optional()
+});
+/**
+* {@link AnalyticsPositionListOptions} as URL query parameters.
+**/
+const analyticsPositionListQueryParamsSchema = z.object({
+	borrower: z.string().refine((value) => isAddress(value, { strict: false }), "invalid address").optional(),
+	kind: positionKindSchema.optional(),
+	isZeroDebt: z.enum(["true", "false"]).optional(),
+	chainIds: z.string().regex(/^$|^\d+(,\d+)*$/).optional(),
+	underlyingType: assetTypeSchema.optional(),
+	sortBy: analyticsPositionSortFieldSchema.optional(),
+	sortDirection: analyticsSortDirectionSchema.optional(),
+	offset: z.string().regex(/^\d+$/).optional(),
+	limit: z.string().regex(/^[1-9]\d*$/).optional()
+});
+/**
+* Codec for an analytics position-list query. It is shared by the SDK client
+* and backend controller so both sides interpret every parameter identically.
+**/
+const analyticsPositionListQuerySchema = z.codec(analyticsPositionListQueryParamsSchema, analyticsPositionListOptionsSchema, {
+	decode: (params) => ({
+		...params.borrower === void 0 ? {} : { borrower: params.borrower },
+		...params.kind === void 0 ? {} : { kind: params.kind },
+		...params.isZeroDebt === void 0 ? {} : { isZeroDebt: params.isZeroDebt === "true" },
+		...params.chainIds === void 0 ? {} : { chainIds: params.chainIds === "" ? [] : params.chainIds.split(",").map(Number) },
+		...params.underlyingType === void 0 ? {} : { underlyingType: params.underlyingType },
+		...params.sortBy === void 0 ? {} : { sortBy: params.sortBy },
+		...params.sortDirection === void 0 ? {} : { sortDirection: params.sortDirection },
+		...params.offset === void 0 ? {} : { offset: Number(params.offset) },
+		...params.limit === void 0 ? {} : { limit: Number(params.limit) }
+	}),
+	encode: (options) => ({
+		borrower: options.borrower,
+		kind: isFilterSet(options.kind) ? options.kind : void 0,
+		isZeroDebt: encodeFlag(options.isZeroDebt),
+		chainIds: options.chainIds?.join(","),
+		underlyingType: isFilterSet(options.underlyingType) ? options.underlyingType : void 0,
+		sortBy: options.sortBy,
+		sortDirection: options.sortDirection,
+		offset: options.offset?.toString(),
+		limit: options.limit?.toString()
+	})
+});
+/** {@link AnalyticsPositionPage} */
+const analyticsPositionPageSchema = z.object({
+	items: z.array(analyticsPositionSchema),
+	total: z.number().int().nonnegative(),
+	offset: z.number().int().nonnegative(),
+	limit: z.number().int().positive().max(100)
+});
+//#endregion
+export { ANALYTICS_POSITIONS_DEFAULT_LIMIT, ANALYTICS_POSITIONS_MAX_LIMIT, analyticsPositionListOptionsSchema, analyticsPositionListQueryParamsSchema, analyticsPositionListQuerySchema, analyticsPositionPageSchema, analyticsPositionSchema, analyticsPositionSortFieldSchema, analyticsSortDirectionSchema };