@gearbox-protocol/sdk 17.10.1 → 17.12.0

package/dist/esm/permissionless/api/deploy/effective-staleness.js

@@ -0,0 +1,46 @@
+import { parseAbi } from "viem";
+//#region src/permissionless/api/deploy/effective-staleness.ts
+const abi = parseAbi(["function stalenessPeriod() view returns (uint32)", "function latestRoundData() view returns (uint80,int256,uint256,uint256,uint80)"]);
+/**
+* Bound for a leg that recomputes its answer on every read and stamps it with
+* the current block (exchange-rate adapters, NAV feeds, Pendle oracles,
+* constant feeds). One second is the tightest value that still satisfies
+* `block.timestamp < updatedAt + stalenessPeriod`.
+**/
+const CURRENT_BLOCK_STALENESS = 1;
+/**
+* The staleness a deployed price feed enforces on the price it reports.
+*
+* This is deliberately not the value the feed is registered with in the
+* PriceFeedStore — derived feeds must be registered with 0 there, and the store
+* rejects anything else for them with `IncorrectParameterException()`. It is
+* the value a parent feed needs when it re-checks the leg's `updatedAt`
+* itself.
+*
+* Returns `null` when it cannot be determined. Callers must surface that
+* rather than substitute a bound: a leg constructed with a staleness its
+* underlying oracle can never satisfy produces a feed that reverts on every
+* read and can never be added to the store.
+**/
+async function deriveEffectiveStalenessPeriod(client, address) {
+	try {
+		const own = await client.readContract({
+			address,
+			abi,
+			functionName: "stalenessPeriod"
+		});
+		if (Number(own) > 0) return Number(own);
+	} catch {}
+	try {
+		const [block, round] = await Promise.all([client.getBlock(), client.readContract({
+			address,
+			abi,
+			functionName: "latestRoundData"
+		})]);
+		const updatedAt = Number(round[3]);
+		if (updatedAt > 0 && updatedAt >= Number(block.timestamp)) return CURRENT_BLOCK_STALENESS;
+	} catch {}
+	return null;
+}
+//#endregion
+export { deriveEffectiveStalenessPeriod };

package/dist/esm/permissionless/api/deploy/index.js

@@ -0,0 +1,4 @@
+import { deriveEffectiveStalenessPeriod } from "./effective-staleness.js";
+import { DEFAULT_DEPLOY_SALT, PermissionlessDeploy, priceFeedSalt } from "./PermissionlessDeploy.js";
+import "./types.js";
+export { DEFAULT_DEPLOY_SALT, PermissionlessDeploy, deriveEffectiveStalenessPeriod, priceFeedSalt };

package/dist/esm/permissionless/api/deploy/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/permissionless/api/errors.js

