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

package/dist/types/onchain/market/adapters/types.d.ts

@@ -15,7 +15,7 @@ export interface IAdapterContract extends IBaseContract {
   openingCalls(): Promise<MultiCall[]>;
 }
 export type VersionedAbi = Record<number, readonly AbiParameter[]>;
-export type AdapterContractType = "ADAPTER::ACCOUNT_MIGRATOR" | "ADAPTER::BALANCER_V3_ROUTER" | "ADAPTER::BALANCER_V3_WRAPPER" | "ADAPTER::CAMELOT_V3_ROUTER" | "ADAPTER::CURVE_STABLE_NG" | "ADAPTER::CURVE_V1_2ASSETS" | "ADAPTER::CURVE_V1_3ASSETS" | "ADAPTER::CURVE_V1_4ASSETS" | "ADAPTER::CURVE_V1_STECRV_POOL" | "ADAPTER::CVX_V1_BASE_REWARD_POOL" | "ADAPTER::CVX_V1_BOOSTER" | "ADAPTER::DAI_USDS_EXCHANGE" | "ADAPTER::ERC4626_VAULT" | "ADAPTER::ERC4626_VAULT_REFERRAL" | "ADAPTER::FLUID_DEX" | "ADAPTER::INFINIFI_GATEWAY" | "ADAPTER::INFINIFI_UNWINDING" | "ADAPTER::KELP_DEPOSIT_POOL" | "ADAPTER::KELP_WITHDRAWAL" | "ADAPTER::LIDO_V1" | "ADAPTER::LIDO_WSTETH_V1" | "ADAPTER::MELLOW_CLAIMER" | "ADAPTER::MELLOW_DVV" | "ADAPTER::MELLOW_ERC4626_VAULT" | "ADAPTER::MELLOW_WRAPPER" | "ADAPTER::MIDAS_GATEWAY" | "ADAPTER::MIDAS_ISSUANCE_VAULT" | "ADAPTER::MIDAS_REDEMPTION_VAULT" | "ADAPTER::PENDLE_ROUTER" | "ADAPTER::SECURITIZE_ONRAMP" | "ADAPTER::SECURITIZE_REDEMPTION" | "ADAPTER::STAKING_REWARDS" | "ADAPTER::TRADERJOE_ROUTER" | "ADAPTER::UNISWAP_V2_ROUTER" | "ADAPTER::UNISWAP_V3_ROUTER" | "ADAPTER::UNISWAP_V4_GATEWAY" | "ADAPTER::UPSHIFT_VAULT" | "ADAPTER::VELODROME_V2_ROUTER";
+export type AdapterContractType = "ADAPTER::ACCOUNT_MIGRATOR" | "ADAPTER::BALANCER_V3_ROUTER" | "ADAPTER::BALANCER_V3_WRAPPER" | "ADAPTER::CAMELOT_V3_ROUTER" | "ADAPTER::CURVE_STABLE_NG" | "ADAPTER::CURVE_V1_2ASSETS" | "ADAPTER::CURVE_V1_3ASSETS" | "ADAPTER::CURVE_V1_4ASSETS" | "ADAPTER::CURVE_V1_STECRV_POOL" | "ADAPTER::CVX_V1_BASE_REWARD_POOL" | "ADAPTER::CVX_V1_BOOSTER" | "ADAPTER::DAI_USDS_EXCHANGE" | "ADAPTER::ERC4626_VAULT" | "ADAPTER::ERC4626_VAULT_REFERRAL" | "ADAPTER::FLUID_DEX" | "ADAPTER::INFINIFI_GATEWAY" | "ADAPTER::INFINIFI_UNWINDING" | "ADAPTER::KELP_DEPOSIT_POOL" | "ADAPTER::KELP_WITHDRAWAL" | "ADAPTER::LIDO_V1" | "ADAPTER::LIDO_WSTETH_V1" | "ADAPTER::MELLOW_CLAIMER" | "ADAPTER::MELLOW_DVV" | "ADAPTER::MELLOW_ERC4626_VAULT" | "ADAPTER::MELLOW_WRAPPER" | "ADAPTER::MIDAS_GATEWAY" | "ADAPTER::MIDAS_ISSUANCE_VAULT" | "ADAPTER::MIDAS_REDEMPTION_VAULT" | "ADAPTER::PENDLE_ROUTER" | "ADAPTER::SECURITIZE_ONRAMP" | "ADAPTER::SECURITIZE_REDEMPTION" | "ADAPTER::STAKING_REWARDS" | "ADAPTER::TRADERJOE_ROUTER" | "ADAPTER::TREEHOUSE_FASTLANE" | "ADAPTER::TREEHOUSE_GATEWAY" | "ADAPTER::TREEHOUSE_ROUTER" | "ADAPTER::UNISWAP_V2_ROUTER" | "ADAPTER::UNISWAP_V3_ROUTER" | "ADAPTER::UNISWAP_V4_GATEWAY" | "ADAPTER::UPSHIFT_VAULT" | "ADAPTER::VELODROME_V2_ROUTER";
 export declare enum AdapterType {
   ACCOUNT_MIGRATOR = "ACCOUNT_MIGRATOR",
   BALANCER_V3_ROUTER = "BALANCER_V3_ROUTER",
@@ -50,6 +50,9 @@ export declare enum AdapterType {
   SECURITIZE_REDEMPTION = "SECURITIZE_REDEMPTION",
   STAKING_REWARDS = "STAKING_REWARDS",
   TRADERJOE_ROUTER = "TRADERJOE_ROUTER",
+  TREEHOUSE_FASTLANE = "TREEHOUSE_FASTLANE",
+  TREEHOUSE_GATEWAY = "TREEHOUSE_GATEWAY",
+  TREEHOUSE_ROUTER = "TREEHOUSE_ROUTER",
   UNISWAP_V2_ROUTER = "UNISWAP_V2_ROUTER",
   UNISWAP_V3_ROUTER = "UNISWAP_V3_ROUTER",
   UNISWAP_V4_GATEWAY = "UNISWAP_V4_GATEWAY",

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, AssetCap, AssetsArgs, FeedCap, MarketCap, PermissionlessAsset, PermissionlessAssetDetails, PermissionlessAssetMarket, PermissionlessAssetMarketFeed, PermissionlessAssetQuota, PermissionlessAssetSummary, PermissionlessIndexedAssetDetails, PermissionlessIndexedAssetSummary, PermissionlessIndexedPriceFeedDetails, PermissionlessIndexedPriceFeedMarket, PermissionlessMarket, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedStore, PermissionlessQuotaTotals, PriceFeedArgs, PriceFeedPrice, PriceFeedRef } 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, AssetCap, AssetsArgs, AttachChainsArgs, ChainScope, ChainSummaryArgs, ChainsNamespace, ChangeNamesArgs, ChangeStalenessPeriodsArgs, DEFAULT_DEPLOY_SALT, DeployArgs, DeployContractArgs, DeployPriceFeedArgs, FeedCap, ForbidFeedsArgs, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GearboxPermissionless, GearboxPermissionlessOptions, InstanceOwnerTransactions, InstanceTxsArgs, MarketCap, PermissionlessAnalytics, PermissionlessAsset, PermissionlessAssetDetails, PermissionlessAssetMarket, PermissionlessAssetMarketFeed, PermissionlessAssetQuota, PermissionlessAssetSummary, PermissionlessChain, PermissionlessChainSummary, PermissionlessChainUnreachableError, PermissionlessDeploy, PermissionlessIndexedAssetDetails, PermissionlessIndexedAssetSummary, PermissionlessIndexedPriceFeedDetails, PermissionlessIndexedPriceFeedMarket, PermissionlessMarket, PermissionlessNotAttachedError, PermissionlessOracles, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedStore, PermissionlessQuotaTotals, PreparedDeployment, PreparedPriceFeedDeployment, PriceChartArgs, PriceFeedArgs, PriceFeedChartPoint, PriceFeedNotInStoreError, PriceFeedPair, PriceFeedPrice, PriceFeedPriceChart, PriceFeedRef, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError, deriveEffectiveStalenessPeriod, priceFeedSalt };

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

