@gearbox-protocol/sdk 18.2.0-next.15 → 18.2.0-next.16

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

@@ -4,11 +4,13 @@ const require_onchain_constants_address_provider = require("../../../onchain/con
 const require_model_opportunities_schema = require("../../../model/opportunities.schema.js");
 const require_abi_compressors_priceFeedCompressor = require("../../../abi/compressors/priceFeedCompressor.js");
 require("../../../onchain/index.js");
+const require_offchain_errors_OffchainStatusError = require("../../../offchain/errors/OffchainStatusError.js");
 const require_offchain_AbstractOffchainNamespace = require("../../../offchain/AbstractOffchainNamespace.js");
 require("../../deployment/addresses.js");
 const require_permissionless_bindings_address_provider = require("../../bindings/address-provider.js");
 const require_permissionless_utils_price_update_get_prices = require("../../utils/price-update/get-prices.js");
 const require_permissionless_api_oracles_enrich = require("./enrich.js");
+const require_permissionless_api_oracles_onchain_feed = require("./onchain-feed.js");
 const require_permissionless_api_oracles_schemas = require("./schemas.js");
 const require_permissionless_api_oracles_stress_run = require("./stress/run.js");
 const require_permissionless_api_oracles_score_run = require("./score/run.js");
@@ -28,6 +30,10 @@ function slotKey(oracle, token, reserve) {
 function describe(e) {
 	return e instanceof Error ? e.message : String(e);
 }
+/** The backend answered that it has no such feed. */
+function isNotFound(e) {
+	return e instanceof require_offchain_errors_OffchainStatusError.OffchainStatusError && e.status === 404;
+}
 /**
 * The price feeds of one chain: the PriceFeedStore as the backend has indexed
 * it, and the prices behind it.
@@ -139,25 +145,65 @@ var PermissionlessOracles = class extends require_offchain_AbstractOffchainNames
 	* 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.
+	* A feed the store does not carry is read off the chain instead, through
+	* the PriceFeedCompressor, and answered with `inStore: false`: its type,
+	* version and description are the chain's, while what only the store knows
+	* — who deployed it, its staleness period, the assets it may price and the
+	* markets it fills — is answered as unknown or empty.
+	*
+	* @throws When neither the store nor the chain knows the feed. A private
+	* draft is not here — it lives in whichever app wrote it.
 	**/
 	async feed({ chainId, address }) {
 		const feed = address.toLowerCase();
-		const indexed = await this.getData({
-			path: `/pfs/${chainId}/price-feed/${address}`,
-			schema: require_permissionless_api_oracles_schemas.priceFeedDetailsSchema
-		});
+		let indexed;
+		try {
+			indexed = await this.getData({
+				path: `/pfs/${chainId}/price-feed/${address}`,
+				schema: require_permissionless_api_oracles_schemas.priceFeedDetailsSchema
+			});
+		} catch (e) {
+			const node = isNotFound(e) ? await this.#onchainNode(chainId, feed) : void 0;
+			if (!node) throw e;
+			return {
+				chainId,
+				priceFeed: require_permissionless_api_oracles_onchain_feed.onchainPriceFeed(node),
+				assets: [],
+				markets: [],
+				inStore: false
+			};
+		}
 		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
-			}))
+			})),
+			inStore: true
 		};
 	}
 	/**
+	* One feed as the PriceFeedCompressor reads it, or nothing when the chain
+	* cannot be read or the compressor does not know the feed.
+	*
+	* Failures are warnings and not errors: this only ever stands in for a
+	* store that did not have the feed, and the caller reports that miss
+	* rather than whatever kept the chain from answering in its place.
+	*/
+	async #onchainNode(chainId, feed) {
+		try {
+			const client = this.#chains.client(chainId);
+			const compressor = await new require_permissionless_bindings_address_provider.AddressProviderContract("0xF7f0a609BfAb9a0A98786951ef10e5FE26cC1E38", client).getLatestVersionAddress(require_onchain_constants_address_provider.AP_PRICE_FEED_COMPRESSOR);
+			if (compressor === viem.zeroAddress) return;
+			const { nodes } = await require_permissionless_api_oracles_stress_run.readFeedTrees(client, compressor, [feed]);
+			return nodes.get(feed);
+		} catch (e) {
+			this.logger?.warn(`could not read price feed ${feed} off chain ${chainId}: ${describe(e)}`);
+			return;
+		}
+	}
+	/**
 	* Staleness period each market's own oracle holds for the feed's slots,
 	* keyed by {@link slotKey}.
 	*

package/dist/cjs/permissionless/api/oracles/onchain-feed.js

@@ -0,0 +1,25 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let viem = require("viem");
+//#region src/permissionless/api/oracles/onchain-feed.ts
+/**
+* What the store would say about a feed, from what the chain says instead.
+*
+* Two fields are the store's alone and are answered as unknown rather than
+* guessed: who deployed it is a store row, so it is the zero address, and the
+* staleness period is a store setting a feed that was never added does not
+* have, so it is 0. The compressor reports `PRICE_FEED::EXTERNAL` for a
+* contract it cannot otherwise place; an empty type is the same thing said
+* less clearly.
+*/
+function onchainPriceFeed(node) {
+	return {
+		address: (0, viem.getAddress)(node.address),
+		contractType: node.contractType.trim() || "PRICE_FEED::EXTERNAL",
+		version: node.version,
+		deployedBy: viem.zeroAddress,
+		stalenessPeriod: 0,
+		name: node.description.trim()
+	};
+}
+//#endregion
+exports.onchainPriceFeed = onchainPriceFeed;

