@gearbox-protocol/sdk 18.2.0-next.2 → 18.2.0-next.4

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

@@ -62,6 +62,77 @@ var PermissionlessOracles = class extends require_offchain_AbstractOffchainNames
 		});
 	}
 	/**
+	* One asset of the store: the feeds allowed for it, and the markets that
+	* take it as collateral.
+	*
+	* The mirror of {@link feed}, and the call to reach for when the question is
+	* "what prices this token and what is it backing" rather than "where is this
+	* feed used". Both read the same market slots; which end they are indexed
+	* from is the difference.
+	*
+	* ```ts
+	* const { priceFeeds, markets, quotaUsedUsd } =
+	*   await permissionless.oracles.asset({ chainId: 1, address: token });
+	* ```
+	*
+	* @throws When the chain has no metadata for the address. An asset nothing
+	* was indexed for has no symbol or decimals, so there is no row to answer.
+	**/
+	async asset({ chainId, address }) {
+		return this.getData({
+			path: `/pfs/${chainId}/asset/${address}`,
+			schema: require_permissionless_api_oracles_schemas.assetDetailsSchema
+		});
+	}
+	/**
+	* What each of one asset's feeds prices it at, and the market cap each of
+	* them implies.
+	*
+	* The asset-side counterpart of {@link feedMarketCaps}, and priced the same
+	* way: one `totalSupply` read for the asset and one price per feed, rather
+	* than the chain-wide pass {@link prices} makes.
+	*
+	* Several feeds for one asset do not have to agree — that is the point of
+	* having a reserve feed — so this answers per feed rather than picking one.
+	*
+	* ```ts
+	* const { prices, marketCaps } = await permissionless.oracles.assetPrices({
+	*   chainId: 1,
+	*   address: token,
+	* });
+	* ```
+	**/
+	async assetPrices({ chainId, address }) {
+		return this.getData({
+			path: `/pfs/${chainId}/asset/${address}/prices`,
+			schema: require_permissionless_api_oracles_schemas.assetPricesSchema
+		});
+	}
+	/**
+	* Every asset the store carries, with what its markets make of it.
+	*
+	* Enough on its own to render a list of assets: the alternative is the
+	* store's whole read for the names plus a call per row for the quotas, and
+	* this is one request either way you scope it.
+	*
+	* Ordered by how central each asset is — the markets it underlies first,
+	* then what is quoted against it, then what it is allowed — so a consumer
+	* renders the rows as they arrive. Omit `chainId` for every chain the
+	* backend serves, ordered the same way across all of them.
+	*
+	* ```ts
+	* const assets = await permissionless.oracles.assets({ chainId: 1 });
+	* const everywhere = await permissionless.oracles.assets();
+	* ```
+	**/
+	async assets(args = {}) {
+		const query = args.chainId === void 0 ? "" : `?chainId=${encodeURIComponent(args.chainId)}`;
+		return this.getData({
+			path: `/pfs/assets${query}`,
+			schema: require_permissionless_api_oracles_schemas.assetSummariesSchema
+		});
+	}
+	/**
 	* The feeds one feed reads from, recursively.
 	*
 	* Answers for any feed the chain has indexed, store member or not: a

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

@@ -62,7 +62,9 @@ const priceFeedMarketSchema = zod_v4.z.looseObject({
 	underlyingSymbol: zod_v4.z.string().nullable(),
 	reserve: zod_v4.z.boolean(),
 	isUnderlying: zod_v4.z.boolean(),
-	quotaLimit: zod_v4.z.number().nullable()
+	quotaLimit: zod_v4.z.number().nullable(),
+	quotaUsed: zod_v4.z.number().nullable(),
+	marketStalenessPeriod: zod_v4.z.number().nullable()
 });
 /** {@link PermissionlessPriceFeedDetails} */
 const priceFeedDetailsSchema = zod_v4.z.looseObject({
@@ -76,8 +78,61 @@ const priceFeedMarketCapsSchema = zod_v4.z.looseObject({
 	marketCaps: require_permissionless_api_schemas.addressRecord(zod_v4.z.string().nullable()),
 	time: zod_v4.z.number()
 });
+/** {@link PermissionlessAssetMarketFeed} */
+const assetMarketFeedSchema = zod_v4.z.looseObject({
+	address: require_permissionless_api_schemas.addressSchema,
+	name: zod_v4.z.string().nullable(),
+	inStore: zod_v4.z.boolean()
+});
+/** {@link PermissionlessAssetMarket} */
+const assetMarketSchema = 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(),
+	underlyingToken: require_permissionless_api_schemas.addressSchema,
+	underlyingSymbol: zod_v4.z.string().nullable(),
+	isUnderlying: zod_v4.z.boolean(),
+	isShutdown: zod_v4.z.boolean(),
+	mainFeed: assetMarketFeedSchema.nullable(),
+	reserveFeed: assetMarketFeedSchema.nullable(),
+	quotaLimit: zod_v4.z.number().nullable(),
+	quotaUsed: zod_v4.z.number().nullable()
+});
+/** {@link PermissionlessAssetDetails} */
+const assetDetailsSchema = zod_v4.z.looseObject({
+	chainId: zod_v4.z.number(),
+	asset: priceFeedAssetSchema,
+	priceFeeds: zod_v4.z.array(priceFeedSchema),
+	markets: zod_v4.z.array(assetMarketSchema),
+	quotaLimitUsd: zod_v4.z.number().nullable(),
+	quotaUsedUsd: zod_v4.z.number().nullable()
+});
+/** {@link PermissionlessAssetPrices} */
+const assetPricesSchema = zod_v4.z.looseObject({
+	prices: require_permissionless_api_schemas.addressRecord(zod_v4.z.string().nullable()),
+	marketCaps: require_permissionless_api_schemas.addressRecord(zod_v4.z.string().nullable()),
+	time: zod_v4.z.number()
+});
+/** {@link PermissionlessAssetSummary} */
+const assetSummarySchema = zod_v4.z.looseObject({
+	chainId: zod_v4.z.number(),
+	address: require_permissionless_api_schemas.addressSchema,
+	symbol: zod_v4.z.string(),
+	underlyingMarketCount: zod_v4.z.number(),
+	quotaLimitUsd: zod_v4.z.number().nullable(),
+	quotaUsedUsd: zod_v4.z.number().nullable()
+});
+/** The list of {@link PermissionlessAssetSummary}, already ordered. */
+const assetSummariesSchema = zod_v4.z.array(assetSummarySchema);
 //#endregion
