@gearbox-protocol/sdk 17.10.1 → 17.11.0

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

@@ -0,0 +1,84 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_offchain_AbstractOffchainNamespace = require("../../../offchain/AbstractOffchainNamespace.js");
+const require_permissionless_utils_price_update_get_prices = require("../../utils/price-update/get-prices.js");
+const require_permissionless_api_oracles_schemas = require("./schemas.js");
+//#region src/permissionless/api/oracles/PermissionlessOracles.ts
+const GET_PRICES_GAS_LIMIT_BY_CHAIN_ID = { 143: 100000000n };
+const GET_PRICES_CHUNK_SIZE = 200;
+/**
+* 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 });
+* ```
+*
+* 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.
+**/
+var PermissionlessOracles = class extends require_offchain_AbstractOffchainNamespace.AbstractOffchainNamespace {
+	#chains;
+	constructor(options, chains) {
+		super("PermissionlessOracles", {
+			...options,
+			chainIds: []
+		});
+		this.#chains = chains;
+	}
+	/**
+	* The store with the assets and feeds of one chain.
+	**/
+	async store({ chainId }) {
+		return this.getData({
+			path: `/pfs/${chainId}`,
+			schema: require_permissionless_api_oracles_schemas.priceFeedStoreSchema
+		});
+	}
+	/**
+	* 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.
+	**/
+	async prices({ chainId }) {
+		return this.getData({
+			path: `/pfs/${chainId}/prices`,
+			schema: require_permissionless_api_oracles_schemas.pricesSchema
+		});
+	}
+	/**
+	* The price each of the named feeds reports, read off the chain.
+	*
+	* 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.
+	*
+	* 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.
+	*
+	* ```ts
+	* const prices = await permissionless.oracles.getPrices({
+	*   chainId: 1,
+	*   priceFeeds: [feed],
+	* });
+	* ```
+	*
+	* @returns A price per feed, in the 8 decimals every Gearbox feed reports.
+	**/
+	async getPrices({ chainId, priceFeeds }) {
+		return require_permissionless_utils_price_update_get_prices.getPrices({
+			client: this.#chains.client(chainId),
+			priceFeeds,
+			chunkSize: 200,
+			gasLimit: GET_PRICES_GAS_LIMIT_BY_CHAIN_ID[chainId]
+		});
+	}
+};
+//#endregion
+exports.GET_PRICES_CHUNK_SIZE = GET_PRICES_CHUNK_SIZE;
+exports.GET_PRICES_GAS_LIMIT_BY_CHAIN_ID = GET_PRICES_GAS_LIMIT_BY_CHAIN_ID;
+exports.PermissionlessOracles = PermissionlessOracles;

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

@@ -0,0 +1,6 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_permissionless_api_oracles_PermissionlessOracles = require("./PermissionlessOracles.js");
+require("./types.js");
+exports.GET_PRICES_CHUNK_SIZE = require_permissionless_api_oracles_PermissionlessOracles.GET_PRICES_CHUNK_SIZE;
+exports.GET_PRICES_GAS_LIMIT_BY_CHAIN_ID = require_permissionless_api_oracles_PermissionlessOracles.GET_PRICES_GAS_LIMIT_BY_CHAIN_ID;
+exports.PermissionlessOracles = require_permissionless_api_oracles_PermissionlessOracles.PermissionlessOracles;

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

