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

package/dist/esm/onchain/market/adapters/abi/actionAbi.js

@@ -32,6 +32,7 @@ const adapterActionSignatures = {
 		311: "function setPairStatusBatch((address,address,address,uint8,uint8)[])"
 	},
 	["TRADERJOE_ROUTER"]: { 310: "function setPoolStatusBatch((address,address,uint256,uint8,bool)[])" },
+	["TREEHOUSE_ROUTER"]: { 310: "function setAssetStatusBatch(address[],bool[])" },
 	["UNISWAP_V2_ROUTER"]: { 310: "function setPairStatusBatch((address,address,bool)[])" },
 	["UNISWAP_V3_ROUTER"]: { 310: "function setPoolStatusBatch((address,address,uint24,bool)[])" },
 	["UNISWAP_V4_GATEWAY"]: { 310: "function setPoolKeyStatusBatch(((address,address,uint24,int24,address),bool)[])" },

package/dist/esm/onchain/market/adapters/abi/conctructorAbi.js

@@ -35,6 +35,9 @@ const adapterConstructorAbi = {
 	["UNISWAP_V4_GATEWAY"]: { 310: BASIC_ADAPTER_ABI },
 	["VELODROME_V2_ROUTER"]: { 310: BASIC_ADAPTER_ABI },
 	["SECURITIZE_ONRAMP"]: { 310: BASIC_ADAPTER_ABI },
+	["TREEHOUSE_FASTLANE"]: { 310: BASIC_ADAPTER_ABI },
+	["TREEHOUSE_GATEWAY"]: { 310: BASIC_ADAPTER_ABI },
+	["TREEHOUSE_ROUTER"]: { 310: BASIC_ADAPTER_ABI },
 	["CURVE_V1_2ASSETS"]: { 311: CURVE_V1_ADAPTER_311_ABI },
 	["CURVE_V1_3ASSETS"]: { 311: CURVE_V1_ADAPTER_311_ABI },
 	["CURVE_V1_4ASSETS"]: { 311: CURVE_V1_ADAPTER_311_ABI },

package/dist/esm/onchain/market/adapters/types.js

@@ -33,6 +33,9 @@ let AdapterType = /* @__PURE__ */ function(AdapterType) {
 	AdapterType["SECURITIZE_REDEMPTION"] = "SECURITIZE_REDEMPTION";
 	AdapterType["STAKING_REWARDS"] = "STAKING_REWARDS";
 	AdapterType["TRADERJOE_ROUTER"] = "TRADERJOE_ROUTER";
+	AdapterType["TREEHOUSE_FASTLANE"] = "TREEHOUSE_FASTLANE";
+	AdapterType["TREEHOUSE_GATEWAY"] = "TREEHOUSE_GATEWAY";
+	AdapterType["TREEHOUSE_ROUTER"] = "TREEHOUSE_ROUTER";
 	AdapterType["UNISWAP_V2_ROUTER"] = "UNISWAP_V2_ROUTER";
 	AdapterType["UNISWAP_V3_ROUTER"] = "UNISWAP_V3_ROUTER";
 	AdapterType["UNISWAP_V4_GATEWAY"] = "UNISWAP_V4_GATEWAY";

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

@@ -1,19 +1,47 @@
+import { getAssetType, getNetworkType, isRWAToken, isSupportedNetwork } from "../../../onchain/chain/chains.js";
+import { AP_PRICE_FEED_COMPRESSOR } from "../../../onchain/constants/address-provider.js";
 import { priceFeedDataSchema } from "../../../model/opportunities.schema.js";
+import { priceFeedCompressorAbi } from "../../../abi/compressors/priceFeedCompressor.js";
+import "../../../onchain/index.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 "../../deployment/addresses.js";
+import { AddressProviderContract } from "../../bindings/address-provider.js";
+import { getLatestPrices, getPrices } from "../../utils/price-update/get-prices.js";
+import { byCentrality, feedKey, pricesByFeed, toCap, totalQuotas } from "./enrich.js";
+import { assetDetailsSchema, assetSummariesSchema, priceFeedDetailsSchema, priceFeedStoresSchema } from "./schemas.js";
+import { erc20Abi } from "viem";
 //#region src/permissionless/api/oracles/PermissionlessOracles.ts
 const GET_PRICES_GAS_LIMIT_BY_CHAIN_ID = { 143: 100000000n };
 const GET_PRICES_CHUNK_SIZE = 200;
 /**
+* What a market slot is: an oracle, a token, and whether it is the reserve
+* one. Not the market — a market that has switched oracles has rows under
+* each, and the slots are the old oracle's and the new one's separately.
+*/
+function slotKey(oracle, token, reserve) {
+	return `${oracle.toLowerCase()}:${token.toLowerCase()}:${reserve}`;
+}
+/** An unknown thrown value, as something a log line can carry. */
+function describe(e) {
+	return e instanceof Error ? e.message : String(e);
+}
+/**
 * The price feeds of one chain: the PriceFeedStore as the backend has indexed
 * it, and the prices behind it.
 *
 * ```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.
@@ -29,11 +57,39 @@ var PermissionlessOracles = class extends AbstractOffchainNamespace {
 	}
 	/**
 	* 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.
 	**/
 	async store({ chainId }) {
+		const [store] = await this.stores({ chainId });
+		if (!store) throw new Error(`no PriceFeedStore served for chain ${chainId}`);
+		return store;
+	}
+	/**
+	* 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();
+	* ```
+	**/
+	async stores({ chainId } = {}) {
 		return this.getData({
-			path: `/pfs/${chainId}`,
-			schema: priceFeedStoreSchema
+			path: "/pfs/stores",
+			query: { chainId: chainId?.toString() },
+			schema: priceFeedStoresSchema
 		});
 	}
 	/**
@@ -51,14 +107,186 @@ var PermissionlessOracles = class 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.
 	**/
 	async feed({ chainId, address }) {
-		return this.getData({
+		const feed = address.toLowerCase();
+		const indexed = await this.getData({
 			path: `/pfs/${chainId}/price-feed/${address}`,
 			schema: priceFeedDetailsSchema
 		});
+		const periods = await this.#stalenessPeriods(chainId, feed, indexed.markets);
+		return {
+			...indexed,
+			markets: indexed.markets.map((market) => ({
+				...market,
+				marketStalenessPeriod: periods.get(slotKey(market.priceOracle, market.token, market.reserve)) ?? null
+			}))
+		};
+	}
+	/**
+	* Staleness period each market's own oracle holds for the feed's slots,
+	* keyed by {@link slotKey}.
+	*
+	* One call per oracle rather than per slot: the compressor answers for a
+	* whole oracle at once, and a feed in a dozen markets of the same curator
+	* would otherwise pay a round trip per token. Scoped to the tokens actually
+	* asked about, since the unscoped overload returns the oracle's entire feed
+	* tree as well.
+	*
+	* Failures are warnings and not errors. A slot missing from the answer keeps
+	* its `null`, which the caller reports as "the oracle would not say" — the
+	* alternative is failing a read whose indexed half is perfectly good.
+	*/
+	async #stalenessPeriods(chainId, feed, rows) {
+		const periods = /* @__PURE__ */ new Map();
+		if (rows.length === 0) return periods;
+		const tokensByOracle = /* @__PURE__ */ new Map();
+		for (const row of rows) {
+			let tokens = tokensByOracle.get(row.priceOracle);
+			if (!tokens) {
+				tokens = /* @__PURE__ */ new Set();
+				tokensByOracle.set(row.priceOracle, tokens);
+			}
+			tokens.add(row.token);
+		}
+		let client;
+		let compressor;
+		try {
+			client = this.#chains.client(chainId);
+			compressor = await new AddressProviderContract("0xF7f0a609BfAb9a0A98786951ef10e5FE26cC1E38", client).getLatestVersionAddress(AP_PRICE_FEED_COMPRESSOR);
+		} catch (e) {
+			this.logger?.warn(`no PriceFeedCompressor for chain ${chainId}, reporting no market staleness periods: ${describe(e)}`);
+			return periods;
+		}
+		const oracles = [...tokensByOracle.keys()];
+		const results = await client.multicall({
+			contracts: oracles.map((oracle) => ({
+				address: compressor,
+				abi: priceFeedCompressorAbi,
+				functionName: "getPriceOracleState",
+				args: [oracle, [...tokensByOracle.get(oracle) ?? []]]
+			})),
+			allowFailure: true
+		});
+		oracles.forEach((oracle, i) => {
+			const result = results[i];
+			if (result?.status !== "success") {
+				this.logger?.warn(`price oracle ${oracle} of chain ${chainId} would not report its feed map`);
+				return;
+			}
+			const { priceFeedMap } = result.result;
+			for (const entry of priceFeedMap) {
+				if (entry.priceFeed.toLowerCase() !== feed) continue;
+				periods.set(slotKey(oracle, entry.token, entry.reserve), Number(entry.stalenessPeriod));
+			}
+		});
+		return periods;
+	}
+	/**
+	* 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.
+	**/
+	async asset({ chainId, address }) {
+		const indexed = await this.getData({
+			path: `/pfs/${chainId}/asset/${address}`,
+			schema: assetDetailsSchema
+		});
+		const priceOf = await this.#underlyingPrices(indexed.markets.map((market) => ({
+			chainId,
+			underlyingPriceFeed: market.underlyingPriceFeed
+		})));
+		return {
+			...indexed,
+			...totalQuotas(indexed.markets, (feed) => priceOf(chainId, feed))
+		};
+	}
+	/**
+	* The price of every underlying the given quota rows name, looked up by
+	* chain and feed.
+	*
+	* Distinct feeds only, because an asset in a dozen markets of the same
+	* underlying names the same feed a dozen times, and a list of every chain's
+	* assets names a handful of feeds per chain between them all.
+	*/
+	async #underlyingPrices(rows) {
+		const refs = /* @__PURE__ */ new Map();
+		for (const { chainId, underlyingPriceFeed } of rows) {
+			if (underlyingPriceFeed === null) continue;
+			const address = underlyingPriceFeed.toLowerCase();
+			refs.set(feedKey(chainId, address), {
+				chainId,
+				address
+			});
+		}
+		const prices = pricesByFeed(await this.getPrices([...refs.values()]));
+		return (chainId, feed) => prices.get(feedKey(chainId, feed));
+	}
+	/**
+	* 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();
+	* ```
+	**/
+	async assets({ chainId } = {}) {
+		const indexed = await this.getData({
+			path: "/pfs/assets",
+			query: { chainId: chainId?.toString() },
+			schema: assetSummariesSchema
+		});
+		const networks = /* @__PURE__ */ new Map();
+		for (const { chainId: id } of indexed) if (!networks.has(id)) networks.set(id, isSupportedNetwork(id) ? getNetworkType(id) : void 0);
+		const priceOf = await this.#underlyingPrices(indexed.flatMap((asset) => asset.marketQuotas.map((quota) => ({
+			chainId: asset.chainId,
+			underlyingPriceFeed: quota.underlyingPriceFeed
+		}))));
+		return indexed.map((asset) => {
+			const network = networks.get(asset.chainId);
+			return {
+				...asset,
+				...totalQuotas(asset.marketQuotas, (feed) => priceOf(asset.chainId, feed)),
+				assetType: network === void 0 ? null : getAssetType(asset.address, network) ?? null,
+				isRwa: network === void 0 ? false : isRWAToken(asset.address, network)
+			};
+		}).sort(byCentrality);
 	}
 	/**
 	* The feeds one feed reads from, recursively.
@@ -81,69 +309,188 @@ var PermissionlessOracles = class extends AbstractOffchainNamespace {
 		});
 	}
 	/**
-	* 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 },
+	* ]);
 	* ```
-	**/
-	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.
+	* @returns One entry per feed asked for, in the order asked, each price in
+	* the 8 decimals every Gearbox feed reports.
 	**/
