@gearbox-protocol/sdk 15.1.0-next.2 → 15.1.0-next.21

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

@@ -0,0 +1,226 @@
+import { CHART_METRIC_UNITS, CHART_RANGES, CHART_UNAVAILABLE_CODES, POOL_OPPORTUNITY_CHART_METRICS, POOL_POSITION_CHART_METRICS, STRATEGY_OPPORTUNITY_CHART_METRICS, STRATEGY_POSITION_CHART_METRICS } from "./charts.js";
+import { timestampSchema, tokenSchema } from "./primitives.schema.js";
+import { z } from "zod/v4";
+//#region src/model/charts.schema.ts
+/**
+* Runtime schemas for {@link ./charts.js}, see the note in
+* `primitives.schema.ts` on why they are written by hand.
+*
+* Metric schemas are shared with the backend, while
+* {@link chartBundleSchemaFor} builds the response schema for one concrete
+* request. Component schemas remain available for consumers that validate
+* model fragments.
+**/
+/**
+* {@link ChartRange}
+**/
+const chartRangeSchema = z.enum(CHART_RANGES);
+/**
+* {@link PoolOpportunityChartMetric}
+**/
+const poolOpportunityChartMetricSchema = z.enum(POOL_OPPORTUNITY_CHART_METRICS);
+/**
+* {@link StrategyOpportunityChartMetric}
+**/
+const strategyOpportunityChartMetricSchema = z.enum(STRATEGY_OPPORTUNITY_CHART_METRICS);
+/**
+* {@link PoolPositionChartMetric}
+**/
+const poolPositionChartMetricSchema = z.enum(POOL_POSITION_CHART_METRICS);
+/**
+* {@link StrategyPositionChartMetric}
+**/
+const strategyPositionChartMetricSchema = z.enum(STRATEGY_POSITION_CHART_METRICS);
+/**
+* {@link ChartMetric}, every metric either kind of subject can chart.
+**/
+const chartMetricSchema = z.union([
+	poolOpportunityChartMetricSchema,
+	strategyOpportunityChartMetricSchema,
+	poolPositionChartMetricSchema,
+	strategyPositionChartMetricSchema
+]);
+/**
+* {@link ChartQuery}
+**/
+const chartQuerySchema = z.object({
+	metrics: z.array(chartMetricSchema).readonly().refine((metrics) => metrics.length > 0, { error: "a chart read needs at least one metric" }).refine((metrics) => new Set(metrics).size === metrics.length, { error: "a chart read needs distinct metrics" }),
+	range: chartRangeSchema
+});
+/**
+* {@link ChartQuery} as a URL can carry it: the metrics comma-joined, since
+* repeated `?metrics=` entries would order differently between clients and give
+* one request two cache keys.
+**/
+const chartQueryParamsSchema = z.object({
+	metrics: z.string().regex(/^\w+(,\w+)*$/),
+	range: chartRangeSchema
+});
+/**
+* Codec for {@link ChartQuery} to encode/decode to/from url query parameters.
+*
+* The one place the wire form of a chart request is decided. The SDK encodes
+* with it, the backend decodes with it, and the checks that a read names at
+* least one metric and names none of them twice ride along in both directions —
+* so a bad request fails before it is issued, not after a round trip.
+**/
+const chartQueryCodec = z.codec(chartQueryParamsSchema, chartQuerySchema, {
+	decode: (params) => ({
+		metrics: params.metrics.split(","),
+		range: params.range
+	}),
+	encode: (query) => ({
+		metrics: query.metrics.join(","),
+		range: query.range
+	})
+});
+/**
+* {@link ChartDenomination}
+**/
+const chartDenominationSchema = z.discriminatedUnion("unit", [
+	z.object({ unit: z.literal("bps") }),
+	z.object({ unit: z.literal("usd") }),
+	z.object({ unit: z.literal("scalar") }),
+	z.object({
+		unit: z.literal("token"),
+		base: tokenSchema
+	}),
+	z.object({
+		unit: z.literal("ratio"),
+		base: tokenSchema,
+		quote: tokenSchema
+	})
+]);
+/**
+* {@link ChartValue}. `null` is a gap, never a zero.
+**/
+const chartValueSchema = z.number().nullable();
+/**
+* {@link ChartSeries}
+**/
+const chartSeriesSchema = z.union([z.intersection(z.object({
+	status: z.literal("ok"),
+	values: z.array(chartValueSchema)
+}), chartDenominationSchema), z.object({
+	status: z.literal("unavailable"),
+	reason: z.object({
+		code: z.enum(CHART_UNAVAILABLE_CODES),
+		message: z.string().optional()
+	})
+})]);
+/**
+* {@link ChartWindow}
+**/
+const chartWindowSchema = z.object({
+	range: chartRangeSchema,
+	from: timestampSchema,
+	to: timestampSchema
+});
+const gridSamplingSchema = z.object({
+	kind: z.literal("grid"),
+	intervalSeconds: z.number().int().positive()
+});
+/**
+* A bundle whose series are keyed by `keys`.
+*
+* `z.record` over a literal union is what enforces the metric set: a key that
+* was not asked for is rejected, and one that was but is missing fails as an
+* absent value. Exactly-once therefore needs no counting — an object cannot
+* hold the same key twice.
+**/
+function chartBundleSchemaWith(keys, expectedRange) {
+	return z.object({
+		window: chartWindowSchema,
+		sampling: gridSamplingSchema,
+		timestamps: z.array(timestampSchema),
+		series: z.record(keys, chartSeriesSchema)
+	}).superRefine((bundle, ctx) => checkChartBundle(bundle, ctx, expectedRange));
+}
+/**
+* The invariants a bundle upholds beyond its shape, checked on every read so a
+* backend that breaks one is rejected rather than plotted:
+*
+* - each available series holds exactly one value per timestamp, which is what
+*   makes two series of a bundle comparable at an index;
+* - a series' unit is the one {@link CHART_METRIC_UNITS} gives the metric it is
+*   keyed by, so a consumer can format from either without them disagreeing;
+* - the window's bounds are the axis' own, so a chart drawn from `window` and a
+*   chart drawn from `timestamps` cover the same span;
+* - timestamps lie on the declared grid and are exactly one interval apart;
+* - when validating a read, the response names the range that was requested.
+**/
+function checkChartBundle(bundle, ctx, expectedRange) {
+	const { sampling, timestamps, window, series } = bundle;
+	const entries = Object.entries(series);
+	for (const [metric, chart] of entries) {
+		if (chart.status !== "ok") continue;
+		if (chart.values.length !== timestamps.length) ctx.addIssue({
+			code: "custom",
+			path: [
+				"series",
+				metric,
+				"values"
+			],
+			message: `series "${metric}" holds ${chart.values.length} values for ${timestamps.length} timestamps`
+		});
+		if (CHART_METRIC_UNITS[metric] !== chart.unit) ctx.addIssue({
+			code: "custom",
+			path: [
+				"series",
+				metric,
+				"unit"
+			],
+			message: `metric "${metric}" is ${CHART_METRIC_UNITS[metric]}, not ${chart.unit}`
+		});
+	}
+	const first = timestamps.at(0);
+	const last = timestamps.at(-1);
+	if (first !== void 0 && first !== window.from) ctx.addIssue({
+		code: "custom",
+		path: ["window", "from"],
+		message: `window starts at ${window.from} but the axis starts at ${first}`
+	});
+	if (last !== void 0 && last !== window.to) ctx.addIssue({
+		code: "custom",
+		path: ["window", "to"],
+		message: `window ends at ${window.to} but the axis ends at ${last}`
+	});
+	if (expectedRange !== void 0 && window.range !== expectedRange) ctx.addIssue({
+		code: "custom",
+		path: ["window", "range"],
+		message: `requested range ${expectedRange}, received ${window.range}`
+	});
+	for (let i = 0; i < timestamps.length; i += 1) {
+		const timestamp = timestamps[i];
+		if (timestamp % sampling.intervalSeconds !== 0) ctx.addIssue({
+			code: "custom",
+			path: ["timestamps", i],
+			message: `timestamp ${timestamp} is not on the ${sampling.intervalSeconds}-second grid`
+		});
+		const previous = timestamps[i - 1];
+		if (previous !== void 0 && timestamp - previous !== sampling.intervalSeconds) ctx.addIssue({
+			code: "custom",
+			path: ["timestamps", i],
+			message: `timestamps are not ${sampling.intervalSeconds} seconds apart`
+		});
+	}
+}
+/**
+* The schema one chart read is decoded with: a {@link ChartBundle} keyed by the
+* requested distinct metrics, all of them and nothing else, for the requested
+* range.
+*
+* Pinning the metrics is what upholds the `ChartBundle<Metrics>` a caller gets
+* back — a response that answers a different question fails validation rather
+* than being cast into the requested shape. The declared return type is the one
+* the key schema actually enforces, which the compiler cannot see through a
+* schema built from a runtime list.
+**/
+function chartBundleSchemaFor(metrics, range) {
+	if (metrics.length === 0) throw new RangeError("a chart read needs at least one metric");
+	if (new Set(metrics).size !== metrics.length) throw new RangeError("a chart read needs distinct metrics");
+	const literals = metrics.map((metric) => z.literal(metric));
+	return chartBundleSchemaWith(z.union(literals), range);
+}
+//#endregion
+export { chartBundleSchemaFor, chartDenominationSchema, chartMetricSchema, chartQueryCodec, chartQueryParamsSchema, chartQuerySchema, chartRangeSchema, chartSeriesSchema, chartValueSchema, chartWindowSchema, poolOpportunityChartMetricSchema, poolPositionChartMetricSchema, strategyOpportunityChartMetricSchema, strategyPositionChartMetricSchema };

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