@@ -2,8 +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 { Address } from "viem";
+import { AssetArgs, AssetCap, AssetsArgs, FeedCap, MarketCap, PermissionlessAssetDetails, PermissionlessAssetSummary, PermissionlessPriceFeedDetails, PermissionlessPriceFeedStore, PriceFeedArgs, PriceFeedPrice, PriceFeedRef } from "./types.js";
 //#region src/permissionless/api/oracles/PermissionlessOracles.d.ts
 export declare const GET_PRICES_GAS_LIMIT_BY_CHAIN_ID: Record<number, bigint>;
 export declare const GET_PRICES_CHUNK_SIZE = 200;
@@ -13,9 +12,17 @@ export declare const GET_PRICES_CHUNK_SIZE = 200;
  *
  * ```ts
  * const store = await permissionless.oracles.store({ chainId: 1 });
- * const { prices } = await permissionless.oracles.prices({ chainId: 1 });
+ * const prices = await permissionless.oracles.getPrices(
+ *   store.priceFeeds.map(({ address }) => ({ chainId: 1, address })),
+ * );
  * ```
  *
+ * The backend answers what it has indexed; anything that is only true at a
+ * block — a price, a market cap, a quota in one currency, the period an
+ * oracle holds for a slot — is read here, off the chain, and folded into what
+ * it answered. That is why these reads mix a request with a multicall rather
+ * than being either one.
+ *
  * Read-only. What the store carries is decided on chain, so putting a feed
  * there is a batch the instance owner executes — see
  * {@link InstanceOwnerTransactions} — not a row a client writes here.