@@ -0,0 +1,64 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_permissionless_api_schemas = require("../schemas.js");
+let zod_v4 = require("zod/v4");
+//#region src/permissionless/api/oracles/schemas.ts
+/**
+* Runtime schemas for {@link ./types.js}.
+*
+* The objects are loose: the backend reads most of these rows straight off the
+* chain through the SDK's own bindings, which attach fields the hand-written
+* types do not declare, and dropping them would make this client lossier than
+* the payload it decodes.
+**/
+/** {@link PriceFeed}, as the backend serves it. */
+const priceFeedSchema = zod_v4.z.looseObject({
+	address: require_permissionless_api_schemas.addressSchema,
+	contractType: zod_v4.z.string(),
+	version: zod_v4.z.number(),
+	deployedBy: require_permissionless_api_schemas.addressSchema,
+	isInStore: zod_v4.z.boolean(),
+	stalenessPeriod: zod_v4.z.number(),
+	name: zod_v4.z.string()
+});
+/** {@link PermissionlessPriceFeedStatus} */
+const priceFeedStatusSchema = zod_v4.z.enum([
+	"private",
+	"inStore",
+	"pendingForbidden",
+	"forbidden"
+]);
+/** {@link PermissionlessAsset} */
+const assetSchema = zod_v4.z.looseObject({
+	address: require_permissionless_api_schemas.addressSchema,
+	symbol: zod_v4.z.string(),
+	name: zod_v4.z.string(),
+	decimals: zod_v4.z.number(),
+	isInStore: zod_v4.z.boolean(),
+	owner: require_permissionless_api_schemas.addressSchema,
+	priceFeeds: zod_v4.z.array(zod_v4.z.looseObject({
+		pricefeed: priceFeedSchema,
+		status: priceFeedStatusSchema
+	}))
+});
+/** {@link PermissionlessPriceFeedStore} */
+const priceFeedStoreSchema = zod_v4.z.looseObject({
+	chainId: zod_v4.z.number(),
+	name: zod_v4.z.string(),
+	isPublic: zod_v4.z.boolean(),
+	isActivated: zod_v4.z.boolean(),
+	explorerUrl: zod_v4.z.string(),
+	assets: zod_v4.z.array(assetSchema),
+	priceFeeds: zod_v4.z.array(priceFeedSchema)
+});
+/** {@link PermissionlessPrices} */
+const pricesSchema = zod_v4.z.looseObject({
+	prices: require_permissionless_api_schemas.addressRecord(zod_v4.z.string().nullable()),
+	marketCaps: require_permissionless_api_schemas.addressRecord(require_permissionless_api_schemas.addressRecord(zod_v4.z.string().nullable())),
+	time: zod_v4.z.number()
+});
+//#endregion
+exports.assetSchema = assetSchema;
+exports.priceFeedSchema = priceFeedSchema;
+exports.priceFeedStatusSchema = priceFeedStatusSchema;
+exports.priceFeedStoreSchema = priceFeedStoreSchema;
+exports.pricesSchema = pricesSchema;

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

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

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

@@ -0,0 +1,28 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let viem = require("viem");
+let zod_v4 = require("zod/v4");
+//#region src/permissionless/api/schemas.ts
+/**
+* Runtime schemas shared by the {@link GearboxPermissionless} namespaces.
+*
+* Addresses are validated but never rewritten: the backend serves them in the
+* case its database holds, and its payloads key records by address, so
+* checksumming here would silently break a lookup by the key it answered with.
+* A caller that needs one form converts with viem's `getAddress`.
+**/
+/** An address, in whatever case the backend serves it. */
+const addressSchema = zod_v4.z.custom((value) => typeof value === "string" && (0, viem.isAddress)(value, { strict: false }), { message: "invalid address" });
+/** A `0x`-prefixed hex string, as viem's `Hex`. */
+const hexSchema = zod_v4.z.custom((value) => typeof value === "string" && (0, viem.isHex)(value), { message: "invalid hex string" });
+/**
+* A record keyed by address. Spelled out here because zod types a record key
+* by the schema's output, which the branded `Address` is not inferred as.
+**/
+function addressRecord(value) {
+	const key = zod_v4.z.string().refine((v) => (0, viem.isAddress)(v, { strict: false }), { message: "invalid address" });
+	return zod_v4.z.record(key, value);
+}
+//#endregion
+exports.addressRecord = addressRecord;
+exports.addressSchema = addressSchema;
+exports.hexSchema = hexSchema;

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