@@ -0,0 +1,77 @@
+import { BaseError } from "viem";
+//#region src/permissionless/api/errors.ts
+/**
+* Thrown when anything is read off {@link ChainsNamespace} before
+* {@link GearboxPermissionless.attach} has completed.
+*
+* The chain list is the backend's answer, so there is nothing to report until
+* it arrives. Answering with an empty list instead would be indistinguishable
+* from a backend that serves no chains at all.
+**/
+var PermissionlessNotAttachedError = class extends BaseError {
+	name = "PermissionlessNotAttachedError";
+	constructor() {
+		super("The client has not attached yet.", { metaMessages: ["Await `attach()` before reading chains off the client."] });
+	}
+};
+/**
+* Thrown when a call has to read a chain the client holds no viem client for.
+*
+* Either the backend does not serve the chain, or it serves one this SDK
+* carries no definition for: endpoints come from the chain definition, since
+* the backend's own urls carry provider keys and are never handed out.
+**/
+var PermissionlessChainUnreachableError = class extends BaseError {
+	name = "PermissionlessChainUnreachableError";
+	/** Chain that was asked for. */
+	chainId;
+	constructor(chainId) {
+		super(`Chain ${chainId} cannot be read directly.`, { metaMessages: ["The backend either does not serve it, or serves a chain this SDK has no definition for."] });
+		this.chainId = chainId;
+	}
+};
+/**
+* Thrown when a rename names a feed the PriceFeedStore does not carry. A name
+* is part of what the store holds, so there is nothing to change on a feed
+* that never reached it.
+**/
+var PriceFeedNotInStoreError = class extends BaseError {
+	name = "PriceFeedNotInStoreError";
+	/** Feed that was named. */
+	priceFeed;
+	chainId;
+	constructor(priceFeed, chainId) {
+		super(`Price feed ${priceFeed} is not in the PriceFeedStore of chain ${chainId}.`, { metaMessages: ["Only a feed the store already carries can be renamed; add it first."] });
+		this.priceFeed = priceFeed;
+		this.chainId = chainId;
+	}
+};
+/**
+* Thrown when a composite feed names a leg whose own staleness bound cannot be
+* read off the chain.
+*
+* Deploying with a placeholder is not an option: a composite whose check can
+* never pass reverts on every read, and the store will not take it. The bound
+* has to be set on the leg first.
+**/
+var PriceFeedStalenessUnknownError = class extends BaseError {
+	name = "PriceFeedStalenessUnknownError";
+	/** Leg whose bound could not be determined. */
+	priceFeed;
+	constructor(priceFeed) {
+		super(`Cannot determine the staleness period of price feed ${priceFeed}.`, { metaMessages: ["Deploying with a placeholder would make this composite permanently stale.", "Set the staleness period on the underlying feed first."] });
+		this.priceFeed = priceFeed;
+	}
+};
+/**
+* Thrown when a price feed deploy names neither a salt nor the name one would
+* be derived from, leaving CREATE2 nothing to distinguish it by.
+**/
+var PriceFeedSaltMissingError = class extends BaseError {
+	name = "PriceFeedSaltMissingError";
+	constructor() {
+		super("A price feed deploy needs either `salt` or `name`.", { metaMessages: ["`name` is hashed into the salt, which is what keeps two feeds of the", "same type and arguments from landing on the same address."] });
+	}
+};
+//#endregion
+export { PermissionlessChainUnreachableError, PermissionlessNotAttachedError, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError };

package/dist/esm/permissionless/api/index.js

@@ -0,0 +1,13 @@
+import { PermissionlessChainUnreachableError, PermissionlessNotAttachedError, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError } from "./errors.js";
+import { ChainsNamespace } from "./chains/ChainsNamespace.js";
+import "./chains/index.js";
+import { deriveEffectiveStalenessPeriod } from "./deploy/effective-staleness.js";
+import { DEFAULT_DEPLOY_SALT, PermissionlessDeploy, priceFeedSalt } from "./deploy/PermissionlessDeploy.js";
+import "./deploy/index.js";
+import { GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, PermissionlessOracles } from "./oracles/PermissionlessOracles.js";
+import { InstanceOwnerTransactions } from "./transactions/InstanceOwnerTransactions.js";
+import { GearboxPermissionless } from "./GearboxPermissionless.js";
+import "./oracles/index.js";
+import "./transactions/index.js";
+import "./types.js";
+export { ChainsNamespace, DEFAULT_DEPLOY_SALT, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GearboxPermissionless, InstanceOwnerTransactions, PermissionlessChainUnreachableError, PermissionlessDeploy, PermissionlessNotAttachedError, PermissionlessOracles, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError, deriveEffectiveStalenessPeriod, priceFeedSalt };

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

