@gearbox-protocol/sdk 17.10.1 → 17.11.0

package/dist/cjs/offchain/AbstractOffchainNamespace.js

@@ -48,14 +48,7 @@ var AbstractOffchainNamespace = class {
 	**/
 	async get(request) {
 		const url = this.#url(request.path, request.query);
-		const payload = await this.#fetchJson(url);
-		const parsed = require_model_response_schema.responseSchema(request.schema).safeParse(payload);
-		if (!parsed.success) {
-			const error = new require_offchain_errors_OffchainValidationError.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, require_model_response_schema.responseSchema(request.schema));
 		return {
 			data,
 			meta: { chains: meta.chains.map((chain) => ({
@@ -65,6 +58,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, zod_v4.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 require_offchain_errors_OffchainValidationError.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/cjs/permissionless/api/GearboxPermissionless.js

@@ -0,0 +1,79 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_permissionless_api_chains_ChainsNamespace = require("./chains/ChainsNamespace.js");
+const require_permissionless_api_deploy_PermissionlessDeploy = require("./deploy/PermissionlessDeploy.js");
+const require_permissionless_api_oracles_PermissionlessOracles = require("./oracles/PermissionlessOracles.js");
+const require_permissionless_api_transactions_InstanceOwnerTransactions = require("./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 require_permissionless_api_chains_ChainsNamespace.ChainsNamespace(options);
+		this.oracles = new require_permissionless_api_oracles_PermissionlessOracles.PermissionlessOracles(options, this.chains);
+		this.transactions = new require_permissionless_api_transactions_InstanceOwnerTransactions.InstanceOwnerTransactions(this.chains, this.oracles);
+		this.deploy = new require_permissionless_api_deploy_PermissionlessDeploy.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
+exports.GearboxPermissionless = GearboxPermissionless;

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

@@ -0,0 +1,180 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_chain_chains = require("../../../onchain/chain/chains.js");
+const require_offchain_AbstractOffchainNamespace = require("../../../offchain/AbstractOffchainNamespace.js");
+const require_permissionless_api_errors = require("../errors.js");
+const require_permissionless_api_chains_schemas = require("./schemas.js");
+let viem = require("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 require_offchain_AbstractOffchainNamespace.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 require_permissionless_api_errors.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: require_permissionless_api_chains_schemas.chainSummaryListSchema
+		});
+	}
+	/**
+	* Chains a client could be built for. A subset of {@link list} — see
+	* {@link client}.
+	**/
+	get chainIds() {
+		if (!this.#chains) throw new require_permissionless_api_errors.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 require_permissionless_api_errors.PermissionlessNotAttachedError();
+		const client = this.#clients.get(chainId);
+		if (!client) throw new require_permissionless_api_errors.PermissionlessChainUnreachableError(chainId);
+		return client;
+	}
+	async #load(scope) {
+		const chains = await this.getData({
+			path: "/chain/list",
+			query: { scope },
+			schema: require_permissionless_api_chains_schemas.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 = require_onchain_chain_chains.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) => (0, viem.http)(url));
+		return (0, viem.createPublicClient)({
+			chain,
+			transport: transports.length > 1 ? (0, viem.fallback)(transports) : transports[0]
+		});
+	}
+};
+//#endregion
+exports.ChainsNamespace = ChainsNamespace;

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

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

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

@@ -0,0 +1,34 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let zod_v4 = require("zod/v4");
+//#region src/permissionless/api/chains/schemas.ts
+/**
+* Runtime schema for {@link PermissionlessChain}.
+**/
+const chainSchema = 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()
+});
+/** What `GET /chain/list` answers with. */
+const chainListSchema = zod_v4.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: zod_v4.z.number(),
+	marketsQty: zod_v4.z.number()
+});
+/** What `GET /chain/summary` answers with. */
+const chainSummaryListSchema = zod_v4.z.array(chainSummarySchema);
+//#endregion
+exports.chainListSchema = chainListSchema;
+exports.chainSchema = chainSchema;
+exports.chainSummaryListSchema = chainSummaryListSchema;
+exports.chainSummarySchema = chainSummarySchema;

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

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

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

@@ -0,0 +1,152 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_permissionless_api_errors = require("../errors.js");
+const require_permissionless_api_deploy_effective_staleness = require("./effective-staleness.js");
+const require_permissionless_bindings_bytecode_repository = require("../../bindings/bytecode-repository.js");
+const require_permissionless_bindings_price_feed_store = require("../../bindings/price-feed-store.js");
+require("../../deployment/addresses.js");
+const require_permissionless_utils_abi_encoder = require("../../utils/abi-encoder.js");
+let viem = require("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 = (0, viem.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 (0, viem.keccak256)((0, viem.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 require_permissionless_bindings_price_feed_store.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: require_permissionless_utils_abi_encoder.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 require_permissionless_bindings_bytecode_repository.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 require_permissionless_api_deploy_effective_staleness.deriveEffectiveStalenessPeriod(client, leg.address);
+		if (derived === null) throw new require_permissionless_api_errors.PriceFeedStalenessUnknownError(leg.address);
+		return {
+			...values,
+			[COMPOSITE_FIRST_LEG]: {
+				...leg,
+				stalenessPeriod: derived
+			}
+		};
+	}
+	#priceFeedSalt(args) {
+		if (args.salt) return args.salt;
+		if (!args.name) throw new require_permissionless_api_errors.PriceFeedSaltMissingError();
+		return priceFeedSalt(args.name);
+	}
+};
+//#endregion
+exports.DEFAULT_DEPLOY_SALT = DEFAULT_DEPLOY_SALT;
+exports.PermissionlessDeploy = PermissionlessDeploy;
+exports.priceFeedSalt = priceFeedSalt;

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