@@ -25,10 +32,33 @@ export declare class PermissionlessOracles extends AbstractOffchainNamespace {
   constructor(options: GearboxPermissionlessOptions, chains: ChainsNamespace);
   /**
    * The store with the assets and feeds of one chain.
+   *
+   * {@link stores} narrowed to one and unwrapped, which is the whole of it:
+   * there is one route either way, and a chain the backend does not serve has
+   * no store to answer with rather than an empty one.
+   *
+   * @throws When the backend serves no store for the chain.
    **/
   store({ chainId }: {
     chainId: number;
   }): Promise<PermissionlessPriceFeedStore>;
+  /**
+   * The same stores for every chain the backend serves.
+   *
+   * One request rather than {@link store} per chain, which is what a page
+   * showing all of them would otherwise do: the backend assembles them in the
+   * same few queries it assembles one in, so the chains cost little more than
+   * the largest of them.
+   *
+   * Each entry names its own chain, so a store is never attributed by
+   * position. `chainId` narrows it to one, for a caller that wants the list
+   * shape either way.
+   *
+   * ```ts
+   * const stores = await permissionless.oracles.stores();
+   * ```
+   **/
+  stores({ chainId }?: AssetsArgs): Promise<PermissionlessPriceFeedStore[]>;
   /**
    * One feed of the store: what it is, which assets it may price, and which
    * market slots it currently fills.
@@ -44,10 +74,59 @@ export declare class PermissionlessOracles extends AbstractOffchainNamespace {
    * });
    * ```
    *
+   * Each market row also carries the staleness period that market's own
+   * oracle holds for the slot, read off the chain here — see
+   * {@link PermissionlessPriceFeedMarket.marketStalenessPeriod}.
+   *
    * @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>;
+  /**
+   * 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 });
+   * ```
+   *
+   * The quota totals are worked out here, over the very market rows this
+   * answers with — see {@link PermissionlessQuotaTotals}.
+   *
+   * @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>;
+  /**
+   * 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.
+   *
+   * Each row also carries its quota totals and what this SDK's tables say the
+   * asset is, neither of which is served — see
+   * {@link PermissionlessAssetSummary}. The totals are what the last two terms
+   * of the order are over, so this waits for them rather than handing back a
+   * list that would reshuffle a moment later.
+   *
+   * ```ts
+   * const assets = await permissionless.oracles.assets({ chainId: 1 });
+   * const everywhere = await permissionless.oracles.assets();
+   * ```
+   **/
+  assets({ chainId }?: AssetsArgs): Promise<PermissionlessAssetSummary[]>;
   /**
    * The feeds one feed reads from, recursively.
    *
@@ -64,54 +143,58 @@ export declare class PermissionlessOracles extends AbstractOffchainNamespace {
    **/
   dependencies({ chainId, address }: PriceFeedArgs): Promise<PriceFeedData>;
   /**
-   * What the market values each of one feed's assets at.
+   * What the named feeds price, read off the chain.
    *
-   * 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.
+   * Prices exactly what is asked for, at the current block, across as many
+   * chains as the list names — one read per chain, so a screen listing every
+   * chain's feeds pays per chain and not per row. A feed the store does not
+   * carry prices the same way, which is what makes this the call to reach for
+   * after a deploy, or while a form is still choosing between candidates.
+   *
+   * Read in two passes. The first asks every feed what it reports as it
+   * stands, which is one multicall per chain; a feed that will not answer
+   * until it has been given a fresh one is then priced inside a simulation
+   * that updates it first, so a push-based feed prices as readily as a
+   * pull-based one. The second pass costs an `OnchainSDK` to attach, hence
+   * only the feeds that need it rather than all of them.
+   *
+   * `null` is a feed neither pass could read, and a chain with no client
+   * configured is every one of its feeds reading `null` rather than a failed
+   * call — the figures built on them are floors either way.
    *
    * ```ts
-   * const { marketCaps } = await permissionless.oracles.feedMarketCaps({
-   *   chainId: 1,
-   *   address: feed,
-   * });
+   * const [{ price }] = await permissionless.oracles.getPrices([
+   *   { 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.
+   * @returns One entry per feed asked for, in the order asked, each price in
+   * the 8 decimals every Gearbox feed reports.
    **/
-  prices({ chainId }: {
-    chainId: number;
-  }): Promise<PermissionlessPrices>;
+  getPrices(feeds: PriceFeedRef[]): Promise<PriceFeedPrice[]>;
   /**
-   * The price each of the named feeds reports, read off the chain.
+   * What one chain's feeds value one chain's assets at: `price × totalSupply`
+   * per pair.
    *
-   * Where {@link prices} answers for the store as a whole and at whatever
-   * moment the backend priced it, this prices exactly the feeds asked for, at
-   * the current block. A feed the store does not carry prices the same way,
-   * which is what makes this the call to reach for after a deploy, or while a
-   * form is still choosing between candidates.
+   * Asked from whichever side the caller is looking at — one asset through
+   * each of its feeds, or one feed over each of the assets it prices — because
+   * a screen shows one row per feed or one row per asset, never the full
+   * cross product. Both answer the same pairs in the same shape.
    *
-   * Feeds needing a fresh answer before they can be read are updated inside
-   * the same simulation, so a push-based feed prices as readily as a
-   * pull-based one. `null` is a feed whose read reverted, not a zero.
+   * Two reads per chain: the prices, and one multicall for the assets'
+   * supplies and decimals. Several scopes can be asked at once, which is how a
+   * table of every asset's feeds pays per chain rather than per row; the pairs
+   * come back in the order the scopes named them. A pair neither read could
+   * resolve has a `null` cap, which is not a zero.
    *
    * ```ts
-   * const prices = await permissionless.oracles.getPrices({
+   * const caps = await permissionless.oracles.getMarketCap({
    *   chainId: 1,
-   *   priceFeeds: [feed],
+   *   asset: token,
+   *   priceFeeds: [main, reserve],
    * });
    * ```
-   *
-   * @returns A price per feed, in the 8 decimals every Gearbox feed reports.
    **/
-  getPrices({ chainId, priceFeeds }: GetPricesArgs): Promise<Record<Address, bigint | null>>;
+  getMarketCap(scope: AssetCap | FeedCap | Array<AssetCap | FeedCap>): Promise<MarketCap[]>;
 }
 //#endregion

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