-	async prices({ chainId }) {
-		return this.getData({
-			path: `/pfs/${chainId}/prices`,
-			schema: pricesSchema
-		});
+	async getPrices(feeds) {
+		const byChain = /* @__PURE__ */ new Map();
+		for (const { chainId, address } of feeds) {
+			const addresses = byChain.get(chainId) ?? /* @__PURE__ */ new Set();
+			addresses.add(address.toLowerCase());
+			byChain.set(chainId, addresses);
+		}
+		const chainIds = [...byChain.keys()];
+		const results = await Promise.all(chainIds.map((chainId) => this.#pricesOf(chainId, [...byChain.get(chainId) ?? []])));
+		const prices = new Map(chainIds.map((id, i) => [id, results[i] ?? {}]));
+		return feeds.map(({ chainId, address }) => ({
+			chainId,
+			address,
+			price: prices.get(chainId)?.[address.toLowerCase()] ?? null
+		}));
+	}
+	/** One chain's half of {@link getPrices}: the cheap pass, then the rest. */
+	async #pricesOf(chainId, priceFeeds) {
+		let client;
+		try {
+			client = this.#chains.client(chainId);
+		} catch (e) {
+			this.logger?.warn(`chain ${chainId} has no client, reporting its ${priceFeeds.length} feed(s) unpriced: ${describe(e)}`);
+			return {};
+		}
+		let prices;
+		try {
+			prices = await getLatestPrices({
+				client,
+				priceFeeds
+			});
+		} catch (e) {
+			this.logger?.warn(`chain ${chainId} would not answer for its ${priceFeeds.length} feed(s), trying each with an update: ${describe(e)}`);
+			prices = {};
+		}
+		const stale = priceFeeds.filter((feed) => (prices[feed] ?? null) === null);
+		if (stale.length === 0) return prices;
+		try {
+			return {
+				...prices,
+				...await getPrices({
+					client,
+					priceFeeds: stale,
+					chunkSize: 200,
+					gasLimit: GET_PRICES_GAS_LIMIT_BY_CHAIN_ID[chainId]
+				})
+			};
+		} catch (e) {
+			this.logger?.warn(`chain ${chainId} would not price ${stale.length} of its feed(s) even with an update, reporting them unpriced: ${describe(e)}`);
+			return prices;
+		}
 	}
 	/**
-	* 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.
 	**/
-	async getPrices({ chainId, priceFeeds }) {
-		return getPrices({
-			client: this.#chains.client(chainId),
-			priceFeeds,
-			chunkSize: 200,
-			gasLimit: GET_PRICES_GAS_LIMIT_BY_CHAIN_ID[chainId]
+	async getMarketCap(scope) {
+		const pairs = (Array.isArray(scope) ? scope : [scope]).flatMap((one) => "asset" in one ? one.priceFeeds.map((priceFeed) => ({
+			chainId: one.chainId,
+			priceFeed: priceFeed.toLowerCase(),
+			asset: one.asset.toLowerCase()
+		})) : one.assets.map((asset) => ({
+			chainId: one.chainId,
+			priceFeed: one.priceFeed.toLowerCase(),
+			asset: asset.toLowerCase()
+		})));
+		if (pairs.length === 0) return [];
+		const feeds = /* @__PURE__ */ new Map();
+		const assetsByChain = /* @__PURE__ */ new Map();
+		for (const { chainId, priceFeed, asset } of pairs) {
+			feeds.set(feedKey(chainId, priceFeed), {
+				chainId,
+				address: priceFeed
+			});
+			const assets = assetsByChain.get(chainId) ?? /* @__PURE__ */ new Set();
+			assets.add(asset);
+			assetsByChain.set(chainId, assets);
+		}
+		const chainIds = [...assetsByChain.keys()];
+		const [prices, perChain] = await Promise.all([this.getPrices([...feeds.values()]), Promise.all(chainIds.map((chainId) => this.#supplies(chainId, [...assetsByChain.get(chainId) ?? []])))]);
+		const priced = pricesByFeed(prices);
+		const supplies = new Map(chainIds.map((id, i) => [id, perChain[i]]));
+		return pairs.map(({ chainId, priceFeed, asset }) => {
+			const supply = supplies.get(chainId)?.get(asset);
+			return {
+				chainId,
+				priceFeed,
+				asset,
+				cap: supply === void 0 ? null : toCap(priced.get(feedKey(chainId, priceFeed)), supply.totalSupply, supply.decimals)
+			};
+		});
+	}
+	/**
+	* Each asset's supply and the decimals it is counted in, which is what turns
+	* a supply into an amount.
+	*
+	* Both read rather than one of them taken from the index, so that a cap can
+	* be asked for an address nothing was indexed for at all — a token a form is
+	* still choosing, say. An asset missing from the answer is left out, and
+	* caps over it come back `null`.
+	*/
+	async #supplies(chainId, assets) {
+		const supplies = /* @__PURE__ */ new Map();
+		let client;
+		try {
+			client = this.#chains.client(chainId);
+		} catch (e) {
+			this.logger?.warn(`chain ${chainId} has no client, reporting no market caps: ${describe(e)}`);
+			return supplies;
+		}
+		const results = await client.multicall({
+			contracts: assets.flatMap((address) => [{
+				address,
+				abi: erc20Abi,
+				functionName: "totalSupply"
+			}, {
+				address,
+				abi: erc20Abi,
+				functionName: "decimals"
+			}]),
+			allowFailure: true
+		});
+		assets.forEach((address, i) => {
+			const supply = results[2 * i];
+			const decimals = results[2 * i + 1];
+			if (decimals?.status !== "success") {
+				this.logger?.warn(`asset ${address} of chain ${chainId} would not report its decimals, reporting no market cap for it`);
+				return;
+			}
+			supplies.set(address, {
+				totalSupply: supply?.status === "success" ? supply.result : null,
+				decimals: Number(decimals.result)
+			});
 		});
+		return supplies;
 	}
 };
 //#endregion

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

@@ -0,0 +1,94 @@
+import { formatUnits } from "viem";
+//#region src/permissionless/api/oracles/enrich.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. */
+function feedKey(chainId, address) {
+	return `${chainId}:${address.toLowerCase()}`;
+}
+/** Prices looked up the way {@link totalQuotas} and the caps need them. */
+function pricesByFeed(prices) {
+	return new Map(prices.map(({ chainId, address, price }) => [feedKey(chainId, address), price]));
+}
+/**
+* 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.
+*/
+function totalQuotas(quotas, priceOf) {
+	let limit = 0;
+	let used = 0;
+	let anyLimit = false;
+	let anyUsed = false;
+	for (const quota of quotas) {
+		const raw = quota.underlyingPriceFeed === null ? null : priceOf(quota.underlyingPriceFeed);
+		if (raw === null || raw === void 0) continue;
+		const price = Number(formatUnits(raw, 8));
+		if (quota.quotaUsed !== null) {
+			used += quota.quotaUsed * price;
+			anyUsed = true;
+		}
+		if (quota.quotaLimit !== null && !quota.isShutdown) {
+			limit += quota.quotaLimit * price;
+			anyLimit = true;
+		}
+	}
+	return {
+		quotaLimitUsd: anyLimit ? limit : null,
+		quotaUsedUsd: anyUsed ? used : null
+	};
+}
+/**
+* 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.
+*/
+function toCap(price, totalSupply, decimals) {
+	if (price === null || price === void 0 || totalSupply === null || totalSupply === void 0) return null;
+	return formatUnits(price * totalSupply, 8 + decimals);
+}
+/** Larger first, with `null` after every figure including a real zero. */
+function descending(a, b) {
+	return (b ?? -1) - (a ?? -1);
+}
+/**
+* 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.
+*/
+function byCentrality(a, b) {
+	return b.underlyingMarketCount - a.underlyingMarketCount || descending(a.quotaUsedUsd, b.quotaUsedUsd) || descending(a.quotaLimitUsd, b.quotaLimitUsd) || a.symbol.localeCompare(b.symbol) || a.address.localeCompare(b.address) || a.chainId - b.chainId;
+}
+//#endregion
+export { byCentrality, feedKey, pricesByFeed, toCap, totalQuotas };