@@ -0,0 +1,230 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_utils_createRawTx = require("../../../onchain/utils/createRawTx.js");
+const require_onchain_chain_chains = require("../../../onchain/chain/chains.js");
+const require_onchain_constants_address_provider = require("../../../onchain/constants/address-provider.js");
+const require_onchain_constants_versions = require("../../../onchain/constants/versions.js");
+const require_onchain_base_ChainContractsRegister = require("../../../onchain/base/ChainContractsRegister.js");
+const require_onchain_OnchainSDK = require("../../../onchain/OnchainSDK.js");
+require("../../../onchain/index.js");
+const require_permissionless_api_errors = require("../errors.js");
+const require_permissionless_utils_literals = require("../../utils/literals.js");
+const require_permissionless_bindings_price_feed_store = require("../../bindings/price-feed-store.js");
+require("../../deployment/addresses.js");
+const require_permissionless_bindings_address_provider = require("../../bindings/address-provider.js");
+const require_permissionless_bindings_instance_manager = require("../../bindings/instance-manager.js");
+const require_permissionless_utils_governance_batch = require("../../utils/governance/batch.js");
+const require_permissionless_utils_price_update_get_updatable_feeds = require("../../utils/price-update/get-updatable-feeds.js");
+const require_permissionless_api_transactions_lp_price_feeds = require("./lp-price-feeds.js");
+//#region src/permissionless/api/transactions/InstanceOwnerTransactions.ts
+const lower = (value) => value.toLowerCase();
+/**
+* The Safe batches an instance owner executes to apply what a curator
+* prepared: adding their private feeds to the PriceFeedStore, renaming feeds,
+* changing staleness periods, forbidding feeds and refreshing LP bounds.
+*
+* Every batch is wrapped with `wrapConfigureLocal`, so the InstanceManager is
+* the only caller the PriceFeedStore ever sees.
+*
+* Backend-free: a batch is built off the chain it will be executed on, and
+* the store it reads is the one {@link PermissionlessOracles} already
+* fetched. Nothing is sent either — a curator never executes these
+* themselves. They prepare a batch and hand it to the instance owner, who
+* reviews and executes it from their Safe.
+*
+* ```ts
+* const txs = await permissionless.transactions.addFeeds({
+*   chainId: 1,
+*   owner: curator,
+* });
+* ```
+**/
+var InstanceOwnerTransactions = class {
+	#chains;
+	#oracles;
+	constructor(chains, oracles) {
+		this.#chains = chains;
+		this.#oracles = oracles;
+	}
+	/**
+	* The batch that adds the owner's private feeds to the store and allows
+	* them on the assets they were connected to. Only feeds that actually carry
+	* a connection are added: a feed nobody priced would land in the store
+	* doing nothing.
+	**/
+	async addFeeds({ chainId, owner }) {
+		const [batch, store] = await Promise.all([this.#batchContext(chainId), this.#oracles.store({ chainId })]);
+		const pairs = store.assets.flatMap((asset) => asset.priceFeeds.filter((entry) => entry.status === "private").map((entry) => ({
+			asset: asset.address,
+			priceFeed: entry.pricefeed.address
+		})));
+		const connected = new Set(pairs.map((pair) => lower(pair.priceFeed)));
+		const feedsToAdd = store.priceFeeds.filter((feed) => !feed.isInStore && connected.has(lower(feed.address)));
+		const txs = [...feedsToAdd.map((feed) => batch.store.addPriceFeedTx(feed.address, feed.stalenessPeriod, feed.name)), ...pairs.map((pair) => batch.store.allowPriceFeedTx(pair.asset, pair.priceFeed))];
+		return this.#envelope({
+			batch,
+			author: owner,
+			name: "pfs-updates",
+			txs,
+			touchedFeeds: feedsToAdd.map((feed) => feed.address)
+		});
+	}
+	/**
+	* The batch that renames feeds already in the store. A name is part of what
+	* the store holds, so changing one is a remove and a fresh add, followed by
+	* allowing the feed again on every asset that priced it.
+	**/
+	async changeNames({ chainId, owner, names }) {
+		const [batch, store] = await Promise.all([this.#batchContext(chainId), this.#oracles.store({ chainId })]);
+		const feedToAssets = await this.#feedToAssets(batch.store);
+		const inStore = new Map(store.priceFeeds.filter((feed) => feed.isInStore).map((feed) => [lower(feed.address), feed]));
+		const txs = [];
+		for (const [address, name] of Object.entries(names)) {
+			const feed = inStore.get(lower(address));
+			if (!feed) throw new require_permissionless_api_errors.PriceFeedNotInStoreError(address, chainId);
+			txs.push(batch.store.removePriceFeedTx(feed.address), batch.store.addPriceFeedTx(feed.address, feed.stalenessPeriod, name));
+			for (const asset of feedToAssets.get(lower(address)) ?? []) txs.push(batch.store.allowPriceFeedTx(asset, feed.address));
+		}
+		return this.#envelope({
+			batch,
+			author: owner,
+			name: "pricefeed-name-changes",
+			txs,
+			touchedFeeds: Object.keys(names)
+		});
+	}
+	/**
+	* The batch that changes how long each feed's price stays valid.
+	**/
+	async changeStalenessPeriods({ chainId, owner, periods }) {
+		const batch = await this.#batchContext(chainId);
+		const entries = Object.entries(periods);
+		const txs = entries.map(([address, period]) => batch.store.setStalenessPeriodTx(address, period));
+		return this.#envelope({
+			batch,
+			author: owner,
+			name: "pricefeed-staleness-changes",
+			txs,
+			touchedFeeds: entries.map(([address]) => address)
+		});
+	}
+	/**
+	* The batch that forbids feeds on the assets they were allowed for.
+	**/
+	async forbidFeeds({ chainId, owner, tokens }) {
+		const batch = await this.#batchContext(chainId);
+		const txs = Object.entries(tokens).flatMap(([token, feeds]) => feeds.map((feed) => require_onchain_utils_createRawTx.createRawTx(batch.store.address, {
+			abi: batch.store.abi,
+			functionName: "forbidPriceFeed",
+			args: [token, feed]
+		})));
+		return this.#envelope({
+			batch,
+			author: owner,
+			name: "forbid-feeds",
+			txs,
+			touchedFeeds: []
+		});
+	}
+	/**
+	* The batch that pulls every drifted LP feed's lower bound back under its
+	* exchange rate. Unlike the others this takes no input: the whole store is
+	* scanned and only the feeds that drifted produce a transaction, so this
+	* one is slow.
+	**/
+	async updateBounds({ chainId, owner }) {
+		const batch = await this.#batchContext(chainId);
+		const pfCompressor = await this.#priceFeedCompressor(batch.client);
+		const known = await batch.store.getKnownPriceFeeds();
+		const feeds = await require_permissionless_api_transactions_lp_price_feeds.getFeedsToUpdate(batch.client, pfCompressor, known);
+		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) => ({
+			target: tx.to,
+			callData: tx.callData
+		})))];
+		return this.#envelope({
+			batch,
+			author: owner,
+			name: "update-bounds",
+			txs,
+			touchedFeeds: []
+		});
+	}
+	/**
+	* The contracts every batch of one chain is built against.
+	*
+	* Nothing here checks that the instance is activated: that is a backend
+	* read, and an instance without a deployed InstanceManager fails on the
+	* owner lookup below anyway.
+	**/
+	async #batchContext(chainId) {
+		const client = this.#chains.client(chainId);
+		const addressProvider = new require_permissionless_bindings_address_provider.AddressProviderContract("0xF7f0a609BfAb9a0A98786951ef10e5FE26cC1E38", client);
+		const instanceManager = new require_permissionless_bindings_instance_manager.InstanceManagerContract(await addressProvider.getAddressOrRevert(require_permissionless_utils_literals.INSTANCE_MANAGER), new require_onchain_base_ChainContractsRegister.ChainContractsRegister(client));
+		return {
+			chainId,
+			client,
+			store: new require_permissionless_bindings_price_feed_store.PriceFeedStoreContract("0x74A868AC479EE145029bB80827BB77F7B7c441cB", client),
+			instanceManager,
+			instanceOwner: await instanceManager.getOwner()
+		};
+	}
+	/** The common shape every batch is returned in. */
+	async #envelope(args) {
+		const { batch, author, name, txs, touchedFeeds } = args;
+		const { chainId, client, instanceManager, instanceOwner } = batch;
+		const wrapped = txs.map((tx) => instanceManager.wrapConfigureLocal(tx));
+		const safeBatch = require_permissionless_utils_governance_batch.getSafeBatch({
+			chainId,
+			safeAddress: instanceOwner,
+			name,
+			txs: wrapped.map((tx) => require_permissionless_utils_governance_batch.convertRawTxToSafeMultisigTx(tx))
+		});
+		const [block, updatableFeeds] = await Promise.all([client.getBlock(), this.#updatableFeeds(touchedFeeds, client)]);
+		return {
+			chainId,
+			author,
+			instanceManager: instanceManager.address,
+			batches: [safeBatch.transactions],
+			createdAtBlock: Number(block.number),
+			updatableFeeds: [updatableFeeds]
+		};
+	}
+	/** Which of the touched feeds the executor has to push a price update for. */
+	async #updatableFeeds(touchedFeeds, client) {
+		if (touchedFeeds.length === 0) return [];
+		const sdk = await this.#sdk(client);
+		return (await require_permissionless_utils_price_update_get_updatable_feeds.getUpdatablePriceFeeds({
+			sdk,
+			client,
+			pfCompressor: this.#compressorFrom(sdk),
+			priceFeeds: touchedFeeds
+		})).map((contract) => contract.address);
+	}
+	async #priceFeedCompressor(client) {
+		return this.#compressorFrom(await this.#sdk(client));
+	}
+	#compressorFrom(sdk) {
+		const [compressor] = sdk.addressProvider.mustGetLatest(require_onchain_constants_address_provider.AP_PRICE_FEED_COMPRESSOR, require_onchain_constants_versions.VERSION_RANGE_310);
+		return compressor;
+	}
+	async #sdk(client) {
+		const chainId = client.chain?.id ?? await client.getChainId();
+		const sdk = new require_onchain_OnchainSDK.OnchainSDK(require_onchain_chain_chains.getNetworkType(chainId), { client });
+		await sdk.attach({ marketConfigurators: [] });
+		return sdk;
+	}
+	/** Every asset each feed is currently allowed on, keyed by lowercase feed. */
+	async #feedToAssets(store) {
+		const byFeed = /* @__PURE__ */ new Map();
+		for (const { token, priceFeeds } of await store.getTokenPriceFeedsMap()) for (const feed of priceFeeds) {
+			const key = lower(feed);
+			const assets = byFeed.get(key);
+			if (assets) assets.push(token.toLowerCase());
+			else byFeed.set(key, [token.toLowerCase()]);
+		}
+		return byFeed;
+	}
+};
+//#endregion
+exports.InstanceOwnerTransactions = InstanceOwnerTransactions;

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

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

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