@@ -0,0 +1,81 @@
+import { AbstractOffchainNamespace } from "../../../offchain/AbstractOffchainNamespace.js";
+import { getPrices } from "../../utils/price-update/get-prices.js";
+import { priceFeedStoreSchema, pricesSchema } from "./schemas.js";
+//#region src/permissionless/api/oracles/PermissionlessOracles.ts
+const GET_PRICES_GAS_LIMIT_BY_CHAIN_ID = { 143: 100000000n };
+const GET_PRICES_CHUNK_SIZE = 200;
+/**
+* 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 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: 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: 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 getPrices({
+			client: this.#chains.client(chainId),
+			priceFeeds,
+			chunkSize: 200,
+			gasLimit: GET_PRICES_GAS_LIMIT_BY_CHAIN_ID[chainId]
+		});
+	}
+};
+//#endregion
+export { GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, PermissionlessOracles };

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

@@ -0,0 +1,3 @@
+import { GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, PermissionlessOracles } from "./PermissionlessOracles.js";
+import "./types.js";
+export { GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, PermissionlessOracles };

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

@@ -0,0 +1,47 @@
+import { addressRecord, addressSchema } from "../schemas.js";
+import { z } from "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 = z.looseObject({
+	address: addressSchema,
+	contractType: z.string(),
+	version: z.number(),
+	deployedBy: addressSchema,
+	stalenessPeriod: z.number(),
+	name: z.string()
+});
+/** {@link PermissionlessAsset} */
+const assetSchema = z.looseObject({
+	address: addressSchema,
+	symbol: z.string(),
+	name: z.string(),
+	decimals: z.number(),
+	owner: addressSchema,
+	priceFeeds: z.array(priceFeedSchema)
+});
+/** {@link PermissionlessPriceFeedStore} */
+const priceFeedStoreSchema = z.looseObject({
+	chainId: z.number(),
+	name: z.string(),
+	isPublic: z.boolean(),
+	isActivated: z.boolean(),
+	explorerUrl: z.string(),
+	assets: z.array(assetSchema),
+	priceFeeds: z.array(priceFeedSchema)
+});
+/** {@link PermissionlessPrices} */
+const pricesSchema = z.looseObject({
+	prices: addressRecord(z.string().nullable()),
+	marketCaps: addressRecord(addressRecord(z.string().nullable())),
+	time: z.number()
+});
+//#endregion
+export { assetSchema, priceFeedSchema, priceFeedStoreSchema, pricesSchema };

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,25 @@
+import { isAddress, isHex } from "viem";
+import { z } from "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 = z.custom((value) => typeof value === "string" && isAddress(value, { strict: false }), { message: "invalid address" });
+/** A `0x`-prefixed hex string, as viem's `Hex`. */
+const hexSchema = z.custom((value) => typeof value === "string" && 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 = z.string().refine((v) => isAddress(v, { strict: false }), { message: "invalid address" });
+	return z.record(key, value);
+}
+//#endregion
+export { addressRecord, addressSchema, hexSchema };

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