@@ -0,0 +1,59 @@
+import { PermissionlessAssetQuota, PermissionlessIndexedAssetSummary, PermissionlessQuotaTotals, PriceFeedPrice } from "./types.js";
+import { Address } from "viem";
+//#region src/permissionless/api/oracles/enrich.d.ts
+/**
+ * What the oracles namespace works out for itself once the backend has
+ * answered.
+ *
+ * All of it used to be the backend's, and all of it needs the chain: a quota
+ * is denominated in its market's own underlying and a market cap is a supply
+ * times a price, so none of these can be indexed — they can only be read at
+ * the block the reader is on. Keeping them here means one description of each
+ * rule rather than one per service that wants it, and a backend that holds no
+ * viem client at all.
+ **/
+/** Identifies a feed across chains, since an address alone does not. */
+export declare function feedKey(chainId: number, address: Address): string;
+/** Prices looked up the way {@link totalQuotas} and the caps need them. */
+export declare function pricesByFeed(prices: PriceFeedPrice[]): Map<string, bigint | null>;
+/**
+ * The asset's quota across its markets, totalled in USD.
+ *
+ * Each market's figures are converted at the price that market's own oracle
+ * holds for its underlying, which is the same number that market's accounting
+ * uses.
+ *
+ * Limits count only the markets still running, because a shut down market's
+ * limit is not borrowable; what is already quoted counts everywhere, because
+ * debt outstanding is exposure either way. A market whose underlying could not
+ * be priced is skipped, which makes both figures floors, and `null` is nothing
+ * to total rather than a zero.
+ *
+ * @param priceOf - The price each underlying feed reports, in the 8 decimals
+ * every Gearbox feed uses.
+ */
+export declare function totalQuotas(quotas: PermissionlessAssetQuota[], priceOf: (feed: Address) => bigint | null | undefined): PermissionlessQuotaTotals;
+/**
+ * What one feed values one asset's supply at: `price × totalSupply`.
+ *
+ * Multiplied as integers and formatted once, rather than through two floats:
+ * an 8-decimal price times an 18-decimal supply loses its small end to a JS
+ * number long before it loses the large one, and the figure is a total rather
+ * than an estimate.
+ *
+ * `null` if either side could not be read — an asset nobody could price is
+ * not an asset worth nothing.
+ */
+export declare function toCap(price: bigint | null | undefined, totalSupply: bigint | null | undefined, decimals: number): string | null;
+/**
+ * Assets ordered the way a reader scans them: what the protocol is built on
+ * first, then what is actually borrowed against it, then what it is merely
+ * allowed to be borrowed against.
+ *
+ * Applied here and not by the backend because the two middle terms are the
+ * converted quotas, which only exist once the chain has been read. The
+ * backend orders by the first term and the tie-breakers, so a caller reading
+ * the route directly still gets a stable order; this refines it.
+ */
+export declare function byCentrality<T extends PermissionlessIndexedAssetSummary & PermissionlessQuotaTotals>(a: T, b: T): number;
+//#endregion

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, AssetCap, AssetsArgs, FeedCap, MarketCap, PermissionlessAsset, PermissionlessAssetDetails, PermissionlessAssetMarket, PermissionlessAssetMarketFeed, PermissionlessAssetQuota, PermissionlessAssetSummary, PermissionlessIndexedAssetDetails, PermissionlessIndexedAssetSummary, PermissionlessIndexedPriceFeedDetails, PermissionlessIndexedPriceFeedMarket, PermissionlessMarket, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedStore, PermissionlessQuotaTotals, PriceFeedArgs, PriceFeedPrice, PriceFeedRef } 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, AssetCap, AssetsArgs, FeedCap, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, MarketCap, PermissionlessAsset, PermissionlessAssetDetails, PermissionlessAssetMarket, PermissionlessAssetMarketFeed, PermissionlessAssetQuota, PermissionlessAssetSummary, PermissionlessIndexedAssetDetails, PermissionlessIndexedAssetSummary, PermissionlessIndexedPriceFeedDetails, PermissionlessIndexedPriceFeedMarket, PermissionlessMarket, PermissionlessOracles, PermissionlessPriceFeedAsset, PermissionlessPriceFeedDetails, PermissionlessPriceFeedMarket, PermissionlessPriceFeedStore, PermissionlessQuotaTotals, PriceFeedArgs, PriceFeedPrice, PriceFeedRef };

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