@@ -0,0 +1,86 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_utils_createRawTx = require("../../../onchain/utils/createRawTx.js");
+const require_onchain_utils_viem_simulateMulticall = require("../../../onchain/utils/viem/simulateMulticall.js");
+const require_abi_compressors_priceFeedCompressor = require("../../../abi/compressors/priceFeedCompressor.js");
+require("../../../onchain/index.js");
+let viem = require("viem");
+//#region src/permissionless/api/transactions/lp-price-feeds.ts
+const LOWER_BOUND_FACTOR = 999n;
+const ilpPriceFeedAbi = (0, viem.parseAbi)([
+	"function contractType() external view returns (bytes32)",
+	"function setLimiter(uint256 newLimiter) external",
+	"function getLPExchangeRate() public view returns (uint256 exchangeRate)",
+	"function lowerBound() external view returns (uint256)",
+	"function upperBound() external view returns (uint256)"
+]);
+function currentLowerBound(client, address) {
+	return client.readContract({
+		abi: ilpPriceFeedAbi,
+		address,
+		functionName: "lowerBound"
+	});
+}
+function getValue(client, address) {
+	return client.readContract({
+		abi: ilpPriceFeedAbi,
+		address,
+		functionName: "getLPExchangeRate"
+	});
+}
+function toLowerBound(value) {
+	return value * LOWER_BOUND_FACTOR / 1000n;
+}
+/**
+* Moves an LP feed's lower bound back under its current exchange rate, when
+* the rate has outgrown the bound or drifted far enough from it to be worth a
+* transaction. Returns nothing when the bound still fits.
+**/
+async function updateBounds(client, address) {
+	const value = await getValue(client, address);
+	const currentLowerBoundValue = await currentLowerBound(client, address);
+	const lowerBound = toLowerBound(value);
+	const deviationFromValue = Math.floor(Number(10000n * (value - currentLowerBoundValue) / currentLowerBoundValue)) / 1e4;
+	const deviationFromBound = Math.floor(Number(10000n * (lowerBound - currentLowerBoundValue) / currentLowerBoundValue)) / 1e4;
+	const txs = [];
+	if (deviationFromValue < 0 || Math.abs(deviationFromBound) > .005) txs.push(require_onchain_utils_createRawTx.createRawTx(address, {
+		abi: ilpPriceFeedAbi,
+		functionName: "setLimiter",
+		args: [lowerBound]
+	}, `[${address}].setLimiter(${lowerBound}); // deviationFromValue: ${(100 * deviationFromValue).toFixed(2)}%`));
+	return txs;
+}
+/**
+* Of the whole feed tree behind `feeds`, the ones that are LP feeds: the
+* probe keeps whatever answers `getLPExchangeRate`.
+**/
+async function getFeedsToUpdate(client, pfCompressor, feeds) {
+	const updateableFeeds = /* @__PURE__ */ new Set();
+	const { data } = await client.call({
+		to: pfCompressor,
+		data: (0, viem.encodeFunctionData)({
+			abi: require_abi_compressors_priceFeedCompressor.priceFeedCompressorAbi,
+			functionName: "loadPriceFeedTree",
+			args: [feeds]
+		}),
+		gas: 200000000n
+	});
+	const trees = (0, viem.decodeFunctionResult)({
+		abi: require_abi_compressors_priceFeedCompressor.priceFeedCompressorAbi,
+		functionName: "loadPriceFeedTree",
+		data: data ?? "0x"
+	});
+	for (const tree of trees) updateableFeeds.add(tree.baseParams.addr.toLowerCase());
+	const candidates = Array.from(updateableFeeds);
+	const { results } = await require_onchain_utils_viem_simulateMulticall.simulateMulticall(client, {
+		contracts: candidates.map((feed) => ({
+			address: feed,
+			abi: ilpPriceFeedAbi,
+			functionName: "getLPExchangeRate"
+		})),
+		allowFailure: true
+	});
+	return candidates.filter((_, index) => results[index]?.status === "success");
+}
+//#endregion
+exports.getFeedsToUpdate = getFeedsToUpdate;
+exports.updateBounds = updateBounds;

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

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

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

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

