@gearbox-protocol/sdk 15.1.0-next.7 → 15.1.0-next.8

package/dist/esm/model/charts.js

@@ -0,0 +1,140 @@
+//#region src/model/charts.ts
+/**
+* Historical charts of an opportunity or a position.
+*
+* Charts are backend-only by construction: the chain serves the present, and
+* reconstructing a series from it would mean archive-node reads per point.
+*
+* A chart is read as a {@link ChartBundle}: one shared x-axis plus one
+* {@link ChartSeries} per metric, each holding values only. Alignment is
+* therefore structural — series `i` and series `j` describe the same instant at
+* the same index — rather than a property the backend promises and every
+* consumer re-checks.
+**/
+/**
+* Time window a chart covers, ending at the present.
+*
+* `"max"` is the full history the backend retains for the subject.
+**/
+const CHART_RANGES = [
+	"1d",
+	"1w",
+	"1m",
+	"1y",
+	"max"
+];
+/**
+* Every metric a pool opportunity can chart.
+**/
+const POOL_OPPORTUNITY_CHART_METRICS = [
+	"depositApy",
+	"borrowApy",
+	"dieselRate",
+	"supplied",
+	"borrowed",
+	"availableLiquidity"
+];
+/**
+* Every metric a strategy opportunity can chart.
+*
+* `collateralPrice` is the collateral/underlying series a liquidation-price
+* chart draws; the two USD series are the same prices quoted in dollars.
+**/
+const STRATEGY_OPPORTUNITY_CHART_METRICS = [
+	"netApy",
+	"borrowApy",
+	"collateralApy",
+	"tvl",
+	"collateralPrice",
+	"collateralUsdPrice",
+	"underlyingUsdPrice"
+];
+/**
+* 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.
+**/
+const POOL_POSITION_CHART_METRICS = [
+	"value",
+	"apy",
+	"pnl",
+	"mwr",
+	"twr",
+	"underlyingPrice"
+];
+/**
+* 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.
+**/
+const STRATEGY_POSITION_CHART_METRICS = [
+	"totalValueUsd",
+	"totalValueUnderlying",
+	"debt",
+	"healthFactor",
+	"leverage",
+	"borrowApy",
+	"underlyingPrice",
+	"pnl",
+	"mwr",
+	"twr",
+	"twrApy",
+	"trailingApy7d",
+	"trailingApy30d"
+];
+/**
+* Unit of every metric, the one place either side decides it.
+*
+* A metric added to a union above fails to compile here until its unit is
+* named, and the wire schema rejects a series whose `unit` disagrees with this
+* table, so the backend cannot drift from it silently.
+**/
+const CHART_METRIC_UNITS = {
+	depositApy: "bps",
+	borrowApy: "bps",
+	netApy: "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"
+};
+/**
+* Reason a series could not be produced at all, which is not the same as a
+* series that has no points in the window.
+**/
+const CHART_UNAVAILABLE_CODES = [
+	"unknown_subject",
+	"unsupported_metric",
+	"no_price_feed",
+	"not_indexed",
+	"internal"
+];
+//#endregion
+export { CHART_METRIC_UNITS, CHART_RANGES, CHART_UNAVAILABLE_CODES, POOL_OPPORTUNITY_CHART_METRICS, POOL_POSITION_CHART_METRICS, STRATEGY_OPPORTUNITY_CHART_METRICS, STRATEGY_POSITION_CHART_METRICS };

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/index.js