+exports.assetDetailsSchema = assetDetailsSchema;
+exports.assetMarketFeedSchema = assetMarketFeedSchema;
+exports.assetMarketSchema = assetMarketSchema;
+exports.assetPricesSchema = assetPricesSchema;
 exports.assetSchema = assetSchema;
+exports.assetSummariesSchema = assetSummariesSchema;
+exports.assetSummarySchema = assetSummarySchema;
 exports.priceFeedAssetSchema = priceFeedAssetSchema;
 exports.priceFeedDetailsSchema = priceFeedDetailsSchema;
 exports.priceFeedMarketCapsSchema = priceFeedMarketCapsSchema;

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

@@ -1,7 +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 { priceFeedDetailsSchema, priceFeedMarketCapsSchema, priceFeedStoreSchema, pricesSchema } from "./schemas.js";
+import { assetDetailsSchema, assetPricesSchema, assetSummariesSchema, 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;
@@ -61,6 +61,77 @@ var PermissionlessOracles = class extends AbstractOffchainNamespace {
 		});
 	}
 	/**
+	* One asset of the store: the feeds allowed for it, and the markets that
+	* take it as collateral.
+	*
+	* The mirror of {@link feed}, and the call to reach for when the question is
+	* "what prices this token and what is it backing" rather than "where is this
+	* feed used". Both read the same market slots; which end they are indexed
+	* from is the difference.
+	*
+	* ```ts
+	* const { priceFeeds, markets, quotaUsedUsd } =
+	*   await permissionless.oracles.asset({ chainId: 1, address: token });
+	* ```
+	*
+	* @throws When the chain has no metadata for the address. An asset nothing
+	* was indexed for has no symbol or decimals, so there is no row to answer.
+	**/
+	async asset({ chainId, address }) {
+		return this.getData({
+			path: `/pfs/${chainId}/asset/${address}`,
+			schema: assetDetailsSchema
+		});
+	}
+	/**
+	* What each of one asset's feeds prices it at, and the market cap each of
+	* them implies.
+	*
+	* The asset-side counterpart of {@link feedMarketCaps}, and priced the same
+	* way: one `totalSupply` read for the asset and one price per feed, rather
+	* than the chain-wide pass {@link prices} makes.
+	*
+	* Several feeds for one asset do not have to agree — that is the point of
+	* having a reserve feed — so this answers per feed rather than picking one.
+	*
+	* ```ts
+	* const { prices, marketCaps } = await permissionless.oracles.assetPrices({
+	*   chainId: 1,
+	*   address: token,
+	* });
+	* ```
+	**/
+	async assetPrices({ chainId, address }) {
+		return this.getData({
+			path: `/pfs/${chainId}/asset/${address}/prices`,
+			schema: assetPricesSchema
+		});
+	}
+	/**
+	* Every asset the store carries, with what its markets make of it.
+	*
+	* Enough on its own to render a list of assets: the alternative is the
+	* store's whole read for the names plus a call per row for the quotas, and
+	* this is one request either way you scope it.
+	*
+	* Ordered by how central each asset is — the markets it underlies first,
+	* then what is quoted against it, then what it is allowed — so a consumer
+	* renders the rows as they arrive. Omit `chainId` for every chain the
+	* backend serves, ordered the same way across all of them.
+	*
+	* ```ts
+	* const assets = await permissionless.oracles.assets({ chainId: 1 });
+	* const everywhere = await permissionless.oracles.assets();
+	* ```
+	**/
+	async assets(args = {}) {
+		const query = args.chainId === void 0 ? "" : `?chainId=${encodeURIComponent(args.chainId)}`;
+		return this.getData({
+			path: `/pfs/assets${query}`,
+			schema: assetSummariesSchema
+		});
+	}
+	/**
 	* The feeds one feed reads from, recursively.
 	*
 	* Answers for any feed the chain has indexed, store member or not: a

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

@@ -61,7 +61,9 @@ const priceFeedMarketSchema = z.looseObject({
 	underlyingSymbol: z.string().nullable(),
 	reserve: z.boolean(),
 	isUnderlying: z.boolean(),
-	quotaLimit: z.number().nullable()
+	quotaLimit: z.number().nullable(),
+	quotaUsed: z.number().nullable(),
+	marketStalenessPeriod: z.number().nullable()
 });
 /** {@link PermissionlessPriceFeedDetails} */
 const priceFeedDetailsSchema = z.looseObject({
@@ -75,5 +77,52 @@ const priceFeedMarketCapsSchema = z.looseObject({
 	marketCaps: addressRecord(z.string().nullable()),
 	time: z.number()
 });
+/** {@link PermissionlessAssetMarketFeed} */
+const assetMarketFeedSchema = z.looseObject({
+	address: addressSchema,
+	name: z.string().nullable(),
+	inStore: z.boolean()
+});
+/** {@link PermissionlessAssetMarket} */
+const assetMarketSchema = z.looseObject({
+	market: addressSchema,
+	marketConfigurator: addressSchema,
+	curatorName: z.string().nullable(),
+	marketName: z.string().nullable(),
+	underlyingToken: addressSchema,
+	underlyingSymbol: z.string().nullable(),
+	isUnderlying: z.boolean(),
+	isShutdown: z.boolean(),
+	mainFeed: assetMarketFeedSchema.nullable(),
+	reserveFeed: assetMarketFeedSchema.nullable(),
+	quotaLimit: z.number().nullable(),
+	quotaUsed: z.number().nullable()
+});
+/** {@link PermissionlessAssetDetails} */
+const assetDetailsSchema = z.looseObject({
+	chainId: z.number(),
+	asset: priceFeedAssetSchema,
+	priceFeeds: z.array(priceFeedSchema),
+	markets: z.array(assetMarketSchema),
+	quotaLimitUsd: z.number().nullable(),
+	quotaUsedUsd: z.number().nullable()
+});
+/** {@link PermissionlessAssetPrices} */
+const assetPricesSchema = z.looseObject({
+	prices: addressRecord(z.string().nullable()),
+	marketCaps: addressRecord(z.string().nullable()),
+	time: z.number()
+});
+/** {@link PermissionlessAssetSummary} */
+const assetSummarySchema = z.looseObject({
+	chainId: z.number(),
+	address: addressSchema,
+	symbol: z.string(),
+	underlyingMarketCount: z.number(),
+	quotaLimitUsd: z.number().nullable(),
+	quotaUsedUsd: z.number().nullable()
+});
+/** The list of {@link PermissionlessAssetSummary}, already ordered. */
+const assetSummariesSchema = z.array(assetSummarySchema);
 //#endregion
-export { assetSchema, priceFeedAssetSchema, priceFeedDetailsSchema, priceFeedMarketCapsSchema, priceFeedMarketSchema, priceFeedSchema, priceFeedStoreSchema, pricesSchema };
+export { assetDetailsSchema, assetMarketFeedSchema, assetMarketSchema, assetPricesSchema, assetSchema, assetSummariesSchema, assetSummarySchema, priceFeedAssetSchema, priceFeedDetailsSchema, priceFeedMarketCapsSchema, priceFeedMarketSchema, priceFeedSchema, priceFeedStoreSchema, pricesSchema };

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

@@ -5,7 +5,7 @@ import { AttachChainsArgs, ChainScope, ChainSummaryArgs, PermissionlessChain, Pe
 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, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedMarketCaps, PermissionlessPriceFeedStore, PermissionlessPrices, PriceFeedArgs } from "./oracles/types.js";
+import { AssetArgs, GetPricesArgs, PermissionlessAsset, PermissionlessAssetDetails, PermissionlessAssetMarket, PermissionlessAssetMarketFeed, PermissionlessAssetPrices, PermissionlessAssetSummary, 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";
@@ -17,4 +17,4 @@ 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, 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 };
+export { AddFeedsArgs, AssetArgs, 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, PermissionlessAssetDetails, PermissionlessAssetMarket, PermissionlessAssetMarketFeed, PermissionlessAssetPrices, PermissionlessAssetSummary, 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

@@ -2,7 +2,7 @@ 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, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarketCaps, PermissionlessPriceFeedStore, PermissionlessPrices, PriceFeedArgs } from "./types.js";
+import { AssetArgs, GetPricesArgs, PermissionlessAssetDetails, PermissionlessAssetPrices, PermissionlessAssetSummary, 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>;
@@ -48,6 +48,63 @@ export declare class PermissionlessOracles extends AbstractOffchainNamespace {
    * here — it lives in whichever app wrote it.
    **/
   feed({ chainId, address }: PriceFeedArgs): Promise<PermissionlessPriceFeedDetails>;
+  /**
+   * One asset of the store: the feeds allowed for it, and the markets that
+   * take it as collateral.
+   *
+   * The mirror of {@link feed}, and the call to reach for when the question is
+   * "what prices this token and what is it backing" rather than "where is this
+   * feed used". Both read the same market slots; which end they are indexed
+   * from is the difference.
+   *
+   * ```ts
+   * const { priceFeeds, markets, quotaUsedUsd } =
+   *   await permissionless.oracles.asset({ chainId: 1, address: token });
+   * ```
+   *
+   * @throws When the chain has no metadata for the address. An asset nothing
+   * was indexed for has no symbol or decimals, so there is no row to answer.
+   **/
+  asset({ chainId, address }: AssetArgs): Promise<PermissionlessAssetDetails>;
+  /**
+   * What each of one asset's feeds prices it at, and the market cap each of
+   * them implies.
+   *
+   * The asset-side counterpart of {@link feedMarketCaps}, and priced the same
+   * way: one `totalSupply` read for the asset and one price per feed, rather
+   * than the chain-wide pass {@link prices} makes.
+   *
+   * Several feeds for one asset do not have to agree — that is the point of
+   * having a reserve feed — so this answers per feed rather than picking one.
+   *
+   * ```ts
+   * const { prices, marketCaps } = await permissionless.oracles.assetPrices({
+   *   chainId: 1,
+   *   address: token,
+   * });
+   * ```
+   **/
+  assetPrices({ chainId, address }: AssetArgs): Promise<PermissionlessAssetPrices>;
+  /**
+   * Every asset the store carries, with what its markets make of it.
+   *
+   * Enough on its own to render a list of assets: the alternative is the
+   * store's whole read for the names plus a call per row for the quotas, and
+   * this is one request either way you scope it.
+   *
+   * Ordered by how central each asset is — the markets it underlies first,
+   * then what is quoted against it, then what it is allowed — so a consumer
+   * renders the rows as they arrive. Omit `chainId` for every chain the
+   * backend serves, ordered the same way across all of them.
+   *
+   * ```ts
+   * const assets = await permissionless.oracles.assets({ chainId: 1 });
+   * const everywhere = await permissionless.oracles.assets();
+   * ```
+   **/
+  assets(args?: {
+    chainId?: number;
+  }): Promise<PermissionlessAssetSummary[]>;
   /**
    * The feeds one feed reads from, recursively.
    *

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

@@ -1,3 +1,3 @@
-import { GetPricesArgs, PermissionlessAsset, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedMarketCaps, PermissionlessPriceFeedStore, PermissionlessPrices, PriceFeedArgs } from "./types.js";
+import { AssetArgs, GetPricesArgs, PermissionlessAsset, PermissionlessAssetDetails, PermissionlessAssetMarket, PermissionlessAssetMarketFeed, PermissionlessAssetPrices, PermissionlessAssetSummary, 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, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedMarketCaps, PermissionlessPriceFeedStore, PermissionlessPrices, PriceFeedArgs };
+export { AssetArgs, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GetPricesArgs, PermissionlessAsset, PermissionlessAssetDetails, PermissionlessAssetMarket, PermissionlessAssetMarketFeed, PermissionlessAssetPrices, PermissionlessAssetSummary, PermissionlessOracles, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedMarketCaps, PermissionlessPriceFeedStore, PermissionlessPrices, PriceFeedArgs };

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

@@ -89,6 +89,8 @@ export declare const priceFeedMarketSchema: z.ZodObject<{
   reserve: z.ZodBoolean;
   isUnderlying: z.ZodBoolean;
   quotaLimit: z.ZodNullable<z.ZodNumber>;
+  quotaUsed: z.ZodNullable<z.ZodNumber>;
+  marketStalenessPeriod: z.ZodNullable<z.ZodNumber>;
 }, z.core.$loose>;
 /** {@link PermissionlessPriceFeedDetails} */
 export declare const priceFeedDetailsSchema: z.ZodObject<{
@@ -118,6 +120,8 @@ export declare const priceFeedDetailsSchema: z.ZodObject<{
     reserve: z.ZodBoolean;
     isUnderlying: z.ZodBoolean;
     quotaLimit: z.ZodNullable<z.ZodNumber>;
+    quotaUsed: z.ZodNullable<z.ZodNumber>;
+    marketStalenessPeriod: z.ZodNullable<z.ZodNumber>;
   }, z.core.$loose>>;
 }, z.core.$loose>;
 /** {@link PermissionlessPriceFeedMarketCaps} */
@@ -125,4 +129,99 @@ 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>;
+/** {@link PermissionlessAssetMarketFeed} */
+export declare const assetMarketFeedSchema: z.ZodObject<{
+  address: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  name: z.ZodNullable<z.ZodString>;
+  inStore: z.ZodBoolean;
+}, z.core.$loose>;
+/** {@link PermissionlessAssetMarket} */
+export declare const assetMarketSchema: 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>;
+  underlyingToken: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  underlyingSymbol: z.ZodNullable<z.ZodString>;
+  isUnderlying: z.ZodBoolean;
+  isShutdown: z.ZodBoolean;
+  mainFeed: z.ZodNullable<z.ZodObject<{
+    address: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    name: z.ZodNullable<z.ZodString>;
+    inStore: z.ZodBoolean;
+  }, z.core.$loose>>;
+  reserveFeed: z.ZodNullable<z.ZodObject<{
+    address: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    name: z.ZodNullable<z.ZodString>;
+    inStore: z.ZodBoolean;
+  }, z.core.$loose>>;
+  quotaLimit: z.ZodNullable<z.ZodNumber>;
+  quotaUsed: z.ZodNullable<z.ZodNumber>;
+}, z.core.$loose>;
+/** {@link PermissionlessAssetDetails} */
+export declare const assetDetailsSchema: z.ZodObject<{
+  chainId: z.ZodNumber;
+  asset: z.ZodObject<{
+    address: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    symbol: z.ZodString;
+    name: z.ZodString;
+    decimals: z.ZodNumber;
+  }, z.core.$loose>;
+  priceFeeds: z.ZodArray<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>>;
+  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>;
+    underlyingToken: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    underlyingSymbol: z.ZodNullable<z.ZodString>;
+    isUnderlying: z.ZodBoolean;
+    isShutdown: z.ZodBoolean;
+    mainFeed: z.ZodNullable<z.ZodObject<{
+      address: z.ZodCustom<`0x${string}`, `0x${string}`>;
+      name: z.ZodNullable<z.ZodString>;
+      inStore: z.ZodBoolean;
+    }, z.core.$loose>>;
+    reserveFeed: z.ZodNullable<z.ZodObject<{
+      address: z.ZodCustom<`0x${string}`, `0x${string}`>;
+      name: z.ZodNullable<z.ZodString>;
+      inStore: z.ZodBoolean;
+    }, z.core.$loose>>;
+    quotaLimit: z.ZodNullable<z.ZodNumber>;
+    quotaUsed: z.ZodNullable<z.ZodNumber>;
+  }, z.core.$loose>>;
+  quotaLimitUsd: z.ZodNullable<z.ZodNumber>;
+  quotaUsedUsd: z.ZodNullable<z.ZodNumber>;
+}, z.core.$loose>;
+/** {@link PermissionlessAssetPrices} */
+export declare const assetPricesSchema: z.ZodObject<{
+  prices: z.ZodType<Record<`0x${string}`, string | null>, unknown, z.core.$ZodTypeInternals<Record<`0x${string}`, string | null>, unknown>>;
+  marketCaps: z.ZodType<Record<`0x${string}`, string | null>, unknown, z.core.$ZodTypeInternals<Record<`0x${string}`, string | null>, unknown>>;
+  time: z.ZodNumber;
+}, z.core.$loose>;
+/** {@link PermissionlessAssetSummary} */
+export declare const assetSummarySchema: z.ZodObject<{
+  chainId: z.ZodNumber;
+  address: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  symbol: z.ZodString;
+  underlyingMarketCount: z.ZodNumber;
+  quotaLimitUsd: z.ZodNullable<z.ZodNumber>;
+  quotaUsedUsd: z.ZodNullable<z.ZodNumber>;
+}, z.core.$loose>;
+/** The list of {@link PermissionlessAssetSummary}, already ordered. */
+export declare const assetSummariesSchema: z.ZodArray<z.ZodObject<{
+  chainId: z.ZodNumber;
+  address: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  symbol: z.ZodString;
+  underlyingMarketCount: z.ZodNumber;
+  quotaLimitUsd: z.ZodNullable<z.ZodNumber>;
+  quotaUsedUsd: z.ZodNullable<z.ZodNumber>;
+}, z.core.$loose>>;
 //#endregion

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

@@ -88,6 +88,33 @@ export interface PermissionlessPriceFeedMarket {
    * answers.
    */
   quotaLimit: number | null;
+  /**
+   * How much of {@link quotaLimit} the market's borrowers have actually taken,
+   * in the same units.
+   *
+   * The sum of every open credit account's current quota for this token across
+   * the credit managers borrowing from the market, so it is what the token is
+   * backing right now rather than what it is allowed to back.
+   *
+   * `null` only where {@link quotaLimit} is: a token nobody quotes reads as a
+   * zero against a limit, which is a different answer from a token the keeper
+   * holds no entry for at all.
+   */
+  quotaUsed: number | null;
+  /**
+   * Staleness period this market's own price oracle holds for the slot, in
+   * seconds.
+   *
+   * The market's figure rather than the store's: a curator sets one per slot
+   * in their price oracle, and nothing obliges it to agree with the period the
+   * PriceFeedStore carries for the feed. A reader comparing the two is
+   * comparing two contracts, which is why both are reported.
+   *
+   * Read off the oracle when the route is answered rather than taken from the
+   * index — the slot's period is not indexed — so `null` means the oracle
+   * would not answer, not that it holds no period.
+   */
+  marketStalenessPeriod: number | null;
 }
 /**
  * One feed of the store, with everywhere the store lets it be used.
@@ -107,6 +134,163 @@ export interface PermissionlessPriceFeedDetails {
    */
   markets: PermissionlessPriceFeedMarket[];
 }
+/**
+ * One feed as a market slot holds it.
+ *
+ * The store's view of the feed and not the feed itself: a market keeps
+ * pricing with whatever it was last pointed at, and nothing removes it from a
+ * market when the store drops it. {@link inStore} is what tells those apart,
+ * and the name survives either way because the store recorded it before.
+ **/
+export interface PermissionlessAssetMarketFeed {
+  address: Address;
+  /**
+   * Display name the store recorded, or `null` for a feed it never carried —
+   * an aggregator a curator pointed a market straight at, say.
+   */
+  name: string | null;
+  /**
+   * Whether the PriceFeedStore still carries the feed.
+   *
+   * `false` is the case worth showing: the market goes on pricing the asset
+   * with a feed the store has removed, or never had. Nothing on chain forbids
+   * that, which is exactly why it has to be visible.
+   */
+  inStore: boolean;
+}
+/**
+ * One market that prices an asset, with both of the slots it may fill.
+ *
+ * A row per market rather than per `(market, role)`: the two roles are two
+ * columns of the same market's row, and the quota is the market's whatever
+ * feed holds which slot.
+ **/
+export interface PermissionlessAssetMarket {
+  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. */
+  marketName: string | null;
+  /** The market's underlying, which its quota figures are denominated in. */
+  underlyingToken: Address;
+  /** `null` for an underlying the backend has no metadata row for. */
+  underlyingSymbol: string | null;
+  /** The asset is this market's own underlying, so it is not quota-managed. */
+  isUnderlying: boolean;
+  /**
+   * The market has been shut down.
+   *
+   * Still reported, and still counted in {@link
+   * PermissionlessAssetDetails.quotaUsedUsd}: a shut down market carries no
+   * new borrowing but its open accounts are quoting all the same.
+   */
+  isShutdown: boolean;
+  /** The feed the market prices the asset with, or `null` if it has none. */
+  mainFeed: PermissionlessAssetMarketFeed | null;
+  /** The feed the market falls back to, or `null` if it has none. */
+  reserveFeed: PermissionlessAssetMarketFeed | null;
+  /**
+   * What the pool will take of the asset, in units of {@link underlyingToken}.
+   *
+   * `null` for an asset the quota keeper was never told a limit for, which the
+   * market's own underlying always is. A zero is a limit set to zero, and the
+   * two are different answers.
+   */
+  quotaLimit: number | null;
+  /** How much of {@link quotaLimit} is actually taken, in the same units. */
+  quotaUsed: number | null;
+}
+/**
+ * One asset of the store: what prices it, and what it is used as collateral
+ * for.
+ *
+ * The counterpart of {@link PermissionlessPriceFeedDetails} — the same corner
+ * of the chain read from the asset's end instead of the feed's.
+ **/
+export interface PermissionlessAssetDetails {
+  chainId: number;
+  asset: PermissionlessPriceFeedAsset;
+  /**
+   * Feeds the store currently allows for the asset.
+   *
+   * Only the store's. A feed a market still prices the asset with but the
+   * store has dropped is not here — it is on its market's row, flagged.
+   */
+  priceFeeds: PriceFeed[];
+  /** Ordered by curator, then by market. */
+  markets: PermissionlessAssetMarket[];
+  /**
+   * Total quota limit across the markets still running, in USD.
+   *
+   * In USD and not in token units because there is no token to state it in: a
+   * limit is denominated in its own market's underlying, and an asset is
+   * routinely collateral in markets underlain by different tokens, so the
+   * figures are not comparable until each is priced. Each market's limit is
+   * converted at the price that market's own oracle holds for its underlying.
+   *
+   * Shut down markets are left out — their limits are not borrowable — and so
+   * are markets whose underlying could not be priced, which makes this a floor
+   * rather than an estimate. `null` when no market contributed at all.
+   */
+  quotaLimitUsd: number | null;
+  /**
+   * Total quota actually taken across every market, in USD, converted the same
+   * way as {@link quotaLimitUsd}.
+   *
+   * Every market, including the shut down ones: debt outstanding is exposure
+   * whether or not the market still takes new borrowers.
+   */
+  quotaUsedUsd: number | null;
+}
+/**
+ * What each of one asset's feeds says the asset is worth, and what the market
+ * values the asset at through each.
+ *
+ * Keyed by the lowercased feed address throughout. The asset is the one asked
+ * for, so a cap here is that feed's price times the asset's supply — the same
+ * figure {@link PermissionlessPriceFeedMarketCaps} answers from the other
+ * side, and the reason both exist is that a page shows one row per feed or one
+ * row per asset, never the full cross product.
+ *
+ * `null` is a read that failed, not a zero.
+ **/
+export interface PermissionlessAssetPrices {
+  prices: Record<Address, string | null>;
+  marketCaps: Record<Address, string | null>;
+  /** When the backend computed the figures; they are read live, not indexed. */
+  time: number;
+}
+/**
+ * One asset of the PriceFeedStore, with what its markets make of it.
+ *
+ * Everything a list of assets renders and nothing else: the store's own read
+ * carries each asset's feeds too, which is several times this payload and not
+ * what a reader scanning for the big positions is looking at.
+ *
+ * The two USD figures are the ones {@link PermissionlessAssetDetails} heads an
+ * asset's own page with, under the same rule — limits count only the markets
+ * still running, what is already quoted counts everywhere, and `null` is
+ * nothing to total rather than a zero — so the list and the page a row of it
+ * opens cannot disagree.
+ **/
+export interface PermissionlessAssetSummary {
+  chainId: number;
+  /** Lowercased, as everything addressed in these payloads is. */
+  address: Address;
+  symbol: string;
+  /**
+   * How many markets still running are underlain by this asset.
+   *
+   * What makes an asset central rather than merely listed: a token several
+   * markets borrow against is the one a reader opens the list for. Shut down
+   * markets are left out for the reason their limits are — they are no longer
+   * a place anything happens.
+   */
+  underlyingMarketCount: number;
+  quotaLimitUsd: number | null;
+  quotaUsedUsd: number | null;
+}
 /**
  * Market caps of one feed's assets, keyed by the lowercased asset address.
  *
@@ -129,6 +313,11 @@ export interface PriceFeedArgs {
   chainId: number;
   address: Address;
 }
+/** Args of a read scoped to one asset. */
+export interface AssetArgs {
+  chainId: number;
+  address: Address;
+}
 /** Args of {@link PermissionlessOracles.getPrices}. */
 export interface GetPricesArgs {
   chainId: number;

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

@@ -13,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, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedMarketCaps, PermissionlessPriceFeedStore, PermissionlessPrices, PriceFeedArgs } from "./api/oracles/types.js";
+import { AssetArgs, GetPricesArgs, PermissionlessAsset, PermissionlessAssetDetails, PermissionlessAssetMarket, PermissionlessAssetMarketFeed, PermissionlessAssetPrices, PermissionlessAssetSummary, 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";
@@ -54,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, 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 };
+export { AccessMode, AddAssetParams, AddFeedsArgs, AddressProviderContract, Addresses, AllowTokenParams, ArchiveTransport, ArchiveTransportConfig, AssetArgs, 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, PermissionlessAssetDetails, PermissionlessAssetMarket, PermissionlessAssetMarketFeed, PermissionlessAssetPrices, PermissionlessAssetSummary, 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.2.0-next.2",
+  "version": "18.2.0-next.4",
   "description": "Gearbox SDK",
   "license": "MIT",
   "repository": {
@@ -69,8 +69,9 @@
     "dev": "tsdown --watch",
     "example": "tsx scripts/example.ts | pino-pretty",
     "list-opportunities": "tsx scripts/list-opportunities.ts",
-    "test:watch": "vitest --project unit",
-    "test:unit": "vitest run --project unit",
+    "test:watch": "vitest --project unit --project api",
+    "test:unit": "vitest run --project unit --project api",
+    "test:api": "vitest run --project api",
     "test:e2e": "vitest run --project e2e",
     "test:all": "vitest run",
     "test": "vitest run",