@gearbox-protocol/sdk 18.1.0 → 18.2.0-next.1

package/dist/cjs/permissionless/api/GearboxPermissionless.js

@@ -1,4 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_permissionless_api_analytics_PermissionlessAnalytics = require("./analytics/PermissionlessAnalytics.js");
 const require_permissionless_api_chains_ChainsNamespace = require("./chains/ChainsNamespace.js");
 const require_permissionless_api_deploy_PermissionlessDeploy = require("./deploy/PermissionlessDeploy.js");
 const require_permissionless_api_oracles_PermissionlessOracles = require("./oracles/PermissionlessOracles.js");
@@ -25,11 +26,11 @@ const require_permissionless_api_transactions_InstanceOwnerTransactions = requir
 * const store = await permissionless.oracles.store({ chainId: chain.chainId });
 * ```
 *
-* Only what needs a server goes to one. {@link chains} and {@link oracles}
-* are the backend's reads; {@link deploy} and {@link transactions} read the
-* target chain directly, because everything they answer is derived from there
-* and a round trip would only move the derivation further from the wallet
-* that has to sign for it.
+* Only what needs a server goes to one. {@link chains}, {@link oracles} and
+* {@link analytics} are the backend's reads; {@link deploy} and
+* {@link transactions} read the target chain directly, because everything
+* they answer is derived from there and a round trip would only move the
+* derivation further from the wallet that has to sign for it.
 **/
 var GearboxPermissionless = class {
 	/**
@@ -42,6 +43,11 @@ var GearboxPermissionless = class {
 	**/
 	oracles;
 	/**
+	* Namespace for history: what a feed's price did over a window, see
+	* {@link PermissionlessAnalytics}.
+	**/
+	analytics;
+	/**
 	* Namespace for the Safe batches an instance owner executes. Backend-free,
 	* see {@link InstanceOwnerTransactions}.
 	**/
@@ -54,6 +60,7 @@ var GearboxPermissionless = class {
 	constructor(options = {}) {
 		this.chains = new require_permissionless_api_chains_ChainsNamespace.ChainsNamespace(options);
 		this.oracles = new require_permissionless_api_oracles_PermissionlessOracles.PermissionlessOracles(options, this.chains);
+		this.analytics = new require_permissionless_api_analytics_PermissionlessAnalytics.PermissionlessAnalytics(options);
 		this.transactions = new require_permissionless_api_transactions_InstanceOwnerTransactions.InstanceOwnerTransactions(this.chains, this.oracles);
 		this.deploy = new require_permissionless_api_deploy_PermissionlessDeploy.PermissionlessDeploy(this.chains);
 	}

package/dist/cjs/permissionless/api/analytics/PermissionlessAnalytics.js

@@ -0,0 +1,50 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_offchain_AbstractOffchainNamespace = require("../../../offchain/AbstractOffchainNamespace.js");
+const require_permissionless_api_analytics_schemas = require("./schemas.js");
+//#region src/permissionless/api/analytics/PermissionlessAnalytics.ts
+/**
+* History of the permissionless stack: what a thing did, rather than what it
+* is.
+*
+* Separate from {@link PermissionlessOracles} because the two are read on
+* different clocks. A feed's identity settles when a curator uploads it and
+* is read once per page; its price moves every block and is re-read whenever
+* a window changes. Folding the series into the feed would make every range
+* switch re-fetch the identity, and every identity read carry a series the
+* caller may never draw.
+*
+* ```ts
+* const chart = await permissionless.analytics.priceChart({
+*   chainId: 1,
+*   address: feed,
+*   range: "1w",
+* });
+* ```
+**/
+var PermissionlessAnalytics = class extends require_offchain_AbstractOffchainNamespace.AbstractOffchainNamespace {
+	constructor(options) {
+		super("PermissionlessAnalytics", {
+			...options,
+			chainIds: []
+		});
+	}
+	/**
+	* The price one feed reported over a window.
+	*
+	* Backend-only by construction: the chain serves the present, and
+	* reconstructing a series from it would mean an archive read per point.
+	*
+	* @throws When the PriceFeedStore does not carry the feed. An address the
+	* store never held has no indexed history, and answering an empty series
+	* would read as "no price yet" rather than as the mistake it is.
+	**/
+	async priceChart({ chainId, address, range }) {
+		return this.getData({
+			path: `/pfs/${chainId}/price-feed/${address}/chart`,
+			query: { range },
+			schema: require_permissionless_api_analytics_schemas.priceFeedChartSchema
+		});
+	}
+};
+//#endregion
+exports.PermissionlessAnalytics = PermissionlessAnalytics;

package/dist/cjs/permissionless/api/analytics/index.js

@@ -0,0 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_permissionless_api_analytics_PermissionlessAnalytics = require("./PermissionlessAnalytics.js");
+require("./types.js");
+exports.PermissionlessAnalytics = require_permissionless_api_analytics_PermissionlessAnalytics.PermissionlessAnalytics;

package/dist/cjs/permissionless/api/analytics/schemas.js

@@ -0,0 +1,27 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_model_charts = require("../../../model/charts.js");
+let zod_v4 = require("zod/v4");
+//#region src/permissionless/api/analytics/schemas.ts
+/**
+* Runtime schemas for {@link ./types.js}.
+*
+* Loose for the same reason the oracles schemas are: the backend assembles
+* these rows from its own indexes and may report more about a window than the
+* hand-written types declare.
+**/
+/** {@link PriceFeedChartPoint} */
+const priceFeedChartPointSchema = zod_v4.z.looseObject({
+	timestamp: zod_v4.z.number(),
+	value: zod_v4.z.number()
+});
+/** {@link PriceFeedPriceChart} */
+const priceFeedChartSchema = zod_v4.z.looseObject({
+	range: zod_v4.z.enum(require_model_charts.CHART_RANGES),
+	from: zod_v4.z.number(),
+	to: zod_v4.z.number(),
+	intervalSeconds: zod_v4.z.number(),
+	points: zod_v4.z.array(priceFeedChartPointSchema)
+});
+//#endregion
+exports.priceFeedChartPointSchema = priceFeedChartPointSchema;
+exports.priceFeedChartSchema = priceFeedChartSchema;

package/dist/cjs/permissionless/api/analytics/types.js

@@ -0,0 +1 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });

package/dist/cjs/permissionless/api/index.js

@@ -1,4 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_permissionless_api_analytics_PermissionlessAnalytics = require("./analytics/PermissionlessAnalytics.js");
+require("./analytics/index.js");
 const require_permissionless_api_errors = require("./errors.js");
 const require_permissionless_api_chains_ChainsNamespace = require("./chains/ChainsNamespace.js");
 require("./chains/index.js");
@@ -17,6 +19,7 @@ exports.GET_PRICES_CHUNK_SIZE = require_permissionless_api_oracles_Permissionles
 exports.GET_PRICES_GAS_LIMIT_BY_CHAIN_ID = require_permissionless_api_oracles_PermissionlessOracles.GET_PRICES_GAS_LIMIT_BY_CHAIN_ID;
 exports.GearboxPermissionless = require_permissionless_api_GearboxPermissionless.GearboxPermissionless;
 exports.InstanceOwnerTransactions = require_permissionless_api_transactions_InstanceOwnerTransactions.InstanceOwnerTransactions;
+exports.PermissionlessAnalytics = require_permissionless_api_analytics_PermissionlessAnalytics.PermissionlessAnalytics;
 exports.PermissionlessChainUnreachableError = require_permissionless_api_errors.PermissionlessChainUnreachableError;
 exports.PermissionlessDeploy = require_permissionless_api_deploy_PermissionlessDeploy.PermissionlessDeploy;
 exports.PermissionlessNotAttachedError = require_permissionless_api_errors.PermissionlessNotAttachedError;

package/dist/cjs/permissionless/api/oracles/PermissionlessOracles.js

@@ -1,4 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_model_opportunities_schema = require("../../../model/opportunities.schema.js");
 const require_offchain_AbstractOffchainNamespace = require("../../../offchain/AbstractOffchainNamespace.js");
 const require_permissionless_utils_price_update_get_prices = require("../../utils/price-update/get-prices.js");
 const require_permissionless_api_oracles_schemas = require("./schemas.js");
@@ -37,9 +38,77 @@ var PermissionlessOracles = class extends require_offchain_AbstractOffchainNames
 		});
 	}
 	/**
+	* One feed of the store: what it is, which assets it may price, and which
+	* market slots it currently fills.
+	*
+	* Singular where {@link store} is plural, and not a filter over it: the
+	* store answers what a list renders, while this answers what a feed is used
+	* for, which the store does not carry at all.
+	*
+	* ```ts
+	* const { priceFeed, markets } = await permissionless.oracles.feed({
+	*   chainId: 1,
+	*   address: feed,
+	* });
+	* ```
+	*
+	* @throws When the store does not carry the feed. A private draft is not
+	* here — it lives in whichever app wrote it.
+	**/
+	async feed({ chainId, address }) {
+		return this.getData({
+			path: `/pfs/${chainId}/price-feed/${address}`,
+			schema: require_permissionless_api_oracles_schemas.priceFeedDetailsSchema
+		});
+	}
+	/**
+	* The feeds one feed reads from, recursively.
+	*
+	* Answers for any feed the chain has indexed, store member or not: a
+	* composite feed's children are rarely in the store themselves, and a tree
+	* that stopped at the first of them would not be one.
+	*
+	* ```ts
+	* const tree = await permissionless.oracles.dependencies({
+	*   chainId: 1,
+	*   address: feed,
+	* });
+	* ```
+	**/
+	async dependencies({ chainId, address }) {
+		return this.getData({
+			path: `/pfs/${chainId}/price-feed/${address}/graph`,
+			schema: require_model_opportunities_schema.priceFeedDataSchema
+		});
+	}
+	/**
+	* What the market values each of one feed's assets at.
+	*
+	* Prefer this over {@link prices} whenever the caller is looking at a single
+	* feed. That one prices the whole store, which costs the backend one
+	* `totalSupply` call per asset of every market on the chain; this costs it
+	* one price lookup and one multicall over the feed's own assets.
+	*
+	* ```ts
+	* const { marketCaps } = await permissionless.oracles.feedMarketCaps({
+	*   chainId: 1,
+	*   address: feed,
+	* });
+	* ```
+	**/
+	async feedMarketCaps({ chainId, address }) {
+		return this.getData({
+			path: `/pfs/${chainId}/price-feed/${address}/market-caps`,
+			schema: require_permissionless_api_oracles_schemas.priceFeedMarketCapsSchema
+		});
+	}
+	/**
 	* A price per feed, and a market cap per feed and asset. The feeds the
 	* indexer has not seen are read off the chain by the backend, so the store
 	* is priced whole.
+	*
+	* Chain-wide, and priced accordingly — see {@link feedMarketCaps} for one
+	* feed.
 	**/
 	async prices({ chainId }) {
 		return this.getData({

package/dist/cjs/permissionless/api/oracles/schemas.js

@@ -44,8 +44,44 @@ const pricesSchema = zod_v4.z.looseObject({
 	marketCaps: require_permissionless_api_schemas.addressRecord(require_permissionless_api_schemas.addressRecord(zod_v4.z.string().nullable())),
 	time: zod_v4.z.number()
 });
+/** {@link PermissionlessPriceFeedAsset} */
+const priceFeedAssetSchema = zod_v4.z.looseObject({
+	address: require_permissionless_api_schemas.addressSchema,
+	symbol: zod_v4.z.string(),
+	name: zod_v4.z.string(),
+	decimals: zod_v4.z.number()
+});
+/** {@link PermissionlessPriceFeedMarket} */
+const priceFeedMarketSchema = zod_v4.z.looseObject({
+	market: require_permissionless_api_schemas.addressSchema,
+	marketConfigurator: require_permissionless_api_schemas.addressSchema,
+	curatorName: zod_v4.z.string().nullable(),
+	marketName: zod_v4.z.string().nullable(),
+	token: require_permissionless_api_schemas.addressSchema,
+	tokenSymbol: zod_v4.z.string().nullable(),
+	underlyingSymbol: zod_v4.z.string().nullable(),
+	reserve: zod_v4.z.boolean(),
+	isUnderlying: zod_v4.z.boolean(),
+	quotaLimit: zod_v4.z.number().nullable()
+});
+/** {@link PermissionlessPriceFeedDetails} */
+const priceFeedDetailsSchema = zod_v4.z.looseObject({
+	chainId: zod_v4.z.number(),
+	priceFeed: priceFeedSchema,
+	assets: zod_v4.z.array(priceFeedAssetSchema),
+	markets: zod_v4.z.array(priceFeedMarketSchema)
+});
+/** {@link PermissionlessPriceFeedMarketCaps} */
+const priceFeedMarketCapsSchema = zod_v4.z.looseObject({
+	marketCaps: require_permissionless_api_schemas.addressRecord(zod_v4.z.string().nullable()),
+	time: zod_v4.z.number()
+});
 //#endregion
 exports.assetSchema = assetSchema;
+exports.priceFeedAssetSchema = priceFeedAssetSchema;
+exports.priceFeedDetailsSchema = priceFeedDetailsSchema;
+exports.priceFeedMarketCapsSchema = priceFeedMarketCapsSchema;
+exports.priceFeedMarketSchema = priceFeedMarketSchema;
 exports.priceFeedSchema = priceFeedSchema;
 exports.priceFeedStoreSchema = priceFeedStoreSchema;
 exports.pricesSchema = pricesSchema;

package/dist/cjs/permissionless/index.js

@@ -1,4 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_permissionless_api_analytics_PermissionlessAnalytics = require("./api/analytics/PermissionlessAnalytics.js");
 const require_permissionless_api_errors = require("./api/errors.js");
 const require_permissionless_api_chains_ChainsNamespace = require("./api/chains/ChainsNamespace.js");
 const require_permissionless_api_deploy_effective_staleness = require("./api/deploy/effective-staleness.js");
@@ -68,6 +69,7 @@ exports.MarketConfiguratorContract = require_permissionless_bindings_market_conf
 exports.MarketConfiguratorFactoryContract = require_permissionless_bindings_market_configurator_factory.MarketConfiguratorFactoryContract;
 exports.PRICE_FEED_STORE = require_permissionless_utils_literals.PRICE_FEED_STORE;
 exports.PUBLIC_CREATE2_FACTORY = require_permissionless_utils_create2.PUBLIC_CREATE2_FACTORY;
+exports.PermissionlessAnalytics = require_permissionless_api_analytics_PermissionlessAnalytics.PermissionlessAnalytics;
 exports.PermissionlessChainUnreachableError = require_permissionless_api_errors.PermissionlessChainUnreachableError;
 exports.PermissionlessDeploy = require_permissionless_api_deploy_PermissionlessDeploy.PermissionlessDeploy;
 exports.PermissionlessNotAttachedError = require_permissionless_api_errors.PermissionlessNotAttachedError;

package/dist/esm/permissionless/api/GearboxPermissionless.js

@@ -1,3 +1,4 @@
+import { PermissionlessAnalytics } from "./analytics/PermissionlessAnalytics.js";
 import { ChainsNamespace } from "./chains/ChainsNamespace.js";
 import { PermissionlessDeploy } from "./deploy/PermissionlessDeploy.js";
 import { PermissionlessOracles } from "./oracles/PermissionlessOracles.js";
@@ -24,11 +25,11 @@ import { InstanceOwnerTransactions } from "./transactions/InstanceOwnerTransacti
 * const store = await permissionless.oracles.store({ chainId: chain.chainId });
 * ```
 *