@@ -1,17 +1,17 @@
+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 { 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 { 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 { borrowRateBreakdownSchema, 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 { 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, rewardsPnLSchema, strategyPositionKeySchema, strategyPositionSchema, tokenRewardsPnLSchema } from "./positions.schema.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, borrowRateBreakdownSchema, 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, 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, curatorNameSchema, curatorSchema, dataSourceSchema, delayedReceivedAssetSchema, encodeFlag, filterAllSchema, filterable, instantReceivedAssetSchema, isFilterSet, leverageSchema, liquidatableAccountFilterSchema, liquidatableAccountSchema, liquidationApprovalSchema, liquidationDetailsSchema, liquidationPositionId, liquidationPositionSchema, matchesLiquidatableAccountFilter, matchesOpportunityFilter, matchesPositionFilter, 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, priceFeedDataSchema, priceFeedSummarySchema, quotaAssetSchema, rateCurvePointSchema, rateCurveSchema, receivedAssetSchema, responseMetadataSchema, responseSchema, rewardsPnLSchema, rewardsSchema, strategyOpportunityChartMetricSchema, strategyOpportunityDetailSchema, strategyOpportunityId, strategyOpportunityKeySchema, strategyOpportunitySchema, strategyPositionChartMetricSchema, strategyPositionId, strategyPositionKeySchema, strategyPositionSchema, timestampSchema, tokenAmountSchema, tokenRewardsPnLSchema, tokenRewardsSchema, tokenSchema, 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/opportunities.schema.js

@@ -1,8 +1,8 @@
 import { ZodAddress } from "../sdk/utils/zod.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
 /**

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

@@ -1,9 +1,9 @@
 import { ZodAddress, ZodBigInt } from "../sdk/utils/zod.js";
+import { assetTypeSchema, bpsSchema, chainIdSchema, leverageSchema, 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
 /**

package/dist/esm/new-sdk/opportunities/OpportunitiesNamespace.js

@@ -57,12 +57,8 @@ var OpportunitiesNamespace = class extends AbstractNamespace {
 	filter(response, filter) {
 		return filterResponse(response, filter, matchesOpportunityFilter);
 	}
-	history(key) {
-		return { chart: (metric, range) => this.offchain.getHistory({
-			opportunity: key,
-			range,
-			metric
-		}) };
+	async charts(key, metrics, range) {
+		return this.offchain.getCharts(key, metrics, range);
 	}
 };
 //#endregion

package/dist/esm/new-sdk/positions/PositionsNamespace.js

@@ -39,12 +39,8 @@ var PositionsNamespace = class extends AbstractNamespace {
 	filter(response, filter) {
 		return filterResponse(response, filter, matchesPositionFilter);
 	}
-	history(key) {
-		return { chart: (metric, range) => this.offchain.getHistory({
-			position: key,
-			range,
-			metric
-		}) };
+	async charts(key, metrics, range) {
+		return this.offchain.getCharts(key, metrics, range);
 	}
 };
 //#endregion

package/dist/esm/new-sdk/utils/index.js

@@ -1,4 +1,3 @@
 import { filterResponse } from "./filterResponse.js";
-import "./history.js";
 import { DEFAULT_MAX_OFFCHAIN_LAG, mergeChainList, mergeChainOne } from "./mergeChains.js";
 export { DEFAULT_MAX_OFFCHAIN_LAG, filterResponse, mergeChainList, mergeChainOne };

package/dist/esm/offchain/AbstractOffchainNamespace.js

@@ -1,4 +1,4 @@
-import { historySeriesSchema } from "../model/history.schema.js";
+import { chartBundleSchemaFor, chartQueryCodec } from "../model/charts.schema.js";
 import { responseSchema } from "../model/response.schema.js";
 import { OffchainInvalidJsonError } from "./errors/OffchainInvalidJsonError.js";
 import { OffchainNotConfiguredError } from "./errors/OffchainNotConfiguredError.js";
@@ -64,14 +64,17 @@ var AbstractOffchainNamespace = class {
 		};
 	}
 	/**
-	* Reads one historical series. A response carrying a metric other than the
-	* requested one fails validation.
+	* Reads the charts of one subject: one series per metric named, onto the one
+	* grid that lets them be compared at an index.
 	**/
-	async readHistory(request) {
+	async readCharts(path, metrics, range) {
 		return this.get({
-			path: request.path,
-			query: { range: request.range },
-			schema: historySeriesSchema.extend({ metric: z.literal(request.metric) })
+			path,
+			query: z.encode(chartQueryCodec, {
+				metrics,
+				range
+			}),
+			schema: chartBundleSchemaFor(metrics, range)
 		});
 	}
 	/**

package/dist/esm/offchain/opportunities/OffchainOpportunities.js

@@ -43,14 +43,10 @@ var OffchainOpportunities = class extends AbstractOffchainNamespace {
 		});
 	}
 	/**
-	* One historical series of one opportunity
+	* Charts of one opportunity: one series per metric, on a shared grid.
 	**/
-	async getHistory(query) {
-		return this.readHistory({
-			path: `${this.#historyRoot(query.opportunity)}/history/${query.metric}`,
-			metric: query.metric,
-			range: query.range
-		});
+	async getCharts(key, metrics, range) {
+		return this.readCharts(`${this.#chartRoot(key)}/charts`, metrics, range);
 	}
 	#poolPath(key) {
 		return `${this.#root}/pools/${key.chainId}/${key.pool}`;
@@ -58,7 +54,7 @@ var OffchainOpportunities = class extends AbstractOffchainNamespace {
 	#strategyPath(key) {
 		return `${this.#root}/strategies/${key.chainId}/${key.creditManager}/${key.targetCollateral}`;
 	}
-	#historyRoot(key) {
+	#chartRoot(key) {
 		return key.kind === "pool" ? this.#poolPath(key) : this.#strategyPath(key);
 	}
 };

package/dist/esm/offchain/positions/OffchainPositions.js

@@ -1,4 +1,6 @@
 import { positionFilterQuerySchema, positionSchema } from "../../model/positions.schema.js";
+import { OffchainNotImplementedError } from "../errors/OffchainNotImplementedError.js";
+import "../errors/index.js";
 import { AbstractOffchainNamespace } from "../AbstractOffchainNamespace.js";
 import { z } from "zod/v4";
 //#region src/offchain/positions/OffchainPositions.ts
@@ -24,19 +26,14 @@ var OffchainPositions = class extends AbstractOffchainNamespace {
 		});
 	}
 	/**
-	* One historical series of one position.
+	* Charts of one position: one series per metric, on a shared grid.
 	*
-	* @returns An empty series until the backend client is implemented.
+	* @throws {OffchainNotImplementedError} Until the backend serves it. An empty
+	* bundle would be the one answer this model exists to rule out: a chart that
+	* could not be read is not a chart with no points.
 	**/
-	async getHistory(query) {
-		return {
-			data: {
-				metric: query.metric,
-				points: [],
-				metadata: {}
-			},
-			meta: { chains: [] }
-		};
+	async getCharts(key, _metrics, _range) {
+		throw new OffchainNotImplementedError(`${this.#root}/${key.chainId}/charts`);
 	}
 };
 //#endregion