@gearbox-protocol/sdk 17.10.1 → 17.12.0

package/dist/cjs/permissionless/index.js

@@ -1,16 +1,28 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_permissionless_bindings_address_provider = require("./bindings/address-provider.js");
+const require_permissionless_api_errors = require("./api/errors.js");
+const require_permissionless_api_chains_ChainsNamespace = require("./api/chains/ChainsNamespace.js");
+const require_permissionless_api_deploy_effective_staleness = require("./api/deploy/effective-staleness.js");
 const require_permissionless_utils_literals = require("./utils/literals.js");
 const require_permissionless_utils_signature = require("./utils/signature.js");
 const require_permissionless_bindings_bytecode_repository = require("./bindings/bytecode-repository.js");
-const require_permissionless_bindings_compressors_token_compressor = require("./bindings/compressors/token-compressor.js");
-const require_permissionless_bindings_compressors_withdrawal_compressor = require("./bindings/compressors/withdrawal-compressor.js");
-const require_permissionless_deployment_addresses = require("./deployment/addresses.js");
 const require_permissionless_bindings_pricefeeds_index = require("./bindings/pricefeeds/index.js");
 const require_permissionless_bindings_price_feed_store = require("./bindings/price-feed-store.js");
+const require_permissionless_deployment_addresses = require("./deployment/addresses.js");
+const require_permissionless_utils_abi_encoder = require("./utils/abi-encoder.js");
+const require_permissionless_api_deploy_PermissionlessDeploy = require("./api/deploy/PermissionlessDeploy.js");
+const require_permissionless_utils_price_update_get_prices = require("./utils/price-update/get-prices.js");
+const require_permissionless_api_oracles_PermissionlessOracles = require("./api/oracles/PermissionlessOracles.js");
+const require_permissionless_bindings_address_provider = require("./bindings/address-provider.js");
+const require_permissionless_bindings_compressors_token_compressor = require("./bindings/compressors/token-compressor.js");
+const require_permissionless_bindings_compressors_withdrawal_compressor = require("./bindings/compressors/withdrawal-compressor.js");
 const require_permissionless_bindings_router_routing_manager = require("./bindings/router/routing-manager.js");
 const require_permissionless_bindings_treasury_splitter = require("./bindings/treasury-splitter.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_InstanceOwnerTransactions = require("./api/transactions/InstanceOwnerTransactions.js");
+const require_permissionless_api_GearboxPermissionless = require("./api/GearboxPermissionless.js");
+require("./api/index.js");
 const require_permissionless_bindings_market_configurator_factory = require("./bindings/market-configurator-factory.js");
 const require_permissionless_bindings_cross_chain_multisig = require("./bindings/cross-chain-multisig.js");
 const require_permissionless_utils_create2 = require("./utils/create2.js");
@@ -25,13 +37,9 @@ const require_permissionless_chains_archive_transport = require("./chains/archiv
 const require_permissionless_chains_chunked_log_transport = require("./chains/chunked-log-transport.js");
 require("./core/index.js");
 const require_permissionless_deployment_mainnet = require("./deployment/mainnet.js");
-const require_permissionless_utils_abi_encoder = require("./utils/abi-encoder.js");
 const require_permissionless_utils_block_utils = require("./utils/block-utils.js");
-const require_permissionless_utils_governance_batch = require("./utils/governance/batch.js");
 const require_permissionless_utils_governance_timelock_txs = require("./utils/governance/timelock-txs.js");
 const require_permissionless_utils_price_update_get_price_update_tx = require("./utils/price-update/get-price-update-tx.js");
-const require_permissionless_utils_price_update_get_prices = require("./utils/price-update/get-prices.js");
-const require_permissionless_utils_price_update_get_updatable_feeds = require("./utils/price-update/get-updatable-feeds.js");
 require("./utils/index.js");
 exports.AccessMode = require_permissionless_bindings_types.AccessMode;
 exports.AddressProviderContract = require_permissionless_bindings_address_provider.AddressProviderContract;
@@ -41,10 +49,16 @@ exports.BYTECODE_REPOSITORY = require_permissionless_utils_literals.BYTECODE_REP
 exports.BytecodeRepositoryContract = require_permissionless_bindings_bytecode_repository.BytecodeRepositoryContract;
 exports.CROSS_CHAIN_GOVERNANCE = require_permissionless_utils_literals.CROSS_CHAIN_GOVERNANCE;
 exports.CROSS_CHAIN_MULTISIG = require_permissionless_utils_literals.CROSS_CHAIN_MULTISIG;
+exports.ChainsNamespace = require_permissionless_api_chains_ChainsNamespace.ChainsNamespace;
 exports.CrossChainMultisigContract = require_permissionless_bindings_cross_chain_multisig.CrossChainMultisigContract;
+exports.DEFAULT_DEPLOY_SALT = require_permissionless_api_deploy_PermissionlessDeploy.DEFAULT_DEPLOY_SALT;
+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.GearboxPermissionless = require_permissionless_api_GearboxPermissionless.GearboxPermissionless;
 exports.GovernorContract = require_permissionless_bindings_governance_governor.GovernorContract;
 exports.INSTANCE_MANAGER = require_permissionless_utils_literals.INSTANCE_MANAGER;
 exports.InstanceManagerContract = require_permissionless_bindings_instance_manager.InstanceManagerContract;
+exports.InstanceOwnerTransactions = require_permissionless_api_transactions_InstanceOwnerTransactions.InstanceOwnerTransactions;
 exports.MAINNET_CCM_CONSTRUCTOR_PARAMS = require_permissionless_deployment_mainnet.MAINNET_CCM_CONSTRUCTOR_PARAMS;
 exports.MAINNET_DEPLOYMENT_BLOCK = require_permissionless_deployment_mainnet.MAINNET_DEPLOYMENT_BLOCK;
 exports.MAINNET_DEPLOYMENT_CCM_SALT = require_permissionless_deployment_mainnet.MAINNET_DEPLOYMENT_CCM_SALT;
@@ -54,6 +68,13 @@ exports.MarketConfiguratorContract = require_permissionless_bindings_market_conf
 exports.MarketConfiguratorFactoryContract = require_permissionless_bindings_market_configurator_factory.MarketConfiguratorFactoryContract;
 exports.PRICE_FEED_STORE = require_permissionless_utils_literals.PRICE_FEED_STORE;
 exports.PUBLIC_CREATE2_FACTORY = require_permissionless_utils_create2.PUBLIC_CREATE2_FACTORY;
+exports.PermissionlessChainUnreachableError = require_permissionless_api_errors.PermissionlessChainUnreachableError;
+exports.PermissionlessDeploy = require_permissionless_api_deploy_PermissionlessDeploy.PermissionlessDeploy;
+exports.PermissionlessNotAttachedError = require_permissionless_api_errors.PermissionlessNotAttachedError;
+exports.PermissionlessOracles = require_permissionless_api_oracles_PermissionlessOracles.PermissionlessOracles;
+exports.PriceFeedNotInStoreError = require_permissionless_api_errors.PriceFeedNotInStoreError;
+exports.PriceFeedSaltMissingError = require_permissionless_api_errors.PriceFeedSaltMissingError;
+exports.PriceFeedStalenessUnknownError = require_permissionless_api_errors.PriceFeedStalenessUnknownError;
 exports.PriceFeedStoreContract = require_permissionless_bindings_price_feed_store.PriceFeedStoreContract;
 exports.RoutingManagerContract = require_permissionless_bindings_router_routing_manager.RoutingManagerContract;
 exports.TOKEN_COMPRESSOR = require_permissionless_utils_literals.TOKEN_COMPRESSOR;
@@ -72,6 +93,7 @@ exports.createCallData = require_permissionless_core_raw_tx.createCallData;
 exports.createCreate2DeployRawTx = require_permissionless_utils_create2.createCreate2DeployRawTx;
 exports.deepJsonParse = require_permissionless_utils_format.deepJsonParse;
 exports.deployUsingPublicCreate2 = require_permissionless_utils_create2.deployUsingPublicCreate2;
+exports.deriveEffectiveStalenessPeriod = require_permissionless_api_deploy_effective_staleness.deriveEffectiveStalenessPeriod;
 exports.encodeFunctionParams = require_permissionless_utils_abi_encoder.encodeFunctionParams;
 exports.formatBytecodeSize = require_permissionless_utils_format.formatBytecodeSize;
 exports.formatBytecodeVersion = require_permissionless_utils_format.formatBytecodeVersion;
@@ -85,6 +107,7 @@ exports.getSafeBatches = require_permissionless_utils_governance_batch.getSafeBa
 exports.getUpdatablePriceFeeds = require_permissionless_utils_price_update_get_updatable_feeds.getUpdatablePriceFeeds;
 exports.handleSalt = require_permissionless_utils_create2.handleSalt;
 exports.normalizeSignature = require_permissionless_utils_signature.normalizeSignature;
+exports.priceFeedSalt = require_permissionless_api_deploy_PermissionlessDeploy.priceFeedSalt;
 exports.priceFeedSetupParams = require_permissionless_bindings_pricefeeds_index.priceFeedSetupParams;
 exports.shortenHash = require_permissionless_utils_format.shortenHash;
 exports.significantTrunc = require_permissionless_utils_format.significantTrunc;

package/dist/cjs/permissionless/utils/governance/timelock-txs.js

@@ -1,8 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_onchain_utils_createRawTx = require("../../../onchain/utils/createRawTx.js");
 require("../../../onchain/index.js");
-const require_abi_governance_governor = require("../../../abi/governance/governor.js");
 const require_permissionless_utils_governance_batch = require("./batch.js");
+const require_abi_governance_governor = require("../../../abi/governance/governor.js");
 //#region src/permissionless/utils/governance/timelock-txs.ts
 function convertQueueBatchToExecuteTx(queueBatch) {
 	const executionBatch = queueBatch.filter((tx) => tx.contractMethod.name === "queueTransaction").map((tx) => ({

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

@@ -1,16 +1,16 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_permissionless_utils_literals = require("./literals.js");
 const require_permissionless_utils_signature = require("./signature.js");
+const require_permissionless_utils_abi_encoder = require("./abi-encoder.js");
+const require_permissionless_utils_price_update_get_prices = require("./price-update/get-prices.js");
+const require_permissionless_utils_governance_batch = require("./governance/batch.js");
+const require_permissionless_utils_price_update_get_updatable_feeds = require("./price-update/get-updatable-feeds.js");
 const require_permissionless_utils_create2 = require("./create2.js");
 const require_permissionless_utils_format = require("./format.js");
-const require_permissionless_utils_abi_encoder = require("./abi-encoder.js");
 const require_permissionless_utils_block_utils = require("./block-utils.js");
-const require_permissionless_utils_governance_batch = require("./governance/batch.js");
 const require_permissionless_utils_governance_timelock_txs = require("./governance/timelock-txs.js");
 require("./governance/index.js");
 const require_permissionless_utils_price_update_get_price_update_tx = require("./price-update/get-price-update-tx.js");
-const require_permissionless_utils_price_update_get_prices = require("./price-update/get-prices.js");
-const require_permissionless_utils_price_update_get_updatable_feeds = require("./price-update/get-updatable-feeds.js");
 require("./price-update/index.js");
 exports.BYTECODE_REPOSITORY = require_permissionless_utils_literals.BYTECODE_REPOSITORY;
 exports.CROSS_CHAIN_GOVERNANCE = require_permissionless_utils_literals.CROSS_CHAIN_GOVERNANCE;

package/dist/cjs/permissionless/utils/price-update/get-price-update-tx.js

@@ -3,8 +3,8 @@ const require_onchain_utils_createRawTx = require("../../../onchain/utils/create
 const require_onchain_market_pricefeeds_updates_getRawPriceUpdates = require("../../../onchain/market/pricefeeds/updates/getRawPriceUpdates.js");
 const require_onchain_OnchainSDK = require("../../../onchain/OnchainSDK.js");
 require("../../../onchain/index.js");
-require("../../deployment/addresses.js");
 const require_permissionless_bindings_price_feed_store = require("../../bindings/price-feed-store.js");
+require("../../deployment/addresses.js");
 require("../../bindings/index.js");
 let viem = require("viem");
 //#region src/permissionless/utils/price-update/get-price-update-tx.ts

package/dist/cjs/permissionless/utils/price-update/index.js

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_permissionless_utils_price_update_get_price_update_tx = require("./get-price-update-tx.js");
 const require_permissionless_utils_price_update_get_prices = require("./get-prices.js");
 const require_permissionless_utils_price_update_get_updatable_feeds = require("./get-updatable-feeds.js");
+const require_permissionless_utils_price_update_get_price_update_tx = require("./get-price-update-tx.js");
 exports.getPriceUpdateTx = require_permissionless_utils_price_update_get_price_update_tx.getPriceUpdateTx;
 exports.getPrices = require_permissionless_utils_price_update_get_prices.getPrices;
 exports.getUpdatablePriceFeeds = require_permissionless_utils_price_update_get_updatable_feeds.getUpdatablePriceFeeds;

package/dist/esm/offchain/AbstractOffchainNamespace.js

@@ -47,14 +47,7 @@ var AbstractOffchainNamespace = class {
 	**/
 	async get(request) {
 		const url = this.#url(request.path, request.query);
-		const payload = await this.#fetchJson(url);
-		const parsed = responseSchema(request.schema).safeParse(payload);
-		if (!parsed.success) {
-			const error = new OffchainValidationError(url, parsed.error);
-			this.logger?.error(error, "offchain response does not match the read model");
-			throw error;
-		}
-		const { data, meta } = parsed.data;
+		const { data, meta } = await this.#read(url, responseSchema(request.schema));
 		return {
 			data,
 			meta: { chains: meta.chains.map((chain) => ({
@@ -64,6 +57,36 @@ var AbstractOffchainNamespace = class {
 		};
 	}
 	/**
+	* Reads one endpoint that answers with the payload alone, and returns it
+	* unwrapped.
+	*
+	* A read served at no particular block has no envelope to report: the
+	* permissionless routes either span every chain at once, or fall through to
+	* a multicall on the chain itself, so the backend answers `{ data }` and
+	* there is no {@link ResponseMetadata} for {@link get} to decode. The
+	* envelope is still there, which is what keeps a payload that happens to be
+	* an array from being mistaken for an error body.
+	**/
+	async getData(request) {
+		const url = this.#url(request.path, request.query);
+		const { data } = await this.#read(url, z.object({ data: request.schema }));
+		return data;
+	}
+	/**
+	* Body of a successful read, decoded. Schema skew is reported against the
+	* url that produced it, which is the only thing that says which read drifted.
+	**/
+	async #read(url, schema) {
+		const payload = await this.#fetchJson(url);
+		const parsed = schema.safeParse(payload);
+		if (!parsed.success) {
+			const error = new OffchainValidationError(url, parsed.error);
+			this.logger?.error(error, "offchain response does not match the read model");
+			throw error;
+		}
+		return parsed.data;
+	}
+	/**
 	* Reads the charts of one subject: one series per metric named, onto the one
 	* grid that lets them be compared at an index.
 	**/

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

@@ -0,0 +1,78 @@
+import { ChainsNamespace } from "./chains/ChainsNamespace.js";
+import { PermissionlessDeploy } from "./deploy/PermissionlessDeploy.js";
+import { PermissionlessOracles } from "./oracles/PermissionlessOracles.js";
+import { InstanceOwnerTransactions } from "./transactions/InstanceOwnerTransactions.js";
+//#region src/permissionless/api/GearboxPermissionless.ts
+/**
+* Client for the permissionless stack: the oracle rows of a chain, the
+* batches an instance owner executes, and the deploys that produce what goes
+* into both.
+*
+* It reads the same backend {@link GearboxAPI} does, and reads the same way —
+* one namespace per subject, every call scoped by the chain it names. Which
+* chains those are is not passed in: {@link attach} reads the list off the
+* backend and builds a client for each, so this client covers exactly what
+* the backend serves.
+*
+* ```ts
+* const permissionless = new GearboxPermissionless({
+*   baseUrl: "https://api.gearbox.fi",
+* });
+* await permissionless.attach();
+*
+* const [chain] = permissionless.chains.list();
+* const store = await permissionless.oracles.store({ chainId: chain.chainId });
+* ```
+*
+* Only what needs a server goes to one. {@link chains} and {@link oracles}
+* are the backend's reads; {@link deploy} and {@link transactions} read the
+* target chain directly, because everything they answer is derived from there
+* and a round trip would only move the derivation further from the wallet
+* that has to sign for it.
+**/
+var GearboxPermissionless = class {
+	/**
+	* Namespace for the chains the stack runs on, and the viem clients that
+	* reach them.
+	**/
+	chains;
+	/**
+	* Namespace for price feeds: the store and its prices.
+	**/
+	oracles;
+	/**
+	* Namespace for the Safe batches an instance owner executes. Backend-free,
+	* see {@link InstanceOwnerTransactions}.
+	**/
+	transactions;
+	/**
+	* Namespace for deploys through the BytecodeRepository. Backend-free, see
+	* {@link PermissionlessDeploy}.
+	**/
+	deploy;
+	constructor(options = {}) {
+		this.chains = new ChainsNamespace(options);
+		this.oracles = new PermissionlessOracles(options, this.chains);
+		this.transactions = new InstanceOwnerTransactions(this.chains, this.oracles);
+		this.deploy = new PermissionlessDeploy(this.chains);
+	}
+	/**
+	* Loads the chain list and builds the clients, see
+	* {@link ChainsNamespace.attach}. Idempotent, and joins a call already in
+	* flight.
+	*
+	* Everything that reads a chain goes through it, so this has to finish
+	* before the first such call.
+	**/
+	async attach(args = {}) {
+		return this.chains.attach(args);
+	}
+	/**
+	* Whether {@link attach} has completed.
+	**/
+	get isAttached() {
+		return this.chains.isAttached;
+	}
+};
+//#endregion
+export { GearboxPermissionless };

package/dist/esm/permissionless/api/chains/ChainsNamespace.js

@@ -0,0 +1,179 @@
+import { getChain } from "../../../onchain/chain/chains.js";
+import { AbstractOffchainNamespace } from "../../../offchain/AbstractOffchainNamespace.js";
+import { PermissionlessChainUnreachableError, PermissionlessNotAttachedError } from "../errors.js";
+import { chainListSchema, chainSummaryListSchema } from "./schemas.js";
+import { createPublicClient, fallback, http } from "viem";
+//#region src/permissionless/api/chains/ChainsNamespace.ts
+/**
+* The chains the permissionless stack runs on, and the viem clients that
+* reach them.
+*
+* Both halves live here because they answer the same question. Which chains
+* exist is the backend's to decide — it holds rows for chains it does not
+* serve, and those must not be reachable — so the list is also the only
+* honest basis for deciding which clients to build. Nothing is passed in: a
+* caller that had to name the chains could name one the backend does not
+* serve, or miss one it does.
+*
+* The list is fetched once, by {@link attach}, and kept for the client's
+* lifetime:
+*
+* ```ts
+* await permissionless.attach();
+* const chains = permissionless.chains.list();
+* ```
+*
+* Every read before that throws {@link PermissionlessNotAttachedError} rather
+* than answering with an empty list, which would be indistinguishable from a
+* backend that serves nothing.
+*
+* What {@link attach} reads is only what identifies a chain. The counters a
+* list renders next to one are {@link summary}, a second read, because they
+* aggregate over every market the backend knows and nothing should wait on
+* that to start.
+**/
+var ChainsNamespace = class extends AbstractOffchainNamespace {
+	#clients = /* @__PURE__ */ new Map();
+	#chains;
+	#attaching;
+	/** The scope {@link attach} settled on, which {@link summary} follows. */
+	#scope;
+	constructor(options) {
+		super("ChainsNamespace", {
+			...options,
+			chainIds: []
+		});
+	}
+	/**
+	* Reads the chain list off the backend and builds a client for each chain
+	* it names.
+	*
+	* Idempotent, and joins a call already in flight, so a double invocation —
+	* React's StrictMode, two components mounting at once — costs one request.
+	* A second call with a different `scope` is a no-op: the list is decided
+	* once.
+	**/
+	async attach({ scope } = {}) {
+		if (this.#chains) return;
+		this.#attaching ??= this.#load(scope).finally(() => {
+			this.#attaching = void 0;
+		});
+		return this.#attaching;
+	}
+	/**
+	* Whether {@link attach} has completed.
+	**/
+	get isAttached() {
+		return this.#chains !== void 0;
+	}
+	/**
+	* Every chain the backend serves, in the order it listed them.
+	**/
+	list() {
+		if (!this.#chains) throw new PermissionlessNotAttachedError();
+		return this.#chains;
+	}
+	/**
+	* One chain by id, or nothing when the backend does not serve it.
+	*
+	* Reads the attached list rather than a route of its own, which is also
+	* what makes "not served" and "not activated" distinguishable: the first is
+	* absence here, the second is {@link PermissionlessChain.isActivated}.
+	**/
+	find(chainId) {
+		return this.list().find((chain) => chain.chainId === chainId);
+	}
+	/**
+	* The same chains, with the counters a list renders next to them.
+	*
+	* A read of its own, and not part of {@link attach}: the counters aggregate
+	* over every market configurator and market the backend knows, which is
+	* slow enough that waiting on it would hold up the whole client. A list
+	* renders off {@link list} and fills the numbers in when this resolves.
+	*
+	* Nothing is cached — each call is a request — so a caller that renders
+	* this should hold it in whatever already owns its async state.
+	*
+	* Covers the scope {@link attach} settled on unless one is named here, so
+	* the counters describe the list that is already on screen rather than a
+	* different set of chains.
+	*
+	* ```ts
+	* await permissionless.attach();
+	* const chains = permissionless.chains.list();
+	* const withCounters = await permissionless.chains.summary();
+	* ```
+	**/
+	async summary({ scope } = {}) {
+		return this.getData({
+			path: "/chain/summary",
+			query: { scope: scope ?? this.#scope },
+			schema: chainSummaryListSchema
+		});
+	}
+	/**
+	* Chains a client could be built for. A subset of {@link list} — see
+	* {@link client}.
+	**/
+	get chainIds() {
+		if (!this.#chains) throw new PermissionlessNotAttachedError();
+		return [...this.#clients.keys()];
+	}
+	/**
+	* The client for one chain.
+	*
+	* @throws {@link PermissionlessChainUnreachableError} when the backend does
+	* not serve the chain, or serves one this SDK carries no definition for.
+	**/
+	client(chainId) {
+		if (!this.#chains) throw new PermissionlessNotAttachedError();
+		const client = this.#clients.get(chainId);
+		if (!client) throw new PermissionlessChainUnreachableError(chainId);
+		return client;
+	}
+	async #load(scope) {
+		const chains = await this.getData({
+			path: "/chain/list",
+			query: { scope },
+			schema: chainListSchema
+		});
+		this.#scope = scope;
+		this.#clients.clear();
+		for (const { chainId } of chains) {
+			const client = this.#client(chainId);
+			if (client) this.#clients.set(chainId, client);
+		}
+		this.#chains = chains;
+	}
+	/**
+	* A client over the chain's own public endpoints, or nothing when this SDK
+	* has no definition for it.
+	*
+	* The backend will not hand over its endpoints — they carry provider keys —
+	* so the chain definition is all there is to go on. A chain the SDK does
+	* not know stays in {@link list}, because the backend serves it and its
+	* rows are readable through the backend; only the calls that have to reach
+	* it directly fail, and they say which chain they could not reach.
+	**/
+	#client(chainId) {
+		let chain;
+		try {
+			chain = getChain(chainId);
+		} catch {
+			this.logger?.warn(`no chain definition for ${chainId}: it will be listed, but nothing can be read off it directly`);
+			return;
+		}
+		const urls = chain.rpcUrls.default.http;
+		if (urls.length === 0) {
+			this.logger?.warn(`no public endpoint for chain ${chainId}`);
+			return;
+		}
+		const transports = urls.map((url) => http(url));
+		return createPublicClient({
+			chain,
+			transport: transports.length > 1 ? fallback(transports) : transports[0]
+		});
+	}
+};
+//#endregion
+export { ChainsNamespace };

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

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

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

@@ -0,0 +1,30 @@
+import { z } from "zod/v4";
+//#region src/permissionless/api/chains/schemas.ts
+/**
+* Runtime schema for {@link PermissionlessChain}.
+**/
+const chainSchema = z.looseObject({
+	chainId: z.number(),
+	name: z.string(),
+	isPublic: z.boolean(),
+	isActivated: z.boolean(),
+	explorerUrl: z.string()
+});
+/** What `GET /chain/list` answers with. */
+const chainListSchema = z.array(chainSchema);
+/**
+* Runtime schema for {@link PermissionlessChainSummary}.
+*
+* Strict about the two counters on purpose: they are the only reason this
+* read exists, and a backend that answered without them would render as
+* dashes where the numbers belong — a skew worth failing on rather than
+* displaying.
+**/
+const chainSummarySchema = chainSchema.extend({
+	riskCuratorsQty: z.number(),
+	marketsQty: z.number()
+});
+/** What `GET /chain/summary` answers with. */
+const chainSummaryListSchema = z.array(chainSummarySchema);
+//#endregion
+export { chainListSchema, chainSchema, chainSummaryListSchema, chainSummarySchema };

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

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

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

@@ -0,0 +1,149 @@
+import { PriceFeedSaltMissingError, PriceFeedStalenessUnknownError } from "../errors.js";
+import { deriveEffectiveStalenessPeriod } from "./effective-staleness.js";
+import { BytecodeRepositoryContract } from "../../bindings/bytecode-repository.js";
+import { PriceFeedStoreContract } from "../../bindings/price-feed-store.js";
+import "../../deployment/addresses.js";
+import { encodeFunctionParams } from "../../utils/abi-encoder.js";
+import { keccak256, stringToHex, toHex } from "viem";
+//#region src/permissionless/api/deploy/PermissionlessDeploy.ts
+/**
+* Contract type whose first leg needs a bound this client reads off the chain,
+* see {@link PermissionlessDeploy.priceFeed}.
+**/
+const COMPOSITE = "PRICE_FEED::COMPOSITE";
+/** Label the composite's first leg arrives under. */
+const COMPOSITE_FIRST_LEG = "underlyingPriceFeed-0";
+/**
+* Salt a generic contract deploy gets when the caller does not name one. Two
+* deploys of the same type and arguments by the same owner collide under it,
+* which for a singleton like a pause committee is the point.
+**/
+const DEFAULT_DEPLOY_SALT = stringToHex("SALT", { size: 32 });
+/**
+* The salt a price feed is deployed under, derived from its name so that two
+* feeds of the same type and arguments get different addresses.
+**/
+function priceFeedSalt(name) {
+	return keccak256(toHex(name));
+}
+/**
+* Deploys through the BytecodeRepository: the constructor arguments it wants,
+* the CREATE2 address those produce, and the transaction that gets there.
+*
+* Entirely on-chain — no backend is involved, every answer is derived from the
+* target chain. Nothing is sent either: a browser holds the only wallet, so a
+* call prepares the deploy and the caller sends
+* {@link PreparedDeployment.tx} with whatever signs for them.
+*
+* ```ts
+* const feed = await permissionless.deploy.priceFeed({
+*   chainId: 1,
+*   owner: account,
+*   contractType: "PRICE_FEED::CHAINLINK",
+*   version: 310,
+*   name: "WETH / USD",
+*   values,
+* });
+* if (!feed.isAlreadyDeployed) {
+*   await sendRawTx(wallet, { tx: feed.tx });
+* }
+* ```
+**/
+var PermissionlessDeploy = class {
+	#chains;
+	constructor(chains) {
+		this.#chains = chains;
+	}
+	/**
+	* Prepares a price feed deploy from the values a form collected: encodes
+	* them the way the PriceFeedStore reads them back, and reports where the
+	* feed will land.
+	*
+	* A COMPOSITE's first leg is the one case where the values are not taken as
+	* given. It arrives with `stalenessPeriod` 0 whenever it is a derived feed,
+	* because the store registers those with 0 and rejects anything else — which
+	* says nothing about what the leg itself enforces. A composite built on that
+	* 0 can never pass its own staleness check, so the real bound is read off
+	* the leg, see {@link deriveEffectiveStalenessPeriod}.
+	*
+	* The deployed feed reaches {@link PermissionlessOracles.store} only once
+	* it is in the PriceFeedStore, which is a batch the instance owner
+	* executes, see {@link InstanceOwnerTransactions.addFeeds}.
+	**/
+	async priceFeed(args) {
+		const client = this.#chains.client(args.chainId);
+		const salt = this.#priceFeedSalt(args);
+		const values = args.contractType === COMPOSITE ? await this.#withDerivedStaleness(client, args.values) : args.values;
+		const encodedParams = await new PriceFeedStoreContract("0x74A868AC479EE145029bB80827BB77F7B7c441cB", client).encodeConstructorParams(args.contractType, args.version, values);
+		return {
+			...await this.#prepare(client, {
+				contractType: args.contractType,
+				version: args.version,
+				owner: args.owner,
+				encodedParams,
+				salt
+			}),
+			values
+		};
+	}
+	/**
+	* Prepares a generic contract deploy from ABI type/value pairs.
+	*
+	* Unlike a price feed, the arguments here are already typed by the caller,
+	* so nothing is looked up: they are encoded as given and the address they
+	* produce is reported.
+	**/
+	async contract(args) {
+		const client = this.#chains.client(args.chainId);
+		return this.#prepare(client, {
+			contractType: args.contractType,
+			version: args.version,
+			owner: args.owner,
+			encodedParams: encodeFunctionParams(args.values),
+			salt: args.salt ?? DEFAULT_DEPLOY_SALT
+		});
+	}
+	/**
+	* Where the encoded deploy lands, whether it is already there, and the
+	* transaction that puts it there.
+	**/
+	async #prepare(client, args) {
+		const repository = new BytecodeRepositoryContract("0x1cE2B1BE96a082b1b1539F80d5D8f82Ec06a0f9A", client);
+		const [isAlreadyDeployed, address] = await repository.isAlreadyDeployedAddress(args);
+		return {
+			...args,
+			address,
+			isAlreadyDeployed,
+			tx: repository.deployTx({
+				contractType: args.contractType,
+				version: BigInt(args.version),
+				encodedParams: args.encodedParams,
+				salt: args.salt
+			})
+		};
+	}
+	/**
+	* The values with the composite's first leg given the bound it actually
+	* enforces, when it came in without one.
+	**/
+	async #withDerivedStaleness(client, values) {
+		const leg = values[COMPOSITE_FIRST_LEG];
+		if (!leg || typeof leg !== "object" || !leg.address || leg.stalenessPeriod !== 0) return values;
+		const derived = await deriveEffectiveStalenessPeriod(client, leg.address);
+		if (derived === null) throw new PriceFeedStalenessUnknownError(leg.address);
+		return {
+			...values,
+			[COMPOSITE_FIRST_LEG]: {
+				...leg,
+				stalenessPeriod: derived
+			}
+		};
+	}
+	#priceFeedSalt(args) {
+		if (args.salt) return args.salt;
+		if (!args.name) throw new PriceFeedSaltMissingError();
+		return priceFeedSalt(args.name);
+	}
+};
+//#endregion
+export { DEFAULT_DEPLOY_SALT, PermissionlessDeploy, priceFeedSalt };