@@ -0,0 +1,29 @@
+//#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
+export { compareTagOf, offchainOnly, onchainOnly, tolerance };

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

@@ -1,4 +1,5 @@
 import { ZodAddress } from "../sdk/utils/zod.js";
+import { offchainOnly } from "./compare.schema.js";
 import { z } from "zod/v4";
 //#region src/model/curators.schema.ts
 /**
@@ -30,7 +31,7 @@ const curatorNameSchema = z.enum([
 const curatorSchema = z.object({
 	address: ZodAddress(),
 	name: curatorNameSchema.optional(),
-	url: z.string().nullable()
+	url: offchainOnly(z.string().nullable())
 });
 //#endregion
 export { curatorNameSchema, curatorSchema };

package/dist/esm/model/index.js

@@ -1,17 +1,22 @@
+import { CHART_METRIC_UNITS, CHART_RANGES, CHART_UNAVAILABLE_CODES, POOL_OPPORTUNITY_CHART_METRICS, POOL_POSITION_CHART_METRICS, STRATEGY_OPPORTUNITY_CHART_METRICS, STRATEGY_POSITION_CHART_METRICS } from "./charts.js";
+import { compareTagOf, offchainOnly, onchainOnly, tolerance } from "./compare.schema.js";
+import { amountSchema, assetTypeSchema, bpsSchema, chainIdSchema, leverageSchema, timestampSchema, tokenAmountSchema, tokenSchema, txCallSchema } from "./primitives.schema.js";
+import { chartBundleSchemaFor, chartDenominationSchema, chartMetricSchema, chartQueryCodec, chartQueryParamsSchema, chartQuerySchema, chartRangeSchema, chartSeriesSchema, chartValueSchema, chartWindowSchema, poolOpportunityChartMetricSchema, poolPositionChartMetricSchema, strategyOpportunityChartMetricSchema, strategyPositionChartMetricSchema } from "./charts.schema.js";
 import "./curators.js";
 import { curatorNameSchema, curatorSchema } from "./curators.schema.js";
+import "./delayed-intents.js";
 import { FILTER_ALL, isFilterSet } from "./filters.js";
 import { booleanParamSchema, encodeFlag, filterAllSchema, filterable } from "./filters.schema.js";
-import { POOL_HISTORY_METRICS, POOL_POSITION_HISTORY_METRICS, STRATEGY_HISTORY_METRICS, STRATEGY_POSITION_HISTORY_METRICS } from "./history.js";
-import { amountSchema, assetTypeSchema, bpsSchema, chainIdSchema, leverageSchema, timestampSchema, tokenAmountSchema, tokenSchema, txCallSchema } from "./primitives.schema.js";
-import { apyBreakdownSchema, opportunityBaseSchema, opportunityDetailSchema, opportunityFilterQueryParamsSchema, opportunityFilterQuerySchema, opportunityFilterSchema, opportunityKeySchema, opportunityKindSchema, opportunitySchema, pointRewardsSchema, pointsProgramSchema, poolOpportunityDetailSchema, poolOpportunityKeySchema, poolOpportunitySchema, priceFeedDataSchema, priceFeedSummarySchema, quotaAssetSchema, rateCurvePointSchema, rateCurveSchema, rewardsSchema, strategyOpportunityDetailSchema, strategyOpportunityKeySchema, strategyOpportunitySchema, tokenRewardsSchema } from "./opportunities.schema.js";
-import { delayedReceivedAssetSchema, instantReceivedAssetSchema, liquidatableAccountFilterSchema, liquidatableAccountSchema, liquidationApprovalSchema, liquidationDetailsSchema, liquidationPositionSchema, receivedAssetSchema } from "./liquidations.schema.js";
-import { pnlBreakdownSchema, pointsProgramPnLSchema, pointsRewardsPnLSchema, poolPositionKeySchema, poolPositionSchema, positionCollateralSchema, positionFilterQueryParamsSchema, positionFilterQuerySchema, positionFilterSchema, positionKeySchema, positionKindSchema, positionSchema, rewardsPnLSchema, strategyPositionKeySchema, strategyPositionSchema, tokenRewardsPnLSchema } from "./positions.schema.js";
-import { historyChartMetadataSchema, historyMetricSchema, historyPointSchema, historyRangeSchema, historySeriesSchema, opportunityHistoryQuerySchema, poolHistoryMetricSchema, poolPositionHistoryMetricSchema, positionHistoryMetricSchema, positionHistoryQuerySchema, strategyHistoryMetricSchema, strategyPositionHistoryMetricSchema } from "./history.schema.js";
 import { matchesLiquidatableAccountFilter } from "./liquidations.js";
+import { delayedReceivedAssetSchema, instantReceivedAssetSchema, liquidatableAccountFilterSchema, liquidatableAccountSchema, liquidationApprovalSchema, liquidationDetailsSchema, liquidationPositionSchema, receivedAssetSchema } from "./liquidations.schema.js";
+import "./notices.js";
+import { noticeKindSchema, noticeSchema } from "./notices.schema.js";
 import { matchesOpportunityFilter, opportunityId, poolOpportunityId, strategyOpportunityId } from "./opportunities.js";
+import { apyBreakdownSchema, opportunityBaseSchema, opportunityDetailSchema, opportunityFilterQueryParamsSchema, opportunityFilterQuerySchema, opportunityFilterSchema, opportunityKeySchema, opportunityKindSchema, opportunitySchema, pointRewardsSchema, pointsProgramSchema, poolOpportunityDetailSchema, poolOpportunityKeySchema, poolOpportunitySchema, priceFeedDataSchema, priceFeedSummarySchema, quotaAssetSchema, rateCurvePointSchema, rateCurveSchema, rewardsSchema, strategyOpportunityDetailSchema, strategyOpportunityKeySchema, strategyOpportunitySchema, tokenRewardsSchema } from "./opportunities.schema.js";
 import { liquidationPositionId, matchesPositionFilter, poolPositionId, positionId, strategyPositionId } from "./positions.js";
+import { borrowRateBreakdownSchema, pnlBreakdownSchema, pointsProgramPnLSchema, pointsRewardsPnLSchema, poolPositionKeySchema, poolPositionSchema, positionCollateralSchema, positionFilterQueryParamsSchema, positionFilterQuerySchema, positionFilterSchema, positionKeySchema, positionKindSchema, positionSchema, positionTransactionKindSchema, positionTransactionSchema, positionsTotalsSchema, rewardsPnLSchema, strategyPositionKeySchema, strategyPositionSchema, tokenQuotaRateSchema, tokenRewardsPnLSchema } from "./positions.schema.js";
+import { ERROR_ADAPTER_CALL_OUTSIDE_BRACKET, ERROR_INVALID_TRANSACTION_VALUE, ERROR_MALFORMED_BRACKET, ERROR_NON_ADAPTER_CALL_IN_BRACKET, ERROR_UNPREVIEWABLE_ADAPTER_CALL, ERROR_UNPREVIEWABLE_RWA_WRAP_UNWRAP, ERROR_UNPRICEABLE_TOKEN } from "./previews.js";
 import "./primitives.js";
 import "./response.js";
 import { chainFailedSchema, chainMetadataSchema, chainSucceededSchema, dataSourceSchema, responseMetadataSchema, responseSchema } from "./response.schema.js";
-export { FILTER_ALL, POOL_HISTORY_METRICS, POOL_POSITION_HISTORY_METRICS, STRATEGY_HISTORY_METRICS, STRATEGY_POSITION_HISTORY_METRICS, amountSchema, apyBreakdownSchema, assetTypeSchema, booleanParamSchema, bpsSchema, chainFailedSchema, chainIdSchema, chainMetadataSchema, chainSucceededSchema, curatorNameSchema, curatorSchema, dataSourceSchema, delayedReceivedAssetSchema, encodeFlag, filterAllSchema, filterable, historyChartMetadataSchema, historyMetricSchema, historyPointSchema, historyRangeSchema, historySeriesSchema, instantReceivedAssetSchema, isFilterSet, leverageSchema, liquidatableAccountFilterSchema, liquidatableAccountSchema, liquidationApprovalSchema, liquidationDetailsSchema, liquidationPositionId, liquidationPositionSchema, matchesLiquidatableAccountFilter, matchesOpportunityFilter, matchesPositionFilter, opportunityBaseSchema, opportunityDetailSchema, opportunityFilterQueryParamsSchema, opportunityFilterQuerySchema, opportunityFilterSchema, opportunityHistoryQuerySchema, opportunityId, opportunityKeySchema, opportunityKindSchema, opportunitySchema, pnlBreakdownSchema, pointRewardsSchema, pointsProgramPnLSchema, pointsProgramSchema, pointsRewardsPnLSchema, poolHistoryMetricSchema, poolOpportunityDetailSchema, poolOpportunityId, poolOpportunityKeySchema, poolOpportunitySchema, poolPositionHistoryMetricSchema, poolPositionId, poolPositionKeySchema, poolPositionSchema, positionCollateralSchema, positionFilterQueryParamsSchema, positionFilterQuerySchema, positionFilterSchema, positionHistoryMetricSchema, positionHistoryQuerySchema, positionId, positionKeySchema, positionKindSchema, positionSchema, priceFeedDataSchema, priceFeedSummarySchema, quotaAssetSchema, rateCurvePointSchema, rateCurveSchema, receivedAssetSchema, responseMetadataSchema, responseSchema, rewardsPnLSchema, rewardsSchema, strategyHistoryMetricSchema, strategyOpportunityDetailSchema, strategyOpportunityId, strategyOpportunityKeySchema, strategyOpportunitySchema, strategyPositionHistoryMetricSchema, strategyPositionId, strategyPositionKeySchema, strategyPositionSchema, timestampSchema, tokenAmountSchema, tokenRewardsPnLSchema, tokenRewardsSchema, tokenSchema, txCallSchema };
+export { CHART_METRIC_UNITS, CHART_RANGES, CHART_UNAVAILABLE_CODES, ERROR_ADAPTER_CALL_OUTSIDE_BRACKET, ERROR_INVALID_TRANSACTION_VALUE, ERROR_MALFORMED_BRACKET, ERROR_NON_ADAPTER_CALL_IN_BRACKET, ERROR_UNPREVIEWABLE_ADAPTER_CALL, ERROR_UNPREVIEWABLE_RWA_WRAP_UNWRAP, ERROR_UNPRICEABLE_TOKEN, FILTER_ALL, POOL_OPPORTUNITY_CHART_METRICS, POOL_POSITION_CHART_METRICS, STRATEGY_OPPORTUNITY_CHART_METRICS, STRATEGY_POSITION_CHART_METRICS, 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, tokenQuotaRateSchema, tokenRewardsPnLSchema, tokenRewardsSchema, tokenSchema, tolerance, txCallSchema };

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

@@ -1,6 +1,6 @@
 import { ZodAddress } from "../sdk/utils/zod.js";
-import { filterable } from "./filters.schema.js";
 import { assetTypeSchema, chainIdSchema, timestampSchema, tokenAmountSchema, tokenSchema, txCallSchema } from "./primitives.schema.js";
+import { filterable } from "./filters.schema.js";
 import { z } from "zod/v4";
 //#region src/model/liquidations.schema.ts
 /**

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

@@ -0,0 +1,23 @@
+import { tokenSchema } from "./primitives.schema.js";
+import { z } from "zod/v4";
+//#region src/model/notices.schema.ts
+/**
+* {@link NoticeKind}
+**/
+const noticeKindSchema = z.union([
+	z.literal("expired"),
+	z.literal("externalRewards"),
+	z.literal("extraApy"),
+	z.literal("warning"),
+	z.literal("disclaimer")
+]);
+/**
+* {@link Notice}
+**/
+const noticeSchema = z.object({
+	kind: noticeKindSchema,
+	message: z.string(),
+	token: tokenSchema.optional()
+});
+//#endregion
+export { noticeKindSchema, noticeSchema };