@@ -17,7 +17,18 @@ export declare const priceFeedSchema: z.ZodObject<{
   stalenessPeriod: z.ZodNumber;
   name: z.ZodString;
 }, z.core.$loose>;
-/** {@link PermissionlessAsset} */
+/**
+ * {@link PermissionlessPriceFeedAsset}
+ *
+ * What identifies an asset, which is all a feed's own listing of one says.
+ **/
+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 PermissionlessAsset} — identified as above, plus what prices it. */
 export declare const assetSchema: z.ZodObject<{
   address: z.ZodCustom<`0x${string}`, `0x${string}`>;
   symbol: z.ZodString;
@@ -33,7 +44,12 @@ export declare const assetSchema: z.ZodObject<{
     name: z.ZodString;
   }, z.core.$loose>>;
 }, z.core.$loose>;
-/** {@link PermissionlessPriceFeedStore} */
+/**
+ * {@link PermissionlessPriceFeedStore}
+ *
+ * A store is a chain's, and is described by the same five fields the chain
+ * list answers with, so those are extended rather than restated.
+ **/
 export declare const priceFeedStoreSchema: z.ZodObject<{
   chainId: z.ZodNumber;
   name: z.ZodString;
@@ -64,33 +80,56 @@ export declare const priceFeedStoreSchema: z.ZodObject<{
     name: z.ZodString;
   }, z.core.$loose>>;
 }, z.core.$loose>;