package/dist/cjs/permissionless/bindings/cross-chain-multisig.js

@@ -4,9 +4,9 @@ const require_onchain_base_BaseContract = require("../../onchain/base/BaseContra
 require("../../onchain/index.js");
 const require_permissionless_utils_literals = require("../utils/literals.js");
 const require_permissionless_utils_signature = require("../utils/signature.js");
-const require_abi_310_crossChainMultisig = require("../../abi/310/crossChainMultisig.js");
 require("../deployment/addresses.js");
 const require_permissionless_bindings_instance_manager = require("./instance-manager.js");
+const require_abi_310_crossChainMultisig = require("../../abi/310/crossChainMultisig.js");
 const require_permissionless_bindings_market_configurator_factory = require("./market-configurator-factory.js");
 let viem = require("viem");
 //#region src/permissionless/bindings/cross-chain-multisig.ts

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

@@ -1,11 +1,11 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_permissionless_bindings_address_provider = require("./address-provider.js");
 const require_permissionless_bindings_bytecode_repository = require("./bytecode-repository.js");
+const require_permissionless_bindings_pricefeeds_index = require("./pricefeeds/index.js");
+const require_permissionless_bindings_price_feed_store = require("./price-feed-store.js");
+const require_permissionless_bindings_address_provider = require("./address-provider.js");
 const require_permissionless_bindings_compressors_token_compressor = require("./compressors/token-compressor.js");
 const require_permissionless_bindings_compressors_withdrawal_compressor = require("./compressors/withdrawal-compressor.js");
 require("./compressors/index.js");
-const require_permissionless_bindings_pricefeeds_index = require("./pricefeeds/index.js");
-const require_permissionless_bindings_price_feed_store = require("./price-feed-store.js");
 const require_permissionless_bindings_router_routing_manager = require("./router/routing-manager.js");
 require("./router/index.js");
 const require_permissionless_bindings_treasury_splitter = require("./treasury-splitter.js");

package/dist/cjs/permissionless/bindings/instance-manager.js

@@ -4,8 +4,7 @@ const require_onchain_base_BaseContract = require("../../onchain/base/BaseContra
 const require_abi_router_gearboxRouter = require("../../abi/router/gearboxRouter.js");
 require("../../onchain/index.js");
 const require_permissionless_bindings_bytecode_repository = require("./bytecode-repository.js");
-const require_permissionless_bindings_compressors_withdrawal_compressor = require("./compressors/withdrawal-compressor.js");
-require("./compressors/index.js");
+const require_permissionless_bindings_price_feed_store = require("./price-feed-store.js");
 require("../deployment/addresses.js");
 const require_abi_310_instanceManager = require("../../abi/310/instanceManager.js");
 const require_abi_router_camelotV3Worker = require("../../abi/router/camelotV3Worker.js");
@@ -14,7 +13,8 @@ const require_abi_router_mellow4626Worker = require("../../abi/router/mellow4626
 const require_abi_router_pendleRouterWorker = require("../../abi/router/pendleRouterWorker.js");
 const require_abi_router_uniswapV3Worker = require("../../abi/router/uniswapV3Worker.js");
 const require_abi_router_uniswapV4Worker = require("../../abi/router/uniswapV4Worker.js");
-const require_permissionless_bindings_price_feed_store = require("./price-feed-store.js");
+const require_permissionless_bindings_compressors_withdrawal_compressor = require("./compressors/withdrawal-compressor.js");
+require("./compressors/index.js");
 const require_permissionless_bindings_router_routing_manager = require("./router/routing-manager.js");
 require("./router/index.js");
 const require_permissionless_bindings_treasury_splitter = require("./treasury-splitter.js");