-* Only what needs a server goes to one. {@link chains} and {@link oracles}
-* are the backend's reads; {@link deploy} and {@link transactions} read the
-* target chain directly, because everything they answer is derived from there
-* and a round trip would only move the derivation further from the wallet
-* that has to sign for it.
+* Only what needs a server goes to one. {@link chains}, {@link oracles} and
+* {@link analytics} are the backend's reads; {@link deploy} and
+* {@link transactions} read the target chain directly, because everything
+* they answer is derived from there and a round trip would only move the
+* derivation further from the wallet that has to sign for it.
 **/
 var GearboxPermissionless = class {
 	/**
@@ -41,6 +42,11 @@ var GearboxPermissionless = class {
 	**/
 	oracles;
 	/**
+	* Namespace for history: what a feed's price did over a window, see
+	* {@link PermissionlessAnalytics}.
+	**/
+	analytics;
+	/**
 	* Namespace for the Safe batches an instance owner executes. Backend-free,
 	* see {@link InstanceOwnerTransactions}.
 	**/
@@ -53,6 +59,7 @@ var GearboxPermissionless = class {
 	constructor(options = {}) {
 		this.chains = new ChainsNamespace(options);
 		this.oracles = new PermissionlessOracles(options, this.chains);
+		this.analytics = new PermissionlessAnalytics(options);
 		this.transactions = new InstanceOwnerTransactions(this.chains, this.oracles);
 		this.deploy = new PermissionlessDeploy(this.chains);
 	}

package/dist/esm/permissionless/api/analytics/PermissionlessAnalytics.js

@@ -0,0 +1,49 @@
+import { AbstractOffchainNamespace } from "../../../offchain/AbstractOffchainNamespace.js";
+import { priceFeedChartSchema } from "./schemas.js";
+//#region src/permissionless/api/analytics/PermissionlessAnalytics.ts
+/**
+* History of the permissionless stack: what a thing did, rather than what it
+* is.
+*
+* Separate from {@link PermissionlessOracles} because the two are read on
+* different clocks. A feed's identity settles when a curator uploads it and
+* is read once per page; its price moves every block and is re-read whenever
+* a window changes. Folding the series into the feed would make every range
+* switch re-fetch the identity, and every identity read carry a series the
+* caller may never draw.
+*
+* ```ts
+* const chart = await permissionless.analytics.priceChart({
+*   chainId: 1,
+*   address: feed,
+*   range: "1w",
+* });
+* ```
+**/
+var PermissionlessAnalytics = class extends AbstractOffchainNamespace {
+	constructor(options) {
+		super("PermissionlessAnalytics", {
+			...options,
+			chainIds: []
+		});
+	}
+	/**
+	* The price one feed reported over a window.
+	*
+	* Backend-only by construction: the chain serves the present, and
+	* reconstructing a series from it would mean an archive read per point.
+	*
+	* @throws When the PriceFeedStore does not carry the feed. An address the
+	* store never held has no indexed history, and answering an empty series
+	* would read as "no price yet" rather than as the mistake it is.
+	**/
+	async priceChart({ chainId, address, range }) {
+		return this.getData({
+			path: `/pfs/${chainId}/price-feed/${address}/chart`,
+			query: { range },
+			schema: priceFeedChartSchema
+		});
+	}
+};
+//#endregion
+export { PermissionlessAnalytics };

package/dist/esm/permissionless/api/analytics/index.js

@@ -0,0 +1,2 @@
+export { PermissionlessAnalytics } from "./PermissionlessAnalytics.js";
+import "./types.js";

package/dist/esm/permissionless/api/analytics/schemas.js

@@ -0,0 +1,25 @@
+import { CHART_RANGES } from "../../../model/charts.js";
+import { z } from "zod/v4";
+//#region src/permissionless/api/analytics/schemas.ts
+/**
+* Runtime schemas for {@link ./types.js}.
+*
+* Loose for the same reason the oracles schemas are: the backend assembles
+* these rows from its own indexes and may report more about a window than the
+* hand-written types declare.
+**/
+/** {@link PriceFeedChartPoint} */
+const priceFeedChartPointSchema = z.looseObject({
+	timestamp: z.number(),
+	value: z.number()
+});
+/** {@link PriceFeedPriceChart} */
+const priceFeedChartSchema = z.looseObject({
+	range: z.enum(CHART_RANGES),
+	from: z.number(),
+	to: z.number(),
+	intervalSeconds: z.number(),
+	points: z.array(priceFeedChartPointSchema)
+});
+//#endregion
+export { priceFeedChartPointSchema, priceFeedChartSchema };

package/dist/esm/permissionless/api/analytics/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/permissionless/api/index.js

@@ -1,3 +1,5 @@
+import { PermissionlessAnalytics } from "./analytics/PermissionlessAnalytics.js";
+import "./analytics/index.js";
 import { PermissionlessChainUnreachableError, PermissionlessNotAttachedError, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError } from "./errors.js";
 import { ChainsNamespace } from "./chains/ChainsNamespace.js";
 import "./chains/index.js";
@@ -10,4 +12,4 @@ import { GearboxPermissionless } from "./GearboxPermissionless.js";
 import "./oracles/index.js";
 import "./transactions/index.js";
 import "./types.js";
-export { ChainsNamespace, DEFAULT_DEPLOY_SALT, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GearboxPermissionless, InstanceOwnerTransactions, PermissionlessChainUnreachableError, PermissionlessDeploy, PermissionlessNotAttachedError, PermissionlessOracles, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError, deriveEffectiveStalenessPeriod, priceFeedSalt };
+export { ChainsNamespace, DEFAULT_DEPLOY_SALT, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GearboxPermissionless, InstanceOwnerTransactions, PermissionlessAnalytics, PermissionlessChainUnreachableError, PermissionlessDeploy, PermissionlessNotAttachedError, PermissionlessOracles, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError, deriveEffectiveStalenessPeriod, priceFeedSalt };

package/dist/esm/permissionless/api/oracles/PermissionlessOracles.js

@@ -1,6 +1,7 @@
+import { priceFeedDataSchema } from "../../../model/opportunities.schema.js";
 import { AbstractOffchainNamespace } from "../../../offchain/AbstractOffchainNamespace.js";
 import { getPrices } from "../../utils/price-update/get-prices.js";
-import { priceFeedStoreSchema, pricesSchema } from "./schemas.js";
+import { priceFeedDetailsSchema, priceFeedMarketCapsSchema, priceFeedStoreSchema, pricesSchema } from "./schemas.js";
 //#region src/permissionless/api/oracles/PermissionlessOracles.ts
 const GET_PRICES_GAS_LIMIT_BY_CHAIN_ID = { 143: 100000000n };
 const GET_PRICES_CHUNK_SIZE = 200;
@@ -36,9 +37,77 @@ var PermissionlessOracles = class extends AbstractOffchainNamespace {
 		});
 	}
 	/**
+	* One feed of the store: what it is, which assets it may price, and which
+	* market slots it currently fills.
+	*
+	* Singular where {@link store} is plural, and not a filter over it: the
+	* store answers what a list renders, while this answers what a feed is used
+	* for, which the store does not carry at all.
+	*
+	* ```ts
+	* const { priceFeed, markets } = await permissionless.oracles.feed({
+	*   chainId: 1,
+	*   address: feed,
+	* });
+	* ```
+	*
+	* @throws When the store does not carry the feed. A private draft is not
+	* here — it lives in whichever app wrote it.
+	**/
+	async feed({ chainId, address }) {
+		return this.getData({
+			path: `/pfs/${chainId}/price-feed/${address}`,
+			schema: priceFeedDetailsSchema
+		});
+	}
+	/**
+	* The feeds one feed reads from, recursively.
+	*
+	* Answers for any feed the chain has indexed, store member or not: a
+	* composite feed's children are rarely in the store themselves, and a tree
+	* that stopped at the first of them would not be one.
+	*
+	* ```ts
+	* const tree = await permissionless.oracles.dependencies({
+	*   chainId: 1,
+	*   address: feed,
+	* });
+	* ```
+	**/
+	async dependencies({ chainId, address }) {
+		return this.getData({
+			path: `/pfs/${chainId}/price-feed/${address}/graph`,
+			schema: priceFeedDataSchema
+		});
+	}
+	/**
+	* What the market values each of one feed's assets at.
+	*
+	* Prefer this over {@link prices} whenever the caller is looking at a single
+	* feed. That one prices the whole store, which costs the backend one
+	* `totalSupply` call per asset of every market on the chain; this costs it
+	* one price lookup and one multicall over the feed's own assets.
+	*
+	* ```ts
+	* const { marketCaps } = await permissionless.oracles.feedMarketCaps({
+	*   chainId: 1,
+	*   address: feed,
+	* });
+	* ```
+	**/
+	async feedMarketCaps({ chainId, address }) {
+		return this.getData({
+			path: `/pfs/${chainId}/price-feed/${address}/market-caps`,
+			schema: priceFeedMarketCapsSchema
+		});
+	}
+	/**
 	* A price per feed, and a market cap per feed and asset. The feeds the
 	* indexer has not seen are read off the chain by the backend, so the store
 	* is priced whole.
+	*
+	* Chain-wide, and priced accordingly — see {@link feedMarketCaps} for one
+	* feed.
 	**/
 	async prices({ chainId }) {
 		return this.getData({

package/dist/esm/permissionless/api/oracles/schemas.js

@@ -43,5 +43,37 @@ const pricesSchema = z.looseObject({
 	marketCaps: addressRecord(addressRecord(z.string().nullable())),
 	time: z.number()
 });
+/** {@link PermissionlessPriceFeedAsset} */
+const priceFeedAssetSchema = z.looseObject({
+	address: addressSchema,
+	symbol: z.string(),
+	name: z.string(),
+	decimals: z.number()
+});
+/** {@link PermissionlessPriceFeedMarket} */
+const priceFeedMarketSchema = z.looseObject({
+	market: addressSchema,
+	marketConfigurator: addressSchema,
+	curatorName: z.string().nullable(),
+	marketName: z.string().nullable(),
+	token: addressSchema,
+	tokenSymbol: z.string().nullable(),
+	underlyingSymbol: z.string().nullable(),
+	reserve: z.boolean(),
+	isUnderlying: z.boolean(),
+	quotaLimit: z.number().nullable()
+});
+/** {@link PermissionlessPriceFeedDetails} */
+const priceFeedDetailsSchema = z.looseObject({
+	chainId: z.number(),
+	priceFeed: priceFeedSchema,
+	assets: z.array(priceFeedAssetSchema),
+	markets: z.array(priceFeedMarketSchema)
+});
+/** {@link PermissionlessPriceFeedMarketCaps} */
+const priceFeedMarketCapsSchema = z.looseObject({
+	marketCaps: addressRecord(z.string().nullable()),
+	time: z.number()
+});
 //#endregion
-export { assetSchema, priceFeedSchema, priceFeedStoreSchema, pricesSchema };
+export { assetSchema, priceFeedAssetSchema, priceFeedDetailsSchema, priceFeedMarketCapsSchema, priceFeedMarketSchema, priceFeedSchema, priceFeedStoreSchema, pricesSchema };

package/dist/esm/permissionless/index.js

@@ -1,3 +1,4 @@
+import { PermissionlessAnalytics } from "./api/analytics/PermissionlessAnalytics.js";
 import { PermissionlessChainUnreachableError, PermissionlessNotAttachedError, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError } from "./api/errors.js";
 import { ChainsNamespace } from "./api/chains/ChainsNamespace.js";
 import { deriveEffectiveStalenessPeriod } from "./api/deploy/effective-staleness.js";
@@ -40,4 +41,4 @@ import { getBlockNumberByTimestamp } from "./utils/block-utils.js";
 import { convertQueueBatchToExecuteTx } from "./utils/governance/timelock-txs.js";
 import { getPriceUpdateTx } from "./utils/price-update/get-price-update-tx.js";
 import "./utils/index.js";
-export { AccessMode, AddressProviderContract, Addresses, ArchiveTransport, BYTECODE_REPOSITORY, BytecodeRepositoryContract, CROSS_CHAIN_GOVERNANCE, CROSS_CHAIN_MULTISIG, ChainsNamespace, CrossChainMultisigContract, DEFAULT_DEPLOY_SALT, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GearboxPermissionless, GovernorContract, INSTANCE_MANAGER, InstanceManagerContract, InstanceOwnerTransactions, MAINNET_CCM_CONSTRUCTOR_PARAMS, MAINNET_DEPLOYMENT_BLOCK, MAINNET_DEPLOYMENT_CCM_SALT, MAINNET_DEPLOYMENT_IM_SALT, MARKET_CONFIGURATOR_FACTORY, MarketConfiguratorContract, MarketConfiguratorFactoryContract, PRICE_FEED_STORE, PUBLIC_CREATE2_FACTORY, PermissionlessChainUnreachableError, PermissionlessDeploy, PermissionlessNotAttachedError, PermissionlessOracles, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError, PriceFeedStoreContract, RoutingManagerContract, TOKEN_COMPRESSOR, TimeLockContract, TokenCompressorContract, TreasurySplitterContract, WithdrawalCompressorContract, calculateChecksum, checkCreate2Deployment, checkCreate2DeploymentAddress, chunkedLogsTransport, convertPercent, convertQueueBatchToExecuteTx, convertRawTxToSafeMultisigTx, createCallData, createCreate2DeployRawTx, deepJsonParse, deployUsingPublicCreate2, deriveEffectiveStalenessPeriod, encodeFunctionParams, formatBytecodeSize, formatBytecodeVersion, getBlockNumberByTimestamp, getCreate2AddressPublicFactory, getCreate2DeploymentAddress, getPriceUpdateTx, getPrices, getSafeBatch, getSafeBatches, getUpdatablePriceFeeds, handleSalt, normalizeSignature, priceFeedSalt, priceFeedSetupParams, shortenHash, significantTrunc };
+export { AccessMode, AddressProviderContract, Addresses, ArchiveTransport, BYTECODE_REPOSITORY, BytecodeRepositoryContract, CROSS_CHAIN_GOVERNANCE, CROSS_CHAIN_MULTISIG, ChainsNamespace, CrossChainMultisigContract, DEFAULT_DEPLOY_SALT, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GearboxPermissionless, GovernorContract, INSTANCE_MANAGER, InstanceManagerContract, InstanceOwnerTransactions, MAINNET_CCM_CONSTRUCTOR_PARAMS, MAINNET_DEPLOYMENT_BLOCK, MAINNET_DEPLOYMENT_CCM_SALT, MAINNET_DEPLOYMENT_IM_SALT, MARKET_CONFIGURATOR_FACTORY, MarketConfiguratorContract, MarketConfiguratorFactoryContract, PRICE_FEED_STORE, PUBLIC_CREATE2_FACTORY, PermissionlessAnalytics, PermissionlessChainUnreachableError, PermissionlessDeploy, PermissionlessNotAttachedError, PermissionlessOracles, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError, PriceFeedStoreContract, RoutingManagerContract, TOKEN_COMPRESSOR, TimeLockContract, TokenCompressorContract, TreasurySplitterContract, WithdrawalCompressorContract, calculateChecksum, checkCreate2Deployment, checkCreate2DeploymentAddress, chunkedLogsTransport, convertPercent, convertQueueBatchToExecuteTx, convertRawTxToSafeMultisigTx, createCallData, createCreate2DeployRawTx, deepJsonParse, deployUsingPublicCreate2, deriveEffectiveStalenessPeriod, encodeFunctionParams, formatBytecodeSize, formatBytecodeVersion, getBlockNumberByTimestamp, getCreate2AddressPublicFactory, getCreate2DeploymentAddress, getPriceUpdateTx, getPrices, getSafeBatch, getSafeBatches, getUpdatablePriceFeeds, handleSalt, normalizeSignature, priceFeedSalt, priceFeedSetupParams, shortenHash, significantTrunc };

package/dist/types/permissionless/api/GearboxPermissionless.d.ts

@@ -1,4 +1,5 @@
 import { GearboxPermissionlessOptions } from "./types.js";
+import { PermissionlessAnalytics } from "./analytics/PermissionlessAnalytics.js";
 import { AttachChainsArgs } from "./chains/types.js";
 import { ChainsNamespace } from "./chains/ChainsNamespace.js";
 import { PermissionlessDeploy } from "./deploy/PermissionlessDeploy.js";
@@ -26,11 +27,11 @@ import { InstanceOwnerTransactions } from "./transactions/InstanceOwnerTransacti
  * const store = await permissionless.oracles.store({ chainId: chain.chainId });
  * ```
  *
- * Only what needs a server goes to one. {@link chains} and {@link oracles}
- * are the backend's reads; {@link deploy} and {@link transactions} read the
- * target chain directly, because everything they answer is derived from there
- * and a round trip would only move the derivation further from the wallet
- * that has to sign for it.
+ * Only what needs a server goes to one. {@link chains}, {@link oracles} and
+ * {@link analytics} are the backend's reads; {@link deploy} and
+ * {@link transactions} read the target chain directly, because everything
+ * they answer is derived from there and a round trip would only move the
+ * derivation further from the wallet that has to sign for it.
  **/
 export declare class GearboxPermissionless {
   /**
@@ -42,6 +43,11 @@ export declare class GearboxPermissionless {
    * Namespace for price feeds: the store and its prices.
    **/
   readonly oracles: PermissionlessOracles;
+  /**
+   * Namespace for history: what a feed's price did over a window, see
+   * {@link PermissionlessAnalytics}.
+   **/
+  readonly analytics: PermissionlessAnalytics;
   /**
    * Namespace for the Safe batches an instance owner executes. Backend-free,
    * see {@link InstanceOwnerTransactions}.

package/dist/types/permissionless/api/analytics/PermissionlessAnalytics.d.ts

@@ -0,0 +1,38 @@
+import { AbstractOffchainNamespace } from "../../../offchain/AbstractOffchainNamespace.js";
+import { GearboxPermissionlessOptions } from "../types.js";
+import { PriceChartArgs, PriceFeedPriceChart } from "./types.js";
+//#region src/permissionless/api/analytics/PermissionlessAnalytics.d.ts
+/**
+ * History of the permissionless stack: what a thing did, rather than what it
+ * is.
+ *
+ * Separate from {@link PermissionlessOracles} because the two are read on
+ * different clocks. A feed's identity settles when a curator uploads it and
+ * is read once per page; its price moves every block and is re-read whenever
+ * a window changes. Folding the series into the feed would make every range
+ * switch re-fetch the identity, and every identity read carry a series the
+ * caller may never draw.
+ *
+ * ```ts
+ * const chart = await permissionless.analytics.priceChart({
+ *   chainId: 1,
+ *   address: feed,
+ *   range: "1w",
+ * });
+ * ```
+ **/
+export declare class PermissionlessAnalytics extends AbstractOffchainNamespace {
+  constructor(options: GearboxPermissionlessOptions);
+  /**
+   * The price one feed reported over a window.
+   *
+   * Backend-only by construction: the chain serves the present, and
+   * reconstructing a series from it would mean an archive read per point.
+   *
+   * @throws When the PriceFeedStore does not carry the feed. An address the
+   * store never held has no indexed history, and answering an empty series
+   * would read as "no price yet" rather than as the mistake it is.
+   **/
+  priceChart({ chainId, address, range }: PriceChartArgs): Promise<PriceFeedPriceChart>;
+}
+//#endregion

package/dist/types/permissionless/api/analytics/index.d.ts

@@ -0,0 +1,3 @@
+import { PriceChartArgs, PriceFeedChartPoint, PriceFeedPriceChart } from "./types.js";
+import { PermissionlessAnalytics } from "./PermissionlessAnalytics.js";
+export { PermissionlessAnalytics, PriceChartArgs, PriceFeedChartPoint, PriceFeedPriceChart };

package/dist/types/permissionless/api/analytics/schemas.d.ts

@@ -0,0 +1,32 @@
+import { z } from "zod/v4";
+//#region src/permissionless/api/analytics/schemas.d.ts
+/**
+ * Runtime schemas for {@link ./types.js}.
+ *
+ * Loose for the same reason the oracles schemas are: the backend assembles
+ * these rows from its own indexes and may report more about a window than the
+ * hand-written types declare.
+ **/
+/** {@link PriceFeedChartPoint} */
+export declare const priceFeedChartPointSchema: z.ZodObject<{
+  timestamp: z.ZodNumber;
+  value: z.ZodNumber;
+}, z.core.$loose>;
+/** {@link PriceFeedPriceChart} */
+export declare const priceFeedChartSchema: z.ZodObject<{
+  range: z.ZodEnum<{
+    "1d": "1d";
+    "1m": "1m";
+    "1w": "1w";
+    "1y": "1y";
+    max: "max";
+  }>;
+  from: z.ZodNumber;
+  to: z.ZodNumber;
+  intervalSeconds: z.ZodNumber;
+  points: z.ZodArray<z.ZodObject<{
+    timestamp: z.ZodNumber;
+    value: z.ZodNumber;
+  }, z.core.$loose>>;
+}, z.core.$loose>;
+//#endregion

package/dist/types/permissionless/api/analytics/types.d.ts

@@ -0,0 +1,38 @@
+import { Timestamp } from "../../../model/primitives.js";
+import { ChartRange } from "../../../model/charts.js";
+import { Address } from "viem";
+//#region src/permissionless/api/analytics/types.d.ts
+/** One sampled price, in whole US dollars. */
+export interface PriceFeedChartPoint {
+  timestamp: Timestamp;
+  value: number;
+}
+/**
+ * A feed's price over one window, sampled onto an epoch-aligned grid.
+ *
+ * Only the buckets with an observation are present: a gap is an absent point,
+ * never a zero and never a value carried over from a neighbour. The window is
+ * echoed back because `max` resolves against the feed's own first observation
+ * and is therefore not derivable from the range alone.
+ *
+ * Deliberately not a {@link ChartBundle}. A bundle carries one series per
+ * {@link ChartMetric}, and that union is closed over what the read model
+ * charts — a price feed's own price is not one of them, and widening it would
+ * reach every chart the protocol serves to add a series only this page draws.
+ **/
+export interface PriceFeedPriceChart {
+  range: ChartRange;
+  from: Timestamp;
+  to: Timestamp;
+  /** Distance between two consecutive buckets. */
+  intervalSeconds: number;
+  points: PriceFeedChartPoint[];
+}
+/** Args of {@link PermissionlessAnalytics.priceChart}. */
+export interface PriceChartArgs {
+  chainId: number;
+  address: Address;
+  /** Window to cover. The same set every other Gearbox chart offers. */
+  range: ChartRange;
+}
+//#endregion

package/dist/types/permissionless/api/index.d.ts

@@ -1,17 +1,20 @@
 import { GearboxPermissionlessOptions } from "./types.js";
+import { PriceChartArgs, PriceFeedChartPoint, PriceFeedPriceChart } from "./analytics/types.js";
+import { PermissionlessAnalytics } from "./analytics/PermissionlessAnalytics.js";
 import { AttachChainsArgs, ChainScope, ChainSummaryArgs, PermissionlessChain, PermissionlessChainSummary } from "./chains/types.js";
 import { ChainsNamespace } from "./chains/ChainsNamespace.js";
 import { DeployArgs, DeployContractArgs, DeployPriceFeedArgs, PreparedDeployment, PreparedPriceFeedDeployment } from "./deploy/types.js";
 import { DEFAULT_DEPLOY_SALT, PermissionlessDeploy, priceFeedSalt } from "./deploy/PermissionlessDeploy.js";
-import { GetPricesArgs, PermissionlessAsset, PermissionlessPriceFeedStore, PermissionlessPrices } from "./oracles/types.js";
+import { GetPricesArgs, PermissionlessAsset, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedMarketCaps, PermissionlessPriceFeedStore, PermissionlessPrices, PriceFeedArgs } from "./oracles/types.js";
 import { GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, PermissionlessOracles } from "./oracles/PermissionlessOracles.js";
 import { AddFeedsArgs, ChangeNamesArgs, ChangeStalenessPeriodsArgs, ForbidFeedsArgs, InstanceTxsArgs, PriceFeedPair } from "./transactions/types.js";
 import { InstanceOwnerTransactions } from "./transactions/InstanceOwnerTransactions.js";
 import { GearboxPermissionless } from "./GearboxPermissionless.js";
+import "./analytics/index.js";
 import "./chains/index.js";
 import { deriveEffectiveStalenessPeriod } from "./deploy/effective-staleness.js";
 import "./deploy/index.js";
 import { PermissionlessChainUnreachableError, PermissionlessNotAttachedError, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError } from "./errors.js";
 import "./oracles/index.js";
 import "./transactions/index.js";
-export { AddFeedsArgs, AttachChainsArgs, ChainScope, ChainSummaryArgs, ChainsNamespace, ChangeNamesArgs, ChangeStalenessPeriodsArgs, DEFAULT_DEPLOY_SALT, DeployArgs, DeployContractArgs, DeployPriceFeedArgs, ForbidFeedsArgs, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GearboxPermissionless, GearboxPermissionlessOptions, GetPricesArgs, InstanceOwnerTransactions, InstanceTxsArgs, PermissionlessAsset, PermissionlessChain, PermissionlessChainSummary, PermissionlessChainUnreachableError, PermissionlessDeploy, PermissionlessNotAttachedError, PermissionlessOracles, PermissionlessPriceFeedStore, PermissionlessPrices, PreparedDeployment, PreparedPriceFeedDeployment, PriceFeedNotInStoreError, PriceFeedPair, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError, deriveEffectiveStalenessPeriod, priceFeedSalt };
+export { AddFeedsArgs, AttachChainsArgs, ChainScope, ChainSummaryArgs, ChainsNamespace, ChangeNamesArgs, ChangeStalenessPeriodsArgs, DEFAULT_DEPLOY_SALT, DeployArgs, DeployContractArgs, DeployPriceFeedArgs, ForbidFeedsArgs, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GearboxPermissionless, GearboxPermissionlessOptions, GetPricesArgs, InstanceOwnerTransactions, InstanceTxsArgs, PermissionlessAnalytics, PermissionlessAsset, PermissionlessChain, PermissionlessChainSummary, PermissionlessChainUnreachableError, PermissionlessDeploy, PermissionlessNotAttachedError, PermissionlessOracles, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedMarketCaps, PermissionlessPriceFeedStore, PermissionlessPrices, PreparedDeployment, PreparedPriceFeedDeployment, PriceChartArgs, PriceFeedArgs, PriceFeedChartPoint, PriceFeedNotInStoreError, PriceFeedPair, PriceFeedPriceChart, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError, deriveEffectiveStalenessPeriod, priceFeedSalt };

package/dist/types/permissionless/api/oracles/PermissionlessOracles.d.ts

@@ -1,7 +1,8 @@
+import { PriceFeedData } from "../../../model/opportunities.js";
 import { AbstractOffchainNamespace } from "../../../offchain/AbstractOffchainNamespace.js";
 import { GearboxPermissionlessOptions } from "../types.js";
 import { ChainsNamespace } from "../chains/ChainsNamespace.js";
-import { GetPricesArgs, PermissionlessPriceFeedStore, PermissionlessPrices } from "./types.js";
+import { GetPricesArgs, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarketCaps, PermissionlessPriceFeedStore, PermissionlessPrices, PriceFeedArgs } from "./types.js";
 import { Address } from "viem";
 //#region src/permissionless/api/oracles/PermissionlessOracles.d.ts
 export declare const GET_PRICES_GAS_LIMIT_BY_CHAIN_ID: Record<number, bigint>;
@@ -28,10 +29,63 @@ export declare class PermissionlessOracles extends AbstractOffchainNamespace {
   store({ chainId }: {
     chainId: number;
   }): Promise<PermissionlessPriceFeedStore>;
+  /**
+   * One feed of the store: what it is, which assets it may price, and which
+   * market slots it currently fills.
+   *
+   * Singular where {@link store} is plural, and not a filter over it: the
+   * store answers what a list renders, while this answers what a feed is used
+   * for, which the store does not carry at all.
+   *
+   * ```ts
+   * const { priceFeed, markets } = await permissionless.oracles.feed({
+   *   chainId: 1,
+   *   address: feed,
+   * });
+   * ```
+   *
+   * @throws When the store does not carry the feed. A private draft is not
+   * here — it lives in whichever app wrote it.
+   **/
+  feed({ chainId, address }: PriceFeedArgs): Promise<PermissionlessPriceFeedDetails>;
+  /**
+   * The feeds one feed reads from, recursively.
+   *
+   * Answers for any feed the chain has indexed, store member or not: a
+   * composite feed's children are rarely in the store themselves, and a tree
+   * that stopped at the first of them would not be one.
+   *
+   * ```ts
+   * const tree = await permissionless.oracles.dependencies({
+   *   chainId: 1,
+   *   address: feed,
+   * });
+   * ```
+   **/
+  dependencies({ chainId, address }: PriceFeedArgs): Promise<PriceFeedData>;
+  /**
+   * What the market values each of one feed's assets at.
+   *
+   * Prefer this over {@link prices} whenever the caller is looking at a single
+   * feed. That one prices the whole store, which costs the backend one
+   * `totalSupply` call per asset of every market on the chain; this costs it
+   * one price lookup and one multicall over the feed's own assets.
+   *
+   * ```ts
+   * const { marketCaps } = await permissionless.oracles.feedMarketCaps({
+   *   chainId: 1,
+   *   address: feed,
+   * });
+   * ```
+   **/
+  feedMarketCaps({ chainId, address }: PriceFeedArgs): Promise<PermissionlessPriceFeedMarketCaps>;
   /**
    * A price per feed, and a market cap per feed and asset. The feeds the
    * indexer has not seen are read off the chain by the backend, so the store
    * is priced whole.
+   *
+   * Chain-wide, and priced accordingly — see {@link feedMarketCaps} for one
+   * feed.
    **/
   prices({ chainId }: {
     chainId: number;

package/dist/types/permissionless/api/oracles/index.d.ts

@@ -1,3 +1,3 @@
-import { GetPricesArgs, PermissionlessAsset, PermissionlessPriceFeedStore, PermissionlessPrices } from "./types.js";
+import { GetPricesArgs, PermissionlessAsset, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedMarketCaps, PermissionlessPriceFeedStore, PermissionlessPrices, PriceFeedArgs } from "./types.js";
 import { GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, PermissionlessOracles } from "./PermissionlessOracles.js";
-export { GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GetPricesArgs, PermissionlessAsset, PermissionlessOracles, PermissionlessPriceFeedStore, PermissionlessPrices };
+export { GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GetPricesArgs, PermissionlessAsset, PermissionlessOracles, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedMarketCaps, PermissionlessPriceFeedStore, PermissionlessPrices, PriceFeedArgs };

package/dist/types/permissionless/api/oracles/schemas.d.ts

@@ -70,4 +70,59 @@ export declare const pricesSchema: z.ZodObject<{
   marketCaps: z.ZodType<Record<`0x${string}`, Record<`0x${string}`, string | null>>, unknown, z.core.$ZodTypeInternals<Record<`0x${string}`, Record<`0x${string}`, string | null>>, unknown>>;
   time: z.ZodNumber;
 }, z.core.$loose>;
+/** {@link PermissionlessPriceFeedAsset} */
+export declare const priceFeedAssetSchema: z.ZodObject<{
+  address: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  symbol: z.ZodString;
+  name: z.ZodString;
+  decimals: z.ZodNumber;
+}, z.core.$loose>;
+/** {@link PermissionlessPriceFeedMarket} */
+export declare const priceFeedMarketSchema: z.ZodObject<{
+  market: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  marketConfigurator: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  curatorName: z.ZodNullable<z.ZodString>;
+  marketName: z.ZodNullable<z.ZodString>;
+  token: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  tokenSymbol: z.ZodNullable<z.ZodString>;
+  underlyingSymbol: z.ZodNullable<z.ZodString>;
+  reserve: z.ZodBoolean;
+  isUnderlying: z.ZodBoolean;
+  quotaLimit: z.ZodNullable<z.ZodNumber>;
+}, z.core.$loose>;
+/** {@link PermissionlessPriceFeedDetails} */
+export declare const priceFeedDetailsSchema: z.ZodObject<{
+  chainId: z.ZodNumber;
+  priceFeed: z.ZodObject<{
+    address: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    contractType: z.ZodString;
+    version: z.ZodNumber;
+    deployedBy: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    stalenessPeriod: z.ZodNumber;
+    name: z.ZodString;
+  }, z.core.$loose>;
+  assets: z.ZodArray<z.ZodObject<{
+    address: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    symbol: z.ZodString;
+    name: z.ZodString;
+    decimals: z.ZodNumber;
+  }, z.core.$loose>>;
+  markets: z.ZodArray<z.ZodObject<{
+    market: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    marketConfigurator: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    curatorName: z.ZodNullable<z.ZodString>;
+    marketName: z.ZodNullable<z.ZodString>;
+    token: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    tokenSymbol: z.ZodNullable<z.ZodString>;
+    underlyingSymbol: z.ZodNullable<z.ZodString>;
+    reserve: z.ZodBoolean;
+    isUnderlying: z.ZodBoolean;
+    quotaLimit: z.ZodNullable<z.ZodNumber>;
+  }, z.core.$loose>>;
+}, z.core.$loose>;
+/** {@link PermissionlessPriceFeedMarketCaps} */
+export declare const priceFeedMarketCapsSchema: z.ZodObject<{
+  marketCaps: z.ZodType<Record<`0x${string}`, string | null>, unknown, z.core.$ZodTypeInternals<Record<`0x${string}`, string | null>, unknown>>;
+  time: z.ZodNumber;
+}, z.core.$loose>;
 //#endregion

package/dist/types/permissionless/api/oracles/types.d.ts

@@ -37,6 +37,98 @@ export interface PermissionlessPrices {
   marketCaps: Record<Address, Record<Address, string | null>>;
   time: number;
 }
+/**
+ * An asset the PriceFeedStore currently allows one feed to price.
+ *
+ * Narrower than {@link PermissionlessAsset} on purpose: this hangs off the
+ * feed, so listing the feeds allowed for it would just name the feed back.
+ **/
+export interface PermissionlessPriceFeedAsset {
+  address: Address;
+  symbol: string;
+  name: string;
+  decimals: number;
+}
+/**
+ * One token a market prices with the feed.
+ *
+ * A row per `(market, token, role)` rather than per market: the same feed can
+ * be the main feed of one token and the reserve feed of another in the very
+ * same market, and both are reported.
+ **/
+export interface PermissionlessPriceFeedMarket {
+  market: Address;
+  marketConfigurator: Address;
+  /** The configurator's own name, as the backend's sync recorded it. */
+  curatorName: string | null;
+  /**
+   * The market's own name, which is the name of its pool token — what the rest
+   * of the backend calls a market by as well.
+   */
+  marketName: string | null;
+  token: Address;
+  /** `null` for a token the backend has no metadata row for. */
+  tokenSymbol: string | null;
+  /**
+   * Symbol of the market's underlying, which is both what the market is
+   * pictured by and what its quota limit is denominated in.
+   */
+  underlyingSymbol: string | null;
+  /** The feed is the market's reserve feed for this token, not its main one. */
+  reserve: boolean;
+  /** The token is the market's underlying. */
+  isUnderlying: boolean;
+  /**
+   * What the pool will take of this token, in units of the market's
+   * underlying.
+   *
+   * `null` for a token the quota keeper was never told a limit for, which the
+   * market's own underlying always is — it is not quota-managed. A zero is a
+   * limit the curator has actually set to zero, and the two are different
+   * answers.
+   */
+  quotaLimit: number | null;
+}
+/**
+ * One feed of the store, with everywhere the store lets it be used.
+ *
+ * Feeds a tree carries but the store never added have no identity to report —
+ * no status history, hence no name or staleness — so the read throws for them
+ * rather than answering a half-filled row.
+ **/
+export interface PermissionlessPriceFeedDetails {
+  chainId: number;
+  priceFeed: PriceFeed;
+  assets: PermissionlessPriceFeedAsset[];
+  /**
+   * Ordered by curator, then by market, then by role with the main feeds
+   * ahead of the reserve ones — the grouping a reader wants, so a caller
+   * rendering a table does not have to sort it again.
+   */
+  markets: PermissionlessPriceFeedMarket[];
+}
+/**
+ * Market caps of one feed's assets, keyed by the lowercased asset address.
+ *
+ * Scoped to the feed rather than to the chain, which is what
+ * {@link PermissionlessOracles.prices} answers. A cap is
+ * `price × totalSupply`, so the chain-wide read pays for one `totalSupply` per
+ * asset of every market on it; a screen showing one feed's handful of rows
+ * should not.
+ *
+ * `null` for an asset whose price or supply could not be read — not a zero,
+ * since an asset nobody could price is not an asset worth nothing.
+ */
+export interface PermissionlessPriceFeedMarketCaps {
+  marketCaps: Record<Address, string | null>;
+  /** When the backend computed the figures; they are read live, not indexed. */
+  time: number;
+}
+/** Args of a read scoped to one feed. */
+export interface PriceFeedArgs {
+  chainId: number;
+  address: Address;
+}
 /** Args of {@link PermissionlessOracles.getPrices}. */
 export interface GetPricesArgs {
   chainId: number;

package/dist/types/permissionless/index.d.ts

@@ -1,4 +1,6 @@
 import { GearboxPermissionlessOptions } from "./api/types.js";
+import { PriceChartArgs, PriceFeedChartPoint, PriceFeedPriceChart } from "./api/analytics/types.js";
+import { PermissionlessAnalytics } from "./api/analytics/PermissionlessAnalytics.js";
 import { AttachChainsArgs, ChainScope, ChainSummaryArgs, PermissionlessChain, PermissionlessChainSummary } from "./api/chains/types.js";
 import { ChainsNamespace } from "./api/chains/ChainsNamespace.js";
 import { Auditor } from "./core/auditor.js";
@@ -11,7 +13,7 @@ import "./core/index.js";
 import { FunctionParams, ValueParams, encodeFunctionParams } from "./utils/abi-encoder.js";
 import { DeployArgs, DeployContractArgs, DeployPriceFeedArgs, PreparedDeployment, PreparedPriceFeedDeployment } from "./api/deploy/types.js";
 import { DEFAULT_DEPLOY_SALT, PermissionlessDeploy, priceFeedSalt } from "./api/deploy/PermissionlessDeploy.js";
-import { GetPricesArgs, PermissionlessAsset, PermissionlessPriceFeedStore, PermissionlessPrices } from "./api/oracles/types.js";
+import { GetPricesArgs, PermissionlessAsset, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedMarketCaps, PermissionlessPriceFeedStore, PermissionlessPrices, PriceFeedArgs } from "./api/oracles/types.js";
 import { GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, PermissionlessOracles } from "./api/oracles/PermissionlessOracles.js";
 import { AddressProviderContract } from "./bindings/address-provider.js";
 import { BytecodeRepositoryContract } from "./bindings/bytecode-repository.js";
@@ -52,4 +54,4 @@ import { getPrices } from "./utils/price-update/get-prices.js";
 import { GetUpdatablePriceFeedsArgs, getUpdatablePriceFeeds } from "./utils/price-update/get-updatable-feeds.js";
 import { normalizeSignature } from "./utils/signature.js";
 import "./utils/index.js";
-export { AccessMode, AddAssetParams, AddFeedsArgs, AddressProviderContract, Addresses, AllowTokenParams, ArchiveTransport, ArchiveTransportConfig, AttachChainsArgs, AuditEvent, Auditor, BYTECODE_REPOSITORY, Batch, Bytecode, BytecodeRepositoryContract, CCMConstructorParams, CROSS_CHAIN_GOVERNANCE, CROSS_CHAIN_MULTISIG, ChainScope, ChainSummaryArgs, ChainsNamespace, ChangeNamesArgs, ChangeStalenessPeriodsArgs, ConstructorParams, CreditManagerFees, CrossChainCall, CrossChainMultisigContract, DEFAULT_DEPLOY_SALT, DeployArgs, DeployContractArgs, DeployParams, DeployPriceFeedArgs, Deployment, DeploymentExtended, ForbidAdapterParams, ForbidFeedsArgs, ForbidTokenParams, FunctionParams, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GearboxPermissionless, GearboxPermissionlessOptions, GetPricesArgs, GetUpdatablePriceFeedsArgs, GovernorContract, INSTANCE_MANAGER, InputValueParams, InstanceManagerContract, InstanceOwnerTransactions, InstanceTxs, InstanceTxsArgs, MAINNET_CCM_CONSTRUCTOR_PARAMS, MAINNET_DEPLOYMENT_BLOCK, MAINNET_DEPLOYMENT_CCM_SALT, MAINNET_DEPLOYMENT_IM_SALT, MARKET_CONFIGURATOR_FACTORY, Market, MarketConfiguratorContract, MarketConfiguratorFactoryContract, PRICE_FEED_STORE, PUBLIC_CREATE2_FACTORY, PauseCreditManagerParams, PeripheryDomain, PermissionlessAsset, PermissionlessChain, PermissionlessChainSummary, PermissionlessChainUnreachableError, PermissionlessDeploy, PermissionlessNotAttachedError, PermissionlessOracles, PermissionlessPriceFeedStore, PermissionlessPrices, PreparedDeployment, PreparedPriceFeedDeployment, PriceFeed, PriceFeedConstructorParam, PriceFeedNotInStoreError, PriceFeedPair, PriceFeedParamType, PriceFeedParams, PriceFeedSaltMissingError, PriceFeedSetupParams, PriceFeedStalenessUnknownError, PriceFeedStoreContract, Proposal, QueuedAndExecutedTransaction, RecoveryMessage, RoutingManagerContract, SafeBatch, SafeMeta, SafeTx, SetExpirationDateParams, SetFeesParams, SetPriceFeedParams, SetReservePriceFeedParams, SetTokenQuotaIncreaseFeeParams, Signature, TOKEN_COMPRESSOR, TimeLockContract, TimelockTransaction, TimelockTxParams, TimelockTxs, TokenCompressorContract, TreasurySplitterContract, UnpauseCreditManagerParams, ValueParams, WithdrawalCompressorContract, calculateChecksum, checkCreate2Deployment, checkCreate2DeploymentAddress, chunkedLogsTransport, convertPercent, convertQueueBatchToExecuteTx, convertRawTxToSafeMultisigTx, createCallData, createCreate2DeployRawTx, deepJsonParse, deployUsingPublicCreate2, deriveEffectiveStalenessPeriod, encodeFunctionParams, formatBytecodeSize, formatBytecodeVersion, getBlockNumberByTimestamp, getCreate2AddressPublicFactory, getCreate2DeploymentAddress, getPriceUpdateTx, getPrices, getSafeBatch, getSafeBatches, getUpdatablePriceFeeds, handleSalt, normalizeSignature, priceFeedSalt, priceFeedSetupParams, shortenHash, significantTrunc };
+export { AccessMode, AddAssetParams, AddFeedsArgs, AddressProviderContract, Addresses, AllowTokenParams, ArchiveTransport, ArchiveTransportConfig, AttachChainsArgs, AuditEvent, Auditor, BYTECODE_REPOSITORY, Batch, Bytecode, BytecodeRepositoryContract, CCMConstructorParams, CROSS_CHAIN_GOVERNANCE, CROSS_CHAIN_MULTISIG, ChainScope, ChainSummaryArgs, ChainsNamespace, ChangeNamesArgs, ChangeStalenessPeriodsArgs, ConstructorParams, CreditManagerFees, CrossChainCall, CrossChainMultisigContract, DEFAULT_DEPLOY_SALT, DeployArgs, DeployContractArgs, DeployParams, DeployPriceFeedArgs, Deployment, DeploymentExtended, ForbidAdapterParams, ForbidFeedsArgs, ForbidTokenParams, FunctionParams, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GearboxPermissionless, GearboxPermissionlessOptions, GetPricesArgs, GetUpdatablePriceFeedsArgs, GovernorContract, INSTANCE_MANAGER, InputValueParams, InstanceManagerContract, InstanceOwnerTransactions, InstanceTxs, InstanceTxsArgs, MAINNET_CCM_CONSTRUCTOR_PARAMS, MAINNET_DEPLOYMENT_BLOCK, MAINNET_DEPLOYMENT_CCM_SALT, MAINNET_DEPLOYMENT_IM_SALT, MARKET_CONFIGURATOR_FACTORY, Market, MarketConfiguratorContract, MarketConfiguratorFactoryContract, PRICE_FEED_STORE, PUBLIC_CREATE2_FACTORY, PauseCreditManagerParams, PeripheryDomain, PermissionlessAnalytics, PermissionlessAsset, PermissionlessChain, PermissionlessChainSummary, PermissionlessChainUnreachableError, PermissionlessDeploy, PermissionlessNotAttachedError, PermissionlessOracles, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedMarketCaps, PermissionlessPriceFeedStore, PermissionlessPrices, PreparedDeployment, PreparedPriceFeedDeployment, PriceChartArgs, PriceFeed, PriceFeedArgs, PriceFeedChartPoint, PriceFeedConstructorParam, PriceFeedNotInStoreError, PriceFeedPair, PriceFeedParamType, PriceFeedParams, PriceFeedPriceChart, PriceFeedSaltMissingError, PriceFeedSetupParams, PriceFeedStalenessUnknownError, PriceFeedStoreContract, Proposal, QueuedAndExecutedTransaction, RecoveryMessage, RoutingManagerContract, SafeBatch, SafeMeta, SafeTx, SetExpirationDateParams, SetFeesParams, SetPriceFeedParams, SetReservePriceFeedParams, SetTokenQuotaIncreaseFeeParams, Signature, TOKEN_COMPRESSOR, TimeLockContract, TimelockTransaction, TimelockTxParams, TimelockTxs, TokenCompressorContract, TreasurySplitterContract, UnpauseCreditManagerParams, ValueParams, WithdrawalCompressorContract, calculateChecksum, checkCreate2Deployment, checkCreate2DeploymentAddress, chunkedLogsTransport, convertPercent, convertQueueBatchToExecuteTx, convertRawTxToSafeMultisigTx, createCallData, createCreate2DeployRawTx, deepJsonParse, deployUsingPublicCreate2, deriveEffectiveStalenessPeriod, encodeFunctionParams, formatBytecodeSize, formatBytecodeVersion, getBlockNumberByTimestamp, getCreate2AddressPublicFactory, getCreate2DeploymentAddress, getPriceUpdateTx, getPrices, getSafeBatch, getSafeBatches, getUpdatablePriceFeeds, handleSalt, normalizeSignature, priceFeedSalt, priceFeedSetupParams, shortenHash, significantTrunc };

package/package.json

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