-/** {@link PermissionlessPrices} */
-export declare const pricesSchema: 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}`, 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;
+/** Every chain's {@link PermissionlessPriceFeedStore}, one per chain. */
+export declare const priceFeedStoresSchema: z.ZodArray<z.ZodObject<{
+  chainId: z.ZodNumber;
   name: z.ZodString;
-  decimals: z.ZodNumber;
-}, z.core.$loose>;
-/** {@link PermissionlessPriceFeedMarket} */
+  isPublic: z.ZodBoolean;
+  isActivated: z.ZodBoolean;
+  explorerUrl: z.ZodString;
+  assets: z.ZodArray<z.ZodObject<{
+    address: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    symbol: z.ZodString;
+    name: z.ZodString;
+    decimals: z.ZodNumber;
+    owner: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    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>>;
+  }, 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>>;
+}, z.core.$loose>>;
+/**
+ * {@link PermissionlessIndexedPriceFeedMarket} — the market as the feed's slot
+ * in it, before the oracle is asked what period it holds for the slot.
+ **/
 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>;
+  quotaUsed: z.ZodNullable<z.ZodNumber>;
+  token: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  tokenSymbol: z.ZodNullable<z.ZodString>;
+  reserve: z.ZodBoolean;
+  priceOracle: z.ZodCustom<`0x${string}`, `0x${string}`>;
 }, z.core.$loose>;
-/** {@link PermissionlessPriceFeedDetails} */
+/** {@link PermissionlessIndexedPriceFeedDetails} */
 export declare const priceFeedDetailsSchema: z.ZodObject<{
   chainId: z.ZodNumber;
   priceFeed: z.ZodObject<{
@@ -112,17 +151,118 @@ export declare const priceFeedDetailsSchema: z.ZodObject<{
     marketConfigurator: z.ZodCustom<`0x${string}`, `0x${string}`>;
     curatorName: z.ZodNullable<z.ZodString>;
     marketName: z.ZodNullable<z.ZodString>;
+    underlyingSymbol: z.ZodNullable<z.ZodString>;
+    isUnderlying: z.ZodBoolean;
+    quotaLimit: z.ZodNullable<z.ZodNumber>;
+    quotaUsed: z.ZodNullable<z.ZodNumber>;
     token: z.ZodCustom<`0x${string}`, `0x${string}`>;
     tokenSymbol: z.ZodNullable<z.ZodString>;
-    underlyingSymbol: z.ZodNullable<z.ZodString>;
     reserve: z.ZodBoolean;
+    priceOracle: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  }, z.core.$loose>>;
+}, 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} — the market as what prices the asset in it. */
+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>;
+  underlyingSymbol: z.ZodNullable<z.ZodString>;
+  isUnderlying: z.ZodBoolean;
+  quotaLimit: z.ZodNullable<z.ZodNumber>;
+  quotaUsed: z.ZodNullable<z.ZodNumber>;
+  underlyingToken: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  underlyingPriceFeed: z.ZodNullable<z.ZodCustom<`0x${string}`, `0x${string}`>>;
+  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>>;
+}, z.core.$loose>;
+/** {@link PermissionlessIndexedAssetDetails} */
+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>;
+    underlyingSymbol: z.ZodNullable<z.ZodString>;
     isUnderlying: z.ZodBoolean;
     quotaLimit: z.ZodNullable<z.ZodNumber>;
+    quotaUsed: z.ZodNullable<z.ZodNumber>;
+    underlyingToken: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    underlyingPriceFeed: z.ZodNullable<z.ZodCustom<`0x${string}`, `0x${string}`>>;
+    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>>;
   }, 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;
+/** {@link PermissionlessAssetQuota} */
+export declare const assetQuotaSchema: z.ZodObject<{
+  quotaLimit: z.ZodNullable<z.ZodNumber>;
+  quotaUsed: z.ZodNullable<z.ZodNumber>;
+  isShutdown: z.ZodBoolean;
+  underlyingPriceFeed: z.ZodNullable<z.ZodCustom<`0x${string}`, `0x${string}`>>;
 }, z.core.$loose>;
+/** {@link PermissionlessIndexedAssetSummary} */
+export declare const assetSummarySchema: z.ZodObject<{
+  chainId: z.ZodNumber;
+  address: z.ZodCustom<`0x${string}`, `0x${string}`>;
+  symbol: z.ZodString;
+  underlyingMarketCount: z.ZodNumber;
+  marketQuotas: z.ZodArray<z.ZodObject<{
+    quotaLimit: z.ZodNullable<z.ZodNumber>;
+    quotaUsed: z.ZodNullable<z.ZodNumber>;
+    isShutdown: z.ZodBoolean;
+    underlyingPriceFeed: z.ZodNullable<z.ZodCustom<`0x${string}`, `0x${string}`>>;
+  }, z.core.$loose>>;
+}, 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;
+  marketQuotas: z.ZodArray<z.ZodObject<{
+    quotaLimit: z.ZodNullable<z.ZodNumber>;
+    quotaUsed: z.ZodNullable<z.ZodNumber>;
+    isShutdown: z.ZodBoolean;
+    underlyingPriceFeed: z.ZodNullable<z.ZodCustom<`0x${string}`, `0x${string}`>>;
+  }, z.core.$loose>>;
+}, z.core.$loose>>;
 //#endregion