package/dist/esm/model/opportunities.js

@@ -16,17 +16,17 @@ function poolOpportunityId(chainId, pool) {
 *
 * @example
 * ```ts
-* strategyOpportunityId(1, "0x3eb9...", "0x7f39...") // "1:0x3eb9...:0x7f39..."
+* strategyOpportunityId(1, "0x3eb9...") // "1:0x3eb9..."
 * ```
 **/
-function strategyOpportunityId(chainId, creditManager, targetCollateral) {
-	return `${chainId}:${creditManager.toLowerCase()}:${targetCollateral.toLowerCase()}`;
+function strategyOpportunityId(chainId, creditManager) {
+	return `${chainId}:${creditManager.toLowerCase()}`;
 }
 /**
 * Canonical id of any opportunity, dispatching on {@link Opportunity.kind}.
 **/
 function opportunityId(opportunity) {
-	return opportunity.kind === "pool" ? poolOpportunityId(opportunity.chainId, opportunity.pool) : strategyOpportunityId(opportunity.chainId, opportunity.creditManager, opportunity.targetCollateral.address);
+	return opportunity.kind === "pool" ? poolOpportunityId(opportunity.chainId, opportunity.pool) : strategyOpportunityId(opportunity.chainId, opportunity.creditManager);
 }
 /**
 * Whether an opportunity satisfies every condition of a filter.

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

@@ -1,8 +1,9 @@
 import { ZodAddress } from "../sdk/utils/zod.js";
+import { offchainOnly, tolerance } from "./compare.schema.js";
+import { amountSchema, assetTypeSchema, bpsSchema, chainIdSchema, leverageSchema, timestampSchema, tokenSchema } from "./primitives.schema.js";
 import { curatorSchema } from "./curators.schema.js";
 import { isFilterSet } from "./filters.js";
 import { booleanParamSchema, encodeFlag, filterable } from "./filters.schema.js";
-import { amountSchema, assetTypeSchema, bpsSchema, chainIdSchema, leverageSchema, timestampSchema, tokenSchema } from "./primitives.schema.js";
 import { z } from "zod/v4";
 //#region src/model/opportunities.schema.ts
 /**
@@ -45,9 +46,9 @@ const rewardsSchema = z.discriminatedUnion("kind", [tokenRewardsSchema, pointRew
 * {@link ApyBreakdown}
 **/
 const apyBreakdownSchema = z.object({
-	totalApy: bpsSchema.optional(),
-	organicApy: bpsSchema,
-	rewards: z.array(rewardsSchema).optional()
+	totalApy: offchainOnly(bpsSchema).optional(),
+	organicApy: tolerance(bpsSchema, "bps"),
+	rewards: offchainOnly(z.array(rewardsSchema)).optional()
 });
 /**
 * {@link OpportunityBase}
@@ -70,10 +71,11 @@ const poolOpportunitySchema = z.object({
 	...opportunityBaseSchema.shape,
 	kind: z.literal("pool"),
 	pool: ZodAddress(),
-	totalSupply: amountSchema,
-	availableLiquidity: amountSchema,
-	utilization: bpsSchema,
-	supplyApy: apyBreakdownSchema
+	totalSupply: tolerance(amountSchema, "amount"),
+	availableLiquidity: tolerance(amountSchema, "amount"),
+	utilization: tolerance(bpsSchema, "bps"),
+	supplyApy: apyBreakdownSchema,
+	supplyApyAvg7D: offchainOnly(apyBreakdownSchema).optional()
 });
 /**
 * {@link StrategyOpportunity}
@@ -87,12 +89,19 @@ const strategyOpportunitySchema = z.object({
 	liquidationPremium: bpsSchema,
 	liquidationFee: bpsSchema,
 	expirationDate: timestampSchema.nullable(),
-	collateralApy: apyBreakdownSchema.optional(),
-	maxLeverageApy: apyBreakdownSchema.optional(),
-	borrowApy: bpsSchema.optional(),
-	additionalBorrowApy: bpsSchema.optional(),
-	totalValue: amountSchema.optional(),
-	utilization: bpsSchema.optional(),
+	collateralApy: offchainOnly(apyBreakdownSchema).optional(),
+	collateralApyAvg7D: offchainOnly(apyBreakdownSchema).optional(),
+	maxLeverageApy: offchainOnly(apyBreakdownSchema).optional(),
+	maxLeverageApyAvg7D: offchainOnly(apyBreakdownSchema).optional(),
+	borrowApy: tolerance(bpsSchema, "bps").optional(),
+	borrowApyAvg7D: offchainOnly(bpsSchema).optional(),
+	additionalBorrowApy: tolerance(bpsSchema, "bps").optional(),
+	additionalBorrowApyAvg7D: offchainOnly(bpsSchema).optional(),
+	totalValue: offchainOnly(amountSchema).optional(),
+	utilization: offchainOnly(bpsSchema).optional(),
+	availableLiquidity: tolerance(amountSchema, "amount"),
+	minDebt: amountSchema,
+	totalDebtLimit: amountSchema,
 	maxBorrowAmount: amountSchema,
 	maxLeverage: leverageSchema
 });
@@ -223,8 +232,7 @@ const poolOpportunityKeySchema = z.object({
 **/
 const strategyOpportunityKeySchema = z.object({
 	chainId: chainIdSchema,
-	creditManager: ZodAddress(),
-	targetCollateral: ZodAddress()
+	creditManager: ZodAddress()
 });
 /**
 * {@link OpportunityKey}

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

@@ -1,9 +1,10 @@
-import { ZodAddress } from "../sdk/utils/zod.js";
+import { ZodAddress, ZodBigInt, ZodHex } from "../sdk/utils/zod.js";
+import { offchainOnly, onchainOnly, tolerance } from "./compare.schema.js";
+import { assetTypeSchema, bpsSchema, chainIdSchema, leverageSchema, timestampSchema, tokenAmountSchema, tokenSchema } from "./primitives.schema.js";
 import { isFilterSet } from "./filters.js";
 import { booleanParamSchema, encodeFlag, filterable } from "./filters.schema.js";
-import { assetTypeSchema, bpsSchema, chainIdSchema, leverageSchema, tokenAmountSchema, tokenSchema } from "./primitives.schema.js";
-import { apyBreakdownSchema, pointsProgramSchema } from "./opportunities.schema.js";
 import { delayedReceivedAssetSchema, liquidationPositionSchema } from "./liquidations.schema.js";
+import { apyBreakdownSchema, pointsProgramSchema } from "./opportunities.schema.js";
 import { z } from "zod/v4";
 //#region src/model/positions.schema.ts
 /**
@@ -55,8 +56,8 @@ const pnlBreakdownSchema = z.object({
 * {@link PositionCollateral}
 **/
 const positionCollateralSchema = z.object({
-	collateral: tokenAmountSchema,
-	quota: tokenAmountSchema,
+	collateral: tolerance(tokenAmountSchema, "amount"),
+	quota: tolerance(tokenAmountSchema, "amount"),
 	withdrawals: z.array(delayedReceivedAssetSchema)
 });
 /**
@@ -67,9 +68,26 @@ const poolPositionSchema = z.object({
 	name: z.string(),
 	chainId: chainIdSchema,
 	pool: ZodAddress(),
-	netValue: tokenAmountSchema,
+	netValue: tolerance(tokenAmountSchema, "amount"),
 	apy: apyBreakdownSchema,
-	pnl: pnlBreakdownSchema.optional()
+	apyAvg7D: offchainOnly(apyBreakdownSchema).optional(),
+	pnl: offchainOnly(pnlBreakdownSchema).optional()
+});
+/**
+* {@link TokenQuotaRate}
+**/
+const tokenQuotaRateSchema = z.object({
+	token: tokenSchema,
+	rate: bpsSchema
+});
+/**
+* {@link BorrowRateBreakdown}
+**/
+const borrowRateBreakdownSchema = z.object({
+	total: bpsSchema,
+	totalOnDebt: bpsSchema,
+	base: bpsSchema,
+	quotas: z.array(tokenQuotaRateSchema)
 });
 /**
 * {@link StrategyPosition}
@@ -81,13 +99,19 @@ const strategyPositionSchema = z.object({
 	creditManager: ZodAddress(),
 	creditAccount: ZodAddress(),
 	targetCollateral: tokenSchema.nullable(),
-	leverage: leverageSchema,
-	borrowApy: bpsSchema,
-	netApy: apyBreakdownSchema.optional(),
-	totalDebt: tokenAmountSchema,
-	totalValue: tokenAmountSchema,
-	healthFactor: bpsSchema,
-	pnl: pnlBreakdownSchema.optional(),
+	leverage: tolerance(leverageSchema, "float"),
+	borrowApy: tolerance(bpsSchema, "bps"),
+	borrowApyAvg7D: offchainOnly(bpsSchema).optional(),
+	netApy: offchainOnly(apyBreakdownSchema).optional(),
+	netApyAvg7D: offchainOnly(apyBreakdownSchema).optional(),
+	totalDebt: tolerance(tokenAmountSchema, "amount"),
+	totalValue: tolerance(tokenAmountSchema, "amount"),
+	healthFactor: tolerance(bpsSchema, "bps"),
+	borrowRate: onchainOnly(borrowRateBreakdownSchema).optional(),
+	borrowRateAvg7D: offchainOnly(borrowRateBreakdownSchema).optional(),
+	timeToLiquidation: onchainOnly(ZodBigInt().nullable()).optional(),
+	liquidationPrice: onchainOnly(ZodBigInt().nullable()).optional(),
+	pnl: offchainOnly(pnlBreakdownSchema).optional(),
 	collaterals: z.array(positionCollateralSchema)
 });
 /**
@@ -161,5 +185,35 @@ const positionKeySchema = z.discriminatedUnion("kind", [z.object({
 	kind: z.literal("strategy"),
 	...strategyPositionKeySchema.shape
 })]);
+/**
+* {@link PositionsTotals}
+**/
+const positionsTotalsSchema = z.object({
+	currentYield: apyBreakdownSchema.nullable(),
+	pnl: pnlBreakdownSchema.nullable(),
+	netValueUsd: z.number().nullable(),
+	claimableUsd: z.number().nullable()
+});
+/**
+* {@link PositionTransactionKind}
+**/
+const positionTransactionKindSchema = z.union([
+	z.literal("open"),
+	z.literal("deposit"),
+	z.literal("withdraw"),
+	z.literal("adjustLeverage"),
+	z.literal("addCollateral"),
+	z.literal("withdrawCollateral"),
+	z.literal("liquidation")
+]);
+/**
+* {@link PositionTransaction}
+**/
+const positionTransactionSchema = z.object({
+	txHash: ZodHex(),
+	timestamp: timestampSchema,
+	kind: positionTransactionKindSchema,
+	assets: z.array(tokenAmountSchema)
+});
 //#endregion
-export { pnlBreakdownSchema, pointsProgramPnLSchema, pointsRewardsPnLSchema, poolPositionKeySchema, poolPositionSchema, positionCollateralSchema, positionFilterQueryParamsSchema, positionFilterQuerySchema, positionFilterSchema, positionKeySchema, positionKindSchema, positionSchema, rewardsPnLSchema, strategyPositionKeySchema, strategyPositionSchema, tokenRewardsPnLSchema };
+export { borrowRateBreakdownSchema, pnlBreakdownSchema, pointsProgramPnLSchema, pointsRewardsPnLSchema, poolPositionKeySchema, poolPositionSchema, positionCollateralSchema, positionFilterQueryParamsSchema, positionFilterQuerySchema, positionFilterSchema, positionKeySchema, positionKindSchema, positionSchema, positionTransactionKindSchema, positionTransactionSchema, positionsTotalsSchema, rewardsPnLSchema, strategyPositionKeySchema, strategyPositionSchema, tokenQuotaRateSchema, tokenRewardsPnLSchema };

package/dist/esm/model/previews.js

@@ -0,0 +1,35 @@
+//#region src/model/previews.ts
+/**
+* Broken `storeExpectedBalances`/`compareBalances` bracket structure:
+* `storeExpectedBalances` without a matching `compareBalances`, nested
+* brackets, or `compareBalances` without a preceding `storeExpectedBalances`.
+* We expect transactions that were generated by our frontend using router/withdrawal compressor
+**/
+const ERROR_MALFORMED_BRACKET = 1001;
+/**
+* Adapter call outside a `storeExpectedBalances`/`compareBalances` bracket
+* We expect transactions that were generated by our frontend using router/withdrawal compressor,
+**/
+const ERROR_ADAPTER_CALL_OUTSIDE_BRACKET = 1002;
+/**
+* Bracketed call whose target is not an adapter (or adapter that is not known to the SDK)
+**/
+const ERROR_NON_ADAPTER_CALL_IN_BRACKET = 1003;
+/**
+* Bracketed adapter call cannot be replayed (undecodable/unsupported calldata)
+**/
+const ERROR_UNPREVIEWABLE_ADAPTER_CALL = 1004;
+/**
+* Out-of-bracket RWA wrap/unwrap calldata cannot be decoded
+**/
+const ERROR_UNPREVIEWABLE_RWA_WRAP_UNWRAP = 1005;
+/**
+* `msg.value` does not fit into the declared WETH collateral
+* Transactions can have arbitrary value, but the ones that we create
+* using our frontend should have a value that fits into the declared WETH collateral.
+**/
+const ERROR_INVALID_TRANSACTION_VALUE = 1006;
+/** A token in the preview could not be priced by the oracle */
+const ERROR_UNPRICEABLE_TOKEN = 2001;
+//#endregion
+export { ERROR_ADAPTER_CALL_OUTSIDE_BRACKET, ERROR_INVALID_TRANSACTION_VALUE, ERROR_MALFORMED_BRACKET, ERROR_NON_ADAPTER_CALL_IN_BRACKET, ERROR_UNPREVIEWABLE_ADAPTER_CALL, ERROR_UNPREVIEWABLE_RWA_WRAP_UNWRAP, ERROR_UNPRICEABLE_TOKEN };

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

@@ -1,4 +1,5 @@
 import { ZodAddress, ZodBigInt, ZodHex } from "../sdk/utils/zod.js";
+import { tolerance } from "./compare.schema.js";
 import { z } from "zod/v4";
 //#region src/model/primitives.schema.ts
 /**
@@ -39,7 +40,7 @@ const leverageSchema = z.number().nonnegative();
 **/
 const amountSchema = z.object({
 	value: ZodBigInt(),
-	valueUsd: z.number().nullable()
+	valueUsd: tolerance(z.number().nullable(), "usd")
 });
 /**
 * {@link Token}