@@ -0,0 +1,46 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/permissionless/api/deploy/effective-staleness.ts
+const abi = (0, require("viem").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
+exports.deriveEffectiveStalenessPeriod = deriveEffectiveStalenessPeriod;

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

@@ -0,0 +1,8 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_permissionless_api_deploy_effective_staleness = require("./effective-staleness.js");
+const require_permissionless_api_deploy_PermissionlessDeploy = require("./PermissionlessDeploy.js");
+require("./types.js");
+exports.DEFAULT_DEPLOY_SALT = require_permissionless_api_deploy_PermissionlessDeploy.DEFAULT_DEPLOY_SALT;
+exports.PermissionlessDeploy = require_permissionless_api_deploy_PermissionlessDeploy.PermissionlessDeploy;
+exports.deriveEffectiveStalenessPeriod = require_permissionless_api_deploy_effective_staleness.deriveEffectiveStalenessPeriod;
+exports.priceFeedSalt = require_permissionless_api_deploy_PermissionlessDeploy.priceFeedSalt;

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

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

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

@@ -0,0 +1,82 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let viem = require("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 viem.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 viem.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 viem.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 viem.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 viem.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
+exports.PermissionlessChainUnreachableError = PermissionlessChainUnreachableError;
+exports.PermissionlessNotAttachedError = PermissionlessNotAttachedError;
+exports.PriceFeedNotInStoreError = PriceFeedNotInStoreError;
+exports.PriceFeedSaltMissingError = PriceFeedSaltMissingError;
+exports.PriceFeedStalenessUnknownError = PriceFeedStalenessUnknownError;

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

@@ -0,0 +1,28 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_permissionless_api_errors = require("./errors.js");
+const require_permissionless_api_chains_ChainsNamespace = require("./chains/ChainsNamespace.js");
+require("./chains/index.js");
+const require_permissionless_api_deploy_effective_staleness = require("./deploy/effective-staleness.js");
+const require_permissionless_api_deploy_PermissionlessDeploy = require("./deploy/PermissionlessDeploy.js");
+require("./deploy/index.js");
+const require_permissionless_api_oracles_PermissionlessOracles = require("./oracles/PermissionlessOracles.js");
+const require_permissionless_api_transactions_InstanceOwnerTransactions = require("./transactions/InstanceOwnerTransactions.js");
+const require_permissionless_api_GearboxPermissionless = require("./GearboxPermissionless.js");
+require("./oracles/index.js");
+require("./transactions/index.js");
+require("./types.js");
+exports.ChainsNamespace = require_permissionless_api_chains_ChainsNamespace.ChainsNamespace;
+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.InstanceOwnerTransactions = require_permissionless_api_transactions_InstanceOwnerTransactions.InstanceOwnerTransactions;
+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.deriveEffectiveStalenessPeriod = require_permissionless_api_deploy_effective_staleness.deriveEffectiveStalenessPeriod;
+exports.priceFeedSalt = require_permissionless_api_deploy_PermissionlessDeploy.priceFeedSalt;