@@ -0,0 +1,233 @@
+import { createRawTx } from "../../../onchain/utils/createRawTx.js";
+import { getNetworkType } from "../../../onchain/chain/chains.js";
+import { AP_PRICE_FEED_COMPRESSOR } from "../../../onchain/constants/address-provider.js";
+import { VERSION_RANGE_310 } from "../../../onchain/constants/versions.js";
+import { ChainContractsRegister } from "../../../onchain/base/ChainContractsRegister.js";
+import { OnchainSDK } from "../../../onchain/OnchainSDK.js";
+import "../../../onchain/index.js";
+import { PriceFeedNotInStoreError } from "../errors.js";
+import { INSTANCE_MANAGER } from "../../utils/literals.js";
+import { PriceFeedStoreContract } from "../../bindings/price-feed-store.js";
+import "../../deployment/addresses.js";
+import { AddressProviderContract } from "../../bindings/address-provider.js";
+import { InstanceManagerContract } from "../../bindings/instance-manager.js";
+import { convertRawTxToSafeMultisigTx, getSafeBatch } from "../../utils/governance/batch.js";
+import { getUpdatablePriceFeeds } from "../../utils/price-update/get-updatable-feeds.js";
+import { getFeedsToUpdate, updateBounds } from "./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,
+*   feeds: [feed],
+*   pairs: [{ asset, priceFeed: feed.address }],
+* });
+* ```
+**/
+var InstanceOwnerTransactions = class {
+	#chains;
+	#oracles;
+	constructor(chains, oracles) {
+		this.#chains = chains;
+		this.#oracles = oracles;
+	}
+	/**
+	* The batch that adds the named feeds to the store and allows the named
+	* edges on it.
+	*
+	* Both lists come from the caller. Which feeds are private, and which asset
+	* each is meant to price, is held wherever the curator prepared them — the
+	* backend indexes the store, so a feed that has not reached it yet is not
+	* something this client can discover.
+	*
+	* Only feeds that actually carry an edge are added: a feed nobody priced
+	* would land in the store doing nothing.
+	**/
+	async addFeeds({ chainId, owner, feeds, pairs }) {
+		const batch = await this.#batchContext(chainId);
+		const connected = new Set(pairs.map((pair) => lower(pair.priceFeed)));
+		const feedsToAdd = feeds.filter((feed) => 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.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 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) => 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 getFeedsToUpdate(batch.client, pfCompressor, known);
+		const configureTxs = [];
+		for (const feed of feeds) configureTxs.push(...await 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 AddressProviderContract("0xF7f0a609BfAb9a0A98786951ef10e5FE26cC1E38", client);
+		const instanceManager = new InstanceManagerContract(await addressProvider.getAddressOrRevert(INSTANCE_MANAGER), new ChainContractsRegister(client));
+		return {
+			chainId,
+			client,
+			store: new 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 = getSafeBatch({
+			chainId,
+			safeAddress: instanceOwner,
+			name,
+			txs: wrapped.map((tx) => 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 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(AP_PRICE_FEED_COMPRESSOR, VERSION_RANGE_310);
+		return compressor;
+	}
+	async #sdk(client) {
+		const chainId = client.chain?.id ?? await client.getChainId();
+		const sdk = new OnchainSDK(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
+export { InstanceOwnerTransactions };

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

@@ -0,0 +1,3 @@
+import { InstanceOwnerTransactions } from "./InstanceOwnerTransactions.js";
+import "./types.js";
+export { InstanceOwnerTransactions };

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

@@ -0,0 +1,84 @@
+import { createRawTx } from "../../../onchain/utils/createRawTx.js";
+import { simulateMulticall } from "../../../onchain/utils/viem/simulateMulticall.js";
+import { priceFeedCompressorAbi } from "../../../abi/compressors/priceFeedCompressor.js";
+import "../../../onchain/index.js";
+import { decodeFunctionResult, encodeFunctionData, parseAbi } from "viem";
+//#region src/permissionless/api/transactions/lp-price-feeds.ts
+const LOWER_BOUND_FACTOR = 999n;
+const ilpPriceFeedAbi = 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(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: encodeFunctionData({
+			abi: priceFeedCompressorAbi,
+			functionName: "loadPriceFeedTree",
+			args: [feeds]
+		}),
+		gas: 200000000n
+	});
+	const trees = decodeFunctionResult({
+		abi: 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 simulateMulticall(client, {
+		contracts: candidates.map((feed) => ({
+			address: feed,
+			abi: ilpPriceFeedAbi,
+			functionName: "getLPExchangeRate"
+		})),
+		allowFailure: true
+	});
+	return candidates.filter((_, index) => results[index]?.status === "success");
+}
+//#endregion
+export { getFeedsToUpdate, updateBounds };

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -3,9 +3,9 @@ import { BaseContract } from "../../onchain/base/BaseContract.js";
 import "../../onchain/index.js";
 import { CROSS_CHAIN_MULTISIG } from "../utils/literals.js";
 import { normalizeSignature } from "../utils/signature.js";
-import { crossChainMultisigAbi } from "../../abi/310/crossChainMultisig.js";
 import "../deployment/addresses.js";
 import { InstanceManagerContract } from "./instance-manager.js";
+import { crossChainMultisigAbi } from "../../abi/310/crossChainMultisig.js";
 import { MarketConfiguratorFactoryContract } from "./market-configurator-factory.js";
 import { parseAbi, parseEventLogs, recoverTypedDataAddress, zeroAddress } from "viem";
 //#region src/permissionless/bindings/cross-chain-multisig.ts

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

@@ -1,10 +1,10 @@
-import { AddressProviderContract } from "./address-provider.js";
 import { BytecodeRepositoryContract } from "./bytecode-repository.js";
+import { priceFeedSetupParams } from "./pricefeeds/index.js";
+import { PriceFeedStoreContract } from "./price-feed-store.js";
+import { AddressProviderContract } from "./address-provider.js";
 import { TokenCompressorContract } from "./compressors/token-compressor.js";
 import { WithdrawalCompressorContract } from "./compressors/withdrawal-compressor.js";
 import "./compressors/index.js";
-import { priceFeedSetupParams } from "./pricefeeds/index.js";
-import { PriceFeedStoreContract } from "./price-feed-store.js";
 import { RoutingManagerContract } from "./router/routing-manager.js";
 import "./router/index.js";
 import { TreasurySplitterContract } from "./treasury-splitter.js";