package/dist/cjs/permissionless/api/transactions/InstanceOwnerTransactions.js

@@ -137,10 +137,21 @@ var InstanceOwnerTransactions = class {
 		const batch = await this.#batchContext(chainId);
 		const pfCompressor = await this.#priceFeedCompressor(batch.client);
 		const known = await batch.store.getKnownPriceFeeds();
+		const isKnown = new Set(known.map(lower));
 		const feeds = await require_permissionless_api_transactions_lp_price_feeds.getFeedsToUpdate(batch.client, pfCompressor, known);
+		const addTxs = [];
+		const added = [];
 		const configureTxs = [];
-		for (const feed of feeds) configureTxs.push(...await require_permissionless_api_transactions_lp_price_feeds.updateBounds(batch.client, feed));
-		const txs = [batch.store.configurePriceFeeds(configureTxs.map((tx) => ({
+		for (const feed of feeds) {
+			const boundTxs = await require_permissionless_api_transactions_lp_price_feeds.updateBounds(batch.client, feed.address);
+			if (boundTxs.length === 0) continue;
+			if (!isKnown.has(feed.address)) {
+				addTxs.push(batch.store.addPriceFeedTx(feed.address, 0, feed.description));
+				added.push(feed.address);
+			}
+			configureTxs.push(...boundTxs);
+		}
+		const txs = [...addTxs, batch.store.configurePriceFeeds(configureTxs.map((tx) => ({
 			target: tx.to,
 			callData: tx.callData
 		})))];
@@ -149,7 +160,7 @@ var InstanceOwnerTransactions = class {
 			author: owner,
 			name: "update-bounds",
 			txs,
-			touchedFeeds: []
+			touchedFeeds: added
 		});
 	}
 	/**

package/dist/cjs/permissionless/api/transactions/lp-price-feeds.js

@@ -52,9 +52,12 @@ async function updateBounds(client, address) {
 /**
 * Of the whole feed tree behind `feeds`, the ones that are LP feeds: the
 * probe keeps whatever answers `getLPExchangeRate`.
+*
+* The trees reach past `feeds` themselves, so an LP feed read inside one of
+* them is among the results whether or not it is one of `feeds`.
 **/
 async function getFeedsToUpdate(client, pfCompressor, feeds) {
-	const updateableFeeds = /* @__PURE__ */ new Set();
+	const updateableFeeds = /* @__PURE__ */ new Map();
 	const { data } = await client.call({
 		to: pfCompressor,
 		data: (0, viem.encodeFunctionData)({
@@ -69,8 +72,8 @@ async function getFeedsToUpdate(client, pfCompressor, feeds) {
 		functionName: "loadPriceFeedTree",
 		data: data ?? "0x"
 	});
-	for (const tree of trees) updateableFeeds.add(tree.baseParams.addr.toLowerCase());
-	const candidates = Array.from(updateableFeeds);
+	for (const tree of trees) updateableFeeds.set(tree.baseParams.addr.toLowerCase(), tree.description);
+	const candidates = Array.from(updateableFeeds.keys());
 	const { results } = await require_onchain_utils_viem_simulateMulticall.simulateMulticall(client, {
 		contracts: candidates.map((feed) => ({
 			address: feed,
@@ -79,7 +82,10 @@ async function getFeedsToUpdate(client, pfCompressor, feeds) {
 		})),
 		allowFailure: true
 	});
-	return candidates.filter((_, index) => results[index]?.status === "success");
+	return candidates.filter((_, index) => results[index]?.status === "success").map((address) => ({
+		address,
+		description: updateableFeeds.get(address) ?? ""
+	}));
 }
 //#endregion
 exports.getFeedsToUpdate = getFeedsToUpdate;

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

@@ -3,15 +3,17 @@ import { AP_PRICE_FEED_COMPRESSOR } from "../../../onchain/constants/address-pro
 import { priceFeedDataSchema } from "../../../model/opportunities.schema.js";
 import { priceFeedCompressorAbi } from "../../../abi/compressors/priceFeedCompressor.js";
 import "../../../onchain/index.js";
+import { OffchainStatusError } from "../../../offchain/errors/OffchainStatusError.js";
 import { AbstractOffchainNamespace } from "../../../offchain/AbstractOffchainNamespace.js";
 import "../../deployment/addresses.js";
 import { AddressProviderContract } from "../../bindings/address-provider.js";
 import { getFeedDecimals, getLatestPrices, getPrices } from "../../utils/price-update/get-prices.js";
 import { byCentrality, feedKey, pricesByFeed, toCap, totalQuotas } from "./enrich.js";
+import { onchainPriceFeed } from "./onchain-feed.js";
 import { assetDetailsSchema, assetSummariesSchema, marketSlotsSchema, priceFeedDetailsSchema, priceFeedStoresSchema } from "./schemas.js";
-import { runStressTest } from "./stress/run.js";
+import { readFeedTrees, runStressTest } from "./stress/run.js";
 import { runAssetScores, runFeedPairScore } from "./score/run.js";
-import { erc20Abi } from "viem";
+import { erc20Abi, zeroAddress } 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;
@@ -27,6 +29,10 @@ function slotKey(oracle, token, reserve) {
 function describe(e) {
 	return e instanceof Error ? e.message : String(e);
 }
+/** The backend answered that it has no such feed. */
+function isNotFound(e) {
+	return e instanceof OffchainStatusError && e.status === 404;
+}
 /**
 * The price feeds of one chain: the PriceFeedStore as the backend has indexed
 * it, and the prices behind it.
@@ -138,25 +144,65 @@ var PermissionlessOracles = class extends AbstractOffchainNamespace {
 	* 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.
+	* A feed the store does not carry is read off the chain instead, through
+	* the PriceFeedCompressor, and answered with `inStore: false`: its type,
+	* version and description are the chain's, while what only the store knows
+	* — who deployed it, its staleness period, the assets it may price and the
+	* markets it fills — is answered as unknown or empty.
+	*
+	* @throws When neither the store nor the chain knows the feed. A private
+	* draft is not here — it lives in whichever app wrote it.
 	**/
 	async feed({ chainId, address }) {
 		const feed = address.toLowerCase();
-		const indexed = await this.getData({
-			path: `/pfs/${chainId}/price-feed/${address}`,
-			schema: priceFeedDetailsSchema
-		});
+		let indexed;
+		try {
+			indexed = await this.getData({
+				path: `/pfs/${chainId}/price-feed/${address}`,
+				schema: priceFeedDetailsSchema
+			});
+		} catch (e) {
+			const node = isNotFound(e) ? await this.#onchainNode(chainId, feed) : void 0;
+			if (!node) throw e;
+			return {
+				chainId,
+				priceFeed: onchainPriceFeed(node),
+				assets: [],
+				markets: [],
+				inStore: false
+			};
+		}
 		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
-			}))
+			})),
+			inStore: true
 		};
 	}
 	/**
+	* One feed as the PriceFeedCompressor reads it, or nothing when the chain
+	* cannot be read or the compressor does not know the feed.
+	*
+	* Failures are warnings and not errors: this only ever stands in for a
+	* store that did not have the feed, and the caller reports that miss
+	* rather than whatever kept the chain from answering in its place.
+	*/
+	async #onchainNode(chainId, feed) {
+		try {
+			const client = this.#chains.client(chainId);
+			const compressor = await new AddressProviderContract("0xF7f0a609BfAb9a0A98786951ef10e5FE26cC1E38", client).getLatestVersionAddress(AP_PRICE_FEED_COMPRESSOR);
+			if (compressor === zeroAddress) return;
+			const { nodes } = await readFeedTrees(client, compressor, [feed]);
+			return nodes.get(feed);
+		} catch (e) {
+			this.logger?.warn(`could not read price feed ${feed} off chain ${chainId}: ${describe(e)}`);
+			return;
+		}
+	}
+	/**
 	* Staleness period each market's own oracle holds for the feed's slots,
 	* keyed by {@link slotKey}.
 	*

package/dist/esm/permissionless/api/oracles/onchain-feed.js

@@ -0,0 +1,24 @@
+import { getAddress, zeroAddress } from "viem";
+//#region src/permissionless/api/oracles/onchain-feed.ts
+/**
+* What the store would say about a feed, from what the chain says instead.
+*
+* Two fields are the store's alone and are answered as unknown rather than
+* guessed: who deployed it is a store row, so it is the zero address, and the
+* staleness period is a store setting a feed that was never added does not
+* have, so it is 0. The compressor reports `PRICE_FEED::EXTERNAL` for a
+* contract it cannot otherwise place; an empty type is the same thing said
+* less clearly.
+*/
+function onchainPriceFeed(node) {
+	return {
+		address: getAddress(node.address),
+		contractType: node.contractType.trim() || "PRICE_FEED::EXTERNAL",
+		version: node.version,
+		deployedBy: zeroAddress,
+		stalenessPeriod: 0,
+		name: node.description.trim()
+	};
+}
+//#endregion
+export { onchainPriceFeed };

package/dist/esm/permissionless/api/transactions/InstanceOwnerTransactions.js

@@ -136,10 +136,21 @@ var InstanceOwnerTransactions = class {
 		const batch = await this.#batchContext(chainId);
 		const pfCompressor = await this.#priceFeedCompressor(batch.client);
 		const known = await batch.store.getKnownPriceFeeds();
+		const isKnown = new Set(known.map(lower));
 		const feeds = await getFeedsToUpdate(batch.client, pfCompressor, known);
+		const addTxs = [];
+		const added = [];
 		const configureTxs = [];
-		for (const feed of feeds) configureTxs.push(...await updateBounds(batch.client, feed));
-		const txs = [batch.store.configurePriceFeeds(configureTxs.map((tx) => ({
+		for (const feed of feeds) {
+			const boundTxs = await updateBounds(batch.client, feed.address);
+			if (boundTxs.length === 0) continue;
+			if (!isKnown.has(feed.address)) {
+				addTxs.push(batch.store.addPriceFeedTx(feed.address, 0, feed.description));
+				added.push(feed.address);
+			}
+			configureTxs.push(...boundTxs);
+		}
+		const txs = [...addTxs, batch.store.configurePriceFeeds(configureTxs.map((tx) => ({
 			target: tx.to,
 			callData: tx.callData
 		})))];
@@ -148,7 +159,7 @@ var InstanceOwnerTransactions = class {
 			author: owner,
 			name: "update-bounds",
 			txs,
-			touchedFeeds: []
+			touchedFeeds: added
 		});
 	}
 	/**

package/dist/esm/permissionless/api/transactions/lp-price-feeds.js

@@ -51,9 +51,12 @@ async function updateBounds(client, address) {
 /**
 * Of the whole feed tree behind `feeds`, the ones that are LP feeds: the
 * probe keeps whatever answers `getLPExchangeRate`.
+*
+* The trees reach past `feeds` themselves, so an LP feed read inside one of
+* them is among the results whether or not it is one of `feeds`.
 **/
 async function getFeedsToUpdate(client, pfCompressor, feeds) {
-	const updateableFeeds = /* @__PURE__ */ new Set();
+	const updateableFeeds = /* @__PURE__ */ new Map();
 	const { data } = await client.call({
 		to: pfCompressor,
 		data: encodeFunctionData({
@@ -68,8 +71,8 @@ async function getFeedsToUpdate(client, pfCompressor, feeds) {
 		functionName: "loadPriceFeedTree",
 		data: data ?? "0x"
 	});
-	for (const tree of trees) updateableFeeds.add(tree.baseParams.addr.toLowerCase());
-	const candidates = Array.from(updateableFeeds);
+	for (const tree of trees) updateableFeeds.set(tree.baseParams.addr.toLowerCase(), tree.description);
+	const candidates = Array.from(updateableFeeds.keys());
 	const { results } = await simulateMulticall(client, {
 		contracts: candidates.map((feed) => ({
 			address: feed,
@@ -78,7 +81,10 @@ async function getFeedsToUpdate(client, pfCompressor, feeds) {
 		})),
 		allowFailure: true
 	});
-	return candidates.filter((_, index) => results[index]?.status === "success");
+	return candidates.filter((_, index) => results[index]?.status === "success").map((address) => ({
+		address,
+		description: updateableFeeds.get(address) ?? ""
+	}));
 }
 //#endregion
 export { getFeedsToUpdate, updateBounds };

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

@@ -99,8 +99,14 @@ export declare class PermissionlessOracles extends AbstractOffchainNamespace {
    * 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.
+   * A feed the store does not carry is read off the chain instead, through
+   * the PriceFeedCompressor, and answered with `inStore: false`: its type,
+   * version and description are the chain's, while what only the store knows
+   * — who deployed it, its staleness period, the assets it may price and the
+   * markets it fills — is answered as unknown or empty.
+   *
+   * @throws When neither the store nor the chain knows the feed. A private
+   * draft is not here — it lives in whichever app wrote it.
    **/
   feed({ chainId, address }: PriceFeedArgs): Promise<PermissionlessPriceFeedDetails>;
   /**

package/dist/types/permissionless/api/oracles/onchain-feed.d.ts

@@ -0,0 +1,15 @@
+import { PriceFeed } from "../../core/pricefeed.js";
+import { TreeNode } from "./stress/classify.js";
+//#region src/permissionless/api/oracles/onchain-feed.d.ts
+/**
+ * What the store would say about a feed, from what the chain says instead.
+ *
+ * Two fields are the store's alone and are answered as unknown rather than
+ * guessed: who deployed it is a store row, so it is the zero address, and the
+ * staleness period is a store setting a feed that was never added does not
+ * have, so it is 0. The compressor reports `PRICE_FEED::EXTERNAL` for a
+ * contract it cannot otherwise place; an empty type is the same thing said
+ * less clearly.
+ */
+export declare function onchainPriceFeed(node: TreeNode): PriceFeed;
+//#endregion

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

@@ -170,9 +170,10 @@ export interface PermissionlessMarketSlot extends PermissionlessIndexedPriceFeed
 /**
  * One feed of the store, with everywhere the store lets it be used.
  *
- * Feeds a tree carries but the store never added have no identity to report —
- * no status history, hence no name or staleness — so the read throws for them
- * rather than answering a half-filled row.
+ * Feeds a tree carries but the store never added have no identity to report
+ * here — no status history, hence no name or staleness — so the backend does
+ * not answer for them; the SDK reads them off the chain instead, see
+ * {@link PermissionlessPriceFeedDetails.inStore}.
  **/
 export interface PermissionlessIndexedPriceFeedDetails {
   chainId: number;
@@ -190,6 +191,14 @@ export interface PermissionlessIndexedPriceFeedDetails {
  **/
 export interface PermissionlessPriceFeedDetails extends PermissionlessIndexedPriceFeedDetails {
   markets: PermissionlessPriceFeedMarket[];
+  /**
+   * Whether the answer is the store's.
+   *
+   * `false` is a deployed feed the store never added, read off the chain
+   * instead: `deployedBy` is the zero address, `stalenessPeriod` is 0, and
+   * `assets` and `markets` are empty, because all of them are store rows.
+   */
+  inStore: boolean;
 }
 /**
  * One feed as a market slot holds it.

package/dist/types/permissionless/api/transactions/lp-price-feeds.d.ts

@@ -8,9 +8,17 @@ import { Address, PublicClient } from "viem";
  * transaction. Returns nothing when the bound still fits.
  **/
 export declare function updateBounds(client: PublicClient, address: Address): Promise<RawTx[]>;
+/** An LP feed found in a feed tree, with what it calls itself on chain. */
+export interface LPFeed {
+  address: Address;
+  description: string;
+}
 /**
  * Of the whole feed tree behind `feeds`, the ones that are LP feeds: the
  * probe keeps whatever answers `getLPExchangeRate`.
+ *
+ * The trees reach past `feeds` themselves, so an LP feed read inside one of
+ * them is among the results whether or not it is one of `feeds`.
  **/
-export declare function getFeedsToUpdate(client: PublicClient, pfCompressor: Address, feeds: Address[]): Promise<Address[]>;
+export declare function getFeedsToUpdate(client: PublicClient, pfCompressor: Address, feeds: Address[]): Promise<LPFeed[]>;
 //#endregion

package/package.json

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