@gearbox-protocol/sdk 18.2.0-next.4 → 18.2.0-next.6

package/dist/cjs/testnets/schemas.js

@@ -0,0 +1,242 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_chain_chains = require("../onchain/chain/chains.js");
+const require_onchain_utils_zod = require("../onchain/utils/zod.js");
+let zod_v4 = require("zod/v4");
+//#region src/testnets/schemas.ts
+/**
+* Go marshals a nil slice as `null`; this reads it as an empty array.
+**/
+function nullableArray(item) {
+	return zod_v4.z.array(item).nullable().transform((value) => value ?? []);
+}
+/**
+* Go marshals a nil map as `null`; this reads it as an empty record.
+**/
+function nullableRecord(value) {
+	return zod_v4.z.record(zod_v4.z.string(), value).nullable().transform((record) => record ?? {});
+}
+const timestamp = zod_v4.z.iso.datetime({ offset: true });
+/**
+* {@link TestnetStageStatus}
+**/
+const testnetStageStatusSchema = zod_v4.z.enum([
+	"queued",
+	"started",
+	"error",
+	"failed",
+	"success",
+	"terminated"
+]);
+/**
+* {@link TestnetBackendState}
+**/
+const testnetBackendStateSchema = zod_v4.z.enum([
+	"provisioning",
+	"starting",
+	"active",
+	"error"
+]);
+/**
+* {@link Testnet}
+**/
+const testnetSchema = zod_v4.z.object({
+	alias: zod_v4.z.string(),
+	executionId: zod_v4.z.string(),
+	isActive: zod_v4.z.boolean(),
+	description: zod_v4.z.string(),
+	persistent: zod_v4.z.boolean(),
+	paused: zod_v4.z.boolean(),
+	network: require_onchain_chain_chains.NetworkType,
+	createdAt: timestamp
+});
+/**
+* {@link TestnetBackendOptions}
+**/
+const testnetBackendOptionsSchema = zod_v4.z.object({
+	version: zod_v4.z.string().optional(),
+	env: zod_v4.z.record(zod_v4.z.string(), zod_v4.z.string()).optional(),
+	parentBranchId: zod_v4.z.string().optional()
+});
+/**
+* {@link TestnetBackendStatus}
+**/
+const testnetBackendStatusSchema = zod_v4.z.object({
+	state: testnetBackendStateSchema,
+	error: zod_v4.z.string().optional(),
+	version: zod_v4.z.string().optional()
+});
+/**
+* {@link TestnetBlock}
+**/
+const testnetBlockSchema = zod_v4.z.object({
+	number: zod_v4.z.number(),
+	time: timestamp
+});
+/**
+* {@link TestnetScriptBlock}
+**/
+const testnetScriptBlockSchema = testnetBlockSchema.extend({
+	timeDrift: zod_v4.z.number(),
+	originDrift: zod_v4.z.string(),
+	automine: zod_v4.z.boolean(),
+	mineInterval: zod_v4.z.number()
+});
+/**
+* {@link TestnetScriptOptions}
+**/
+const testnetScriptOptionsSchema = zod_v4.z.object({
+	id: zod_v4.z.string(),
+	description: zod_v4.z.string(),
+	npx: zod_v4.z.string().optional(),
+	docker: zod_v4.z.string().optional(),
+	args: nullableArray(zod_v4.z.string()),
+	env: nullableRecord(zod_v4.z.string()),
+	flags: nullableArray(zod_v4.z.string()),
+	timeout: zod_v4.z.string(),
+	packageManager: zod_v4.z.string().optional(),
+	input: zod_v4.z.unknown().optional()
+});
+/**
+* {@link TestnetScript}
+**/
+const testnetScriptSchema = zod_v4.z.object({
+	script: testnetScriptOptionsSchema,
+	duration: zod_v4.z.string(),
+	blockBefore: testnetScriptBlockSchema.optional(),
+	blockAfter: testnetScriptBlockSchema.optional(),
+	status: testnetStageStatusSchema,
+	error: zod_v4.z.string().optional(),
+	exitCode: zod_v4.z.number(),
+	source: zod_v4.z.string().optional(),
+	revision: zod_v4.z.string().optional()
+});
+/**
+* {@link TestnetTaskDefinition}
+**/
+const testnetTaskDefinitionSchema = zod_v4.z.object({
+	id: zod_v4.z.string().optional(),
+	family: zod_v4.z.string().optional(),
+	name: zod_v4.z.string().optional(),
+	description: zod_v4.z.string().optional(),
+	image: zod_v4.z.string(),
+	version: zod_v4.z.string().optional(),
+	entrypoint: zod_v4.z.array(zod_v4.z.string()).optional(),
+	command: zod_v4.z.array(zod_v4.z.string()).optional(),
+	env: zod_v4.z.record(zod_v4.z.string(), zod_v4.z.string()).optional(),
+	secrets: zod_v4.z.record(zod_v4.z.string(), zod_v4.z.string()).optional(),
+	input: zod_v4.z.unknown().optional(),
+	timeout: zod_v4.z.number().optional(),
+	concurrent: zod_v4.z.boolean(),
+	multicontainer: zod_v4.z.boolean(),
+	schemaVersion: zod_v4.z.number().optional()
+});
+/**
+* {@link TestnetTaskProgress}
+**/
+const testnetTaskProgressSchema = zod_v4.z.object({
+	completed: zod_v4.z.number(),
+	total: zod_v4.z.number(),
+	details: zod_v4.z.unknown().optional()
+});
+/**
+* {@link TestnetTask}
+**/
+const testnetTaskSchema = zod_v4.z.object({
+	id: zod_v4.z.string(),
+	definitionId: zod_v4.z.string(),
+	family: zod_v4.z.string(),
+	executionId: zod_v4.z.string(),
+	name: zod_v4.z.string().optional(),
+	description: zod_v4.z.string().optional(),
+	image: zod_v4.z.string(),
+	source: zod_v4.z.string().optional(),
+	revision: zod_v4.z.string().optional(),
+	entrypoint: zod_v4.z.array(zod_v4.z.string()).optional(),
+	command: zod_v4.z.array(zod_v4.z.string()).optional(),
+	env: zod_v4.z.record(zod_v4.z.string(), zod_v4.z.string()).optional(),
+	secrets: zod_v4.z.record(zod_v4.z.string(), zod_v4.z.string()).optional(),
+	input: zod_v4.z.unknown().optional(),
+	multicontainer: zod_v4.z.boolean(),
+	concurrent: zod_v4.z.boolean(),
+	outputDir: zod_v4.z.string().optional(),
+	status: testnetStageStatusSchema,
+	error: zod_v4.z.string().optional(),
+	createdAt: timestamp,
+	updatedAt: timestamp,
+	progress: testnetTaskProgressSchema
+});
+/**
+* {@link TestnetOptions}
+**/
+const testnetOptionsSchema = zod_v4.z.object({
+	description: zod_v4.z.string().optional(),
+	chainId: zod_v4.z.number().optional(),
+	network: require_onchain_chain_chains.NetworkType,
+	cid: zod_v4.z.string().optional(),
+	anvilFlags: zod_v4.z.array(zod_v4.z.string()).optional(),
+	anvilImage: zod_v4.z.string().optional(),
+	rpcProvider: zod_v4.z.string().optional(),
+	addressProvider: require_onchain_utils_zod.ZodAddress().optional(),
+	marketConfigurators: zod_v4.z.array(require_onchain_utils_zod.ZodAddress()).optional(),
+	rwaFactories: zod_v4.z.array(require_onchain_utils_zod.ZodAddress()).optional(),
+	blockNumber: zod_v4.z.string(),
+	owner: zod_v4.z.string(),
+	timeout: zod_v4.z.string(),
+	synctronLogLevel: zod_v4.z.string().optional(),
+	scripts: nullableArray(testnetScriptOptionsSchema),
+	disableSync: zod_v4.z.boolean(),
+	disableIntervalMining: zod_v4.z.boolean(),
+	disableRPCProtection: zod_v4.z.boolean(),
+	debug: zod_v4.z.boolean().optional(),
+	webhooks: nullableArray(zod_v4.z.string()),
+	backend: testnetBackendOptionsSchema.optional(),
+	tasks: zod_v4.z.array(testnetTaskDefinitionSchema).optional()
+});
+/**
+* {@link TestnetStatus}
+**/
+const testnetStatusSchema = zod_v4.z.object({
+	alias: zod_v4.z.string().optional(),
+	network: require_onchain_chain_chains.NetworkType,
+	nextRestart: timestamp.optional(),
+	isActive: zod_v4.z.boolean(),
+	ready: zod_v4.z.boolean(),
+	paused: zod_v4.z.boolean(),
+	rpcUrl: zod_v4.z.string().optional(),
+	url: zod_v4.z.string(),
+	logsUrl: zod_v4.z.string(),
+	persistent: zod_v4.z.boolean(),
+	latestBlock: testnetScriptBlockSchema.optional(),
+	tasks: zod_v4.z.array(testnetTaskSchema).optional(),
+	backend: testnetBackendStatusSchema.optional(),
+	executionId: zod_v4.z.string(),
+	options: testnetOptionsSchema,
+	forkBlock: testnetBlockSchema,
+	syncBlock: zod_v4.z.number(),
+	syncError: zod_v4.z.string().optional(),
+	originChainId: zod_v4.z.number(),
+	anvilChainId: zod_v4.z.number(),
+	createdAt: timestamp,
+	addressProvider: require_onchain_utils_zod.ZodAddress(),
+	marketConfigurators: zod_v4.z.array(require_onchain_utils_zod.ZodAddress()).optional(),
+	rwaFactories: zod_v4.z.array(require_onchain_utils_zod.ZodAddress()).optional(),
+	onchainExecutionId: require_onchain_utils_zod.ZodAddress(),
+	scripts: zod_v4.z.array(testnetScriptSchema).optional(),
+	cid: zod_v4.z.string().optional(),
+	files: zod_v4.z.array(zod_v4.z.string()).optional()
+});
+//#endregion
+exports.testnetBackendOptionsSchema = testnetBackendOptionsSchema;
+exports.testnetBackendStateSchema = testnetBackendStateSchema;
+exports.testnetBackendStatusSchema = testnetBackendStatusSchema;
+exports.testnetBlockSchema = testnetBlockSchema;
+exports.testnetOptionsSchema = testnetOptionsSchema;
+exports.testnetSchema = testnetSchema;
+exports.testnetScriptBlockSchema = testnetScriptBlockSchema;
+exports.testnetScriptOptionsSchema = testnetScriptOptionsSchema;
+exports.testnetScriptSchema = testnetScriptSchema;
+exports.testnetStageStatusSchema = testnetStageStatusSchema;
+exports.testnetStatusSchema = testnetStatusSchema;
+exports.testnetTaskDefinitionSchema = testnetTaskDefinitionSchema;
+exports.testnetTaskProgressSchema = testnetTaskProgressSchema;
+exports.testnetTaskSchema = testnetTaskSchema;

package/dist/cjs/testnets/types.js

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

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

@@ -124,10 +124,10 @@ var PermissionlessOracles = class extends AbstractOffchainNamespace {
 	* const everywhere = await permissionless.oracles.assets();
 	* ```
 	**/
-	async assets(args = {}) {
-		const query = args.chainId === void 0 ? "" : `?chainId=${encodeURIComponent(args.chainId)}`;
+	async assets({ chainId } = {}) {
 		return this.getData({
-			path: `/pfs/assets${query}`,
+			path: "/pfs/assets",
+			query: { chainId: chainId?.toString() },
 			schema: assetSummariesSchema
 		});
 	}

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

@@ -1,3 +1,4 @@
+import { chainSchema } from "../chains/schemas.js";
 import { addressRecord, addressSchema } from "../schemas.js";
 import { z } from "zod/v4";
 //#region src/permissionless/api/oracles/schemas.ts
@@ -18,22 +19,29 @@ const priceFeedSchema = z.looseObject({
 	stalenessPeriod: z.number(),
 	name: z.string()
 });
-/** {@link PermissionlessAsset} */
-const assetSchema = z.looseObject({
+/**
+* {@link PermissionlessPriceFeedAsset}
+*
+* What identifies an asset, which is all a feed's own listing of one says.
+**/
+const priceFeedAssetSchema = z.looseObject({
 	address: addressSchema,
 	symbol: z.string(),
 	name: z.string(),
-	decimals: z.number(),
+	decimals: z.number()
+});
+/** {@link PermissionlessAsset} — identified as above, plus what prices it. */
+const assetSchema = priceFeedAssetSchema.extend({
 	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(),
+/**
+* {@link PermissionlessPriceFeedStore}
+*
+* A store is a chain's, and is described by the same five fields the chain
+* list answers with, so those are extended rather than restated.
+**/
+const priceFeedStoreSchema = chainSchema.extend({
 	assets: z.array(assetSchema),
 	priceFeeds: z.array(priceFeedSchema)
 });
@@ -43,26 +51,29 @@ const pricesSchema = z.looseObject({
 	marketCaps: addressRecord(addressRecord(z.string().nullable())),
 	time: z.number()
 });
-/** {@link PermissionlessPriceFeedAsset} */
-const priceFeedAssetSchema = z.looseObject({
-	address: addressSchema,
-	symbol: z.string(),
-	name: z.string(),
-	decimals: z.number()
-});
-/** {@link PermissionlessPriceFeedMarket} */
-const priceFeedMarketSchema = z.looseObject({
+/**
+* What names a market, whichever side it is being listed from.
+*
+* A feed's markets and an asset's markets are different reads, but they
+* answer with the same market: who curates it, what it is denominated in and
+* how much of the quota is taken. Only what the read is about differs, which
+* is what each of the two below adds.
+**/
+const marketSchema = z.looseObject({
 	market: addressSchema,
 	marketConfigurator: addressSchema,
 	curatorName: z.string().nullable(),
 	marketName: z.string().nullable(),
-	token: addressSchema,
-	tokenSymbol: z.string().nullable(),
 	underlyingSymbol: z.string().nullable(),
-	reserve: z.boolean(),
 	isUnderlying: z.boolean(),
 	quotaLimit: z.number().nullable(),
-	quotaUsed: z.number().nullable(),
+	quotaUsed: z.number().nullable()
+});
+/** {@link PermissionlessPriceFeedMarket} — the market as the feed's slot in it. */
+const priceFeedMarketSchema = marketSchema.extend({
+	token: addressSchema,
+	tokenSymbol: z.string().nullable(),
+	reserve: z.boolean(),
 	marketStalenessPeriod: z.number().nullable()
 });
 /** {@link PermissionlessPriceFeedDetails} */
@@ -83,20 +94,12 @@ const assetMarketFeedSchema = z.looseObject({
 	name: z.string().nullable(),
 	inStore: z.boolean()
 });
-/** {@link PermissionlessAssetMarket} */
-const assetMarketSchema = z.looseObject({
-	market: addressSchema,
-	marketConfigurator: addressSchema,
-	curatorName: z.string().nullable(),
-	marketName: z.string().nullable(),
+/** {@link PermissionlessAssetMarket} — the market as what prices the asset in it. */
+const assetMarketSchema = marketSchema.extend({
 	underlyingToken: addressSchema,
-	underlyingSymbol: z.string().nullable(),
-	isUnderlying: z.boolean(),
 	isShutdown: z.boolean(),
 	mainFeed: assetMarketFeedSchema.nullable(),
-	reserveFeed: assetMarketFeedSchema.nullable(),
-	quotaLimit: z.number().nullable(),
-	quotaUsed: z.number().nullable()
+	reserveFeed: assetMarketFeedSchema.nullable()
 });
 /** {@link PermissionlessAssetDetails} */
 const assetDetailsSchema = z.looseObject({
@@ -107,7 +110,13 @@ const assetDetailsSchema = z.looseObject({
 	quotaLimitUsd: z.number().nullable(),
 	quotaUsedUsd: z.number().nullable()
 });
-/** {@link PermissionlessAssetPrices} */
+/**
+* {@link PermissionlessAssetPrices}
+*
+* The same shape as {@link priceFeedMarketCapsSchema} plus the prices, but not
+* an extension of it: the caps there are keyed by asset and these are keyed by
+* feed, so what the two have in common is a coincidence of form.
+**/
 const assetPricesSchema = z.looseObject({
 	prices: addressRecord(z.string().nullable()),
 	marketCaps: addressRecord(z.string().nullable()),

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

@@ -1,4 +1,4 @@
-import { isAddress, isHex } from "viem";
+import { isAddress } from "viem";
 import { z } from "zod/v4";
 //#region src/permissionless/api/schemas.ts
 /**
@@ -11,8 +11,6 @@ import { z } from "zod/v4";
 **/
 /** 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.
@@ -22,4 +20,4 @@ function addressRecord(value) {
 	return z.record(key, value);
 }
 //#endregion
-export { addressRecord, addressSchema, hexSchema };
+export { addressRecord, addressSchema };

package/dist/esm/testnets/TestnetsAPI.js

@@ -0,0 +1,178 @@
+import { TestnetStatusError } from "./errors/TestnetStatusError.js";
+import { TestnetNotFoundError } from "./errors/TestnetNotFoundError.js";
+import { TestnetRequestFailedError } from "./errors/TestnetRequestFailedError.js";
+import { TestnetValidationError } from "./errors/TestnetValidationError.js";
+import { TestnetWaitTimeoutError } from "./errors/TestnetWaitTimeoutError.js";
+import "./errors/index.js";
+import { testnetSchema, testnetStatusSchema } from "./schemas.js";
+import { z } from "zod/v4";
+//#region src/testnets/TestnetsAPI.ts
+const DEFAULT_BASE_URL = "https://anvil.gearbox.foundation";
+const DEFAULT_TIMEOUT = 3e4;
+const DEFAULT_WAIT_TIMEOUT = 6e5;
+const DEFAULT_WAIT_INTERVAL = 5e3;
+const errorBodySchema = z.object({ error: z.string() });
+/**
+* Client for anvil-manager, which runs the anvil forks Gearbox calls
+* testnets. It manages non-persistent testnets only, addressed by their
+* execution id.
+*
+* ```ts
+* const testnets = new TestnetsAPI({ apiKey: process.env.ANVIL_MANAGER_API_KEY });
+* const { executionId } = await testnets.create({ network: "Mainnet", timeout: "2h" });
+* const status = await testnets.waitUntilReady(executionId);
+* // ... use status.rpcUrl ...
+* await testnets.kill(executionId);
+* ```
+*
+* Every method throws a {@link TestnetsError} subclass when it fails, except
+* when a response body is not JSON: then it rejects with the error of
+* `response.json()`.
+**/
+var TestnetsAPI = class {
+	logger;
+	#baseUrl;
+	#apiKey;
+	#timeout;
+	constructor(options = {}) {
+		this.#baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+		this.#apiKey = options.apiKey;
+		this.#timeout = options.timeout ?? DEFAULT_TIMEOUT;
+		this.logger = options.logger?.child?.({ name: "TestnetsAPI" }) ?? options.logger;
+	}
+	/**
+	* Base URL every request of this client is sent to.
+	**/
+	get baseUrl() {
+		return this.#baseUrl;
+	}
+	/**
+	* Every testnet anvil-manager knows of, persistent ones included.
+	**/
+	async list() {
+		const url = this.#url("/api/v1/forks");
+		const response = await this.#fetch(url, { method: "GET" });
+		return this.#decode(url, response, z.array(testnetSchema));
+	}
+	/**
+	* Status of one testnet.
+	*
+	* @param id - Execution id of the testnet.
+	* @throws {@link TestnetNotFoundError} when there is no such testnet.
+	**/
+	async get(id) {
+		const url = this.#forkUrl(id);
+		const response = await this.#fetch(url, { method: "GET" });
+		return this.#decode(url, response, testnetStatusSchema);
+	}
+	/**
+	* Starts a testnet. It answers as soon as the testnet is created, long
+	* before it is {@link TestnetStatus.ready}.
+	*
+	* @param files - Saved in the testnet's shared dir, where scripts and tasks
+	* can read them.
+	**/
+	async create(request, files) {
+		const url = this.#url("/api/v1/forks");
+		const response = await this.#fetch(url, {
+			method: "POST",
+			...createBody(request, files)
+		});
+		return this.#decode(url, response, testnetStatusSchema);
+	}
+	/**
+	* Stops a testnet. Stopping one that is already stopped succeeds.
+	*
+	* @param id - Execution id of the testnet.
+	* @throws {@link TestnetNotFoundError} when there is no such testnet.
+	* @throws {@link TestnetStatusError} with status 400 when the testnet is
+	* persistent.
+	**/
+	async kill(id) {
+		await this.#fetch(this.#forkUrl(id), { method: "DELETE" });
+	}
+	/**
+	* Polls a testnet's status until it is {@link TestnetStatus.ready}.
+	*
+	* @param id - Execution id of the testnet.
+	* @returns The first status that is ready.
+	* @throws {@link TestnetWaitTimeoutError} when the testnet is not ready in
+	* time. Any error of a poll is thrown as is, without retrying.
+	**/
+	async waitUntilReady(id, options = {}) {
+		const { timeout = DEFAULT_WAIT_TIMEOUT, interval = DEFAULT_WAIT_INTERVAL } = options;
+		const deadline = Date.now() + timeout;
+		while (true) {
+			const status = await this.get(id);
+			if (status.ready) return status;
+			const remaining = deadline - Date.now();
+			if (remaining <= 0) throw new TestnetWaitTimeoutError(this.#forkUrl(id), id, timeout);
+			this.logger?.debug(`testnet ${id} is not ready yet`);
+			await new Promise((resolve) => setTimeout(resolve, Math.min(interval, remaining)));
+		}
+	}
+	#url(path) {
+		return `${this.#baseUrl}${path}`;
+	}
+	#forkUrl(id) {
+		return this.#url(`/api/v1/forks/${encodeURIComponent(id)}`);
+	}
+	/**
+	* Sends one request and returns its response once it is known to be 2xx.
+	**/
+	async #fetch(url, init) {
+		const headers = new Headers(init.headers);
+		headers.set("accept", "application/json");
+		if (this.#apiKey) headers.set("authorization", `Bearer ${this.#apiKey}`);
+		let response;
+		try {
+			response = await fetch(url, {
+				...init,
+				headers,
+				signal: AbortSignal.timeout(this.#timeout)
+			});
+		} catch (error) {
+			throw new TestnetRequestFailedError(url, error);
+		}
+		if (!response.ok) {
+			const responseBody = await response.text();
+			const details = errorBodySchema.safeParse(responseBody).data?.error;
+			throw response.status === 404 ? new TestnetNotFoundError(url, details) : new TestnetStatusError(url, response.status, details);
+		}
+		return response;
+	}
+	/**
+	* Body of a 2xx response, decoded.
+	**/
+	async #decode(url, response, schema) {
+		const payload = await response.json();
+		const parsed = schema.safeParse(payload);
+		if (!parsed.success) {
+			const error = new TestnetValidationError(url, parsed.error);
+			this.logger?.error(error, "anvil-manager response does not match the testnet schemas");
+			throw error;
+		}
+		return parsed.data;
+	}
+};
+/**
+* Body and content type of a create request: JSON alone, or a multipart form
+* with the JSON in its `json` field when there are files to upload.
+**/
+function createBody(request, files) {
+	const json = JSON.stringify(request);
+	if (!files || Object.keys(files).length === 0) return {
+		body: json,
+		headers: { "content-type": "application/json" }
+	};
+	const form = new FormData();
+	form.append("json", json);
+	for (const [name, contents] of Object.entries(files)) form.append("file", toBlob(contents), name);
+	return { body: form };
+}
+function toBlob(contents) {
+	if (contents instanceof Blob) return contents;
+	return new Blob([typeof contents === "string" ? contents : new Uint8Array(contents)]);
+}
+//#endregion
+export { TestnetsAPI };

package/dist/esm/testnets/errors/TestnetNotFoundError.js

@@ -0,0 +1,14 @@
+import { TestnetStatusError } from "./TestnetStatusError.js";
+//#region src/testnets/errors/TestnetNotFoundError.ts
+/**
+* Thrown when anvil-manager answered 404: there is no testnet with that
+* execution id.
+**/
+var TestnetNotFoundError = class extends TestnetStatusError {
+	name = "TestnetNotFoundError";
+	constructor(url, details) {
+		super(url, 404, details);
+	}
+};
+//#endregion
+export { TestnetNotFoundError };

package/dist/esm/testnets/errors/TestnetRequestFailedError.js

@@ -0,0 +1,23 @@
+import { TestnetsError } from "./TestnetsError.js";
+//#region src/testnets/errors/TestnetRequestFailedError.ts
+/**
+* Thrown when a request to anvil-manager never completed: the network was
+* down, or it took longer than the client's timeout.
+**/
+var TestnetRequestFailedError = class extends TestnetsError {
+	name = "TestnetRequestFailedError";
+	constructor(url, cause) {
+		super(timedOut(cause) ? "The request to anvil-manager timed out." : "The request to anvil-manager failed.", {
+			url,
+			cause
+		});
+	}
+};
+/**
+* Whether a caught value is the rejection `AbortSignal.timeout` produces.
+**/
+function timedOut(error) {
+	return error instanceof Error && error.name === "TimeoutError";
+}
+//#endregion
+export { TestnetRequestFailedError };

package/dist/esm/testnets/errors/TestnetStatusError.js

@@ -0,0 +1,18 @@
+import { TestnetsError } from "./TestnetsError.js";
+//#region src/testnets/errors/TestnetStatusError.ts
+/**
+* Thrown when anvil-manager answered with a status outside the 2xx range. What
+* it said about it, when it said anything, is the `details` of the error.
+**/
+var TestnetStatusError = class extends TestnetsError {
+	name = "TestnetStatusError";
+	constructor(url, status, details) {
+		super(`anvil-manager answered ${status}.`, {
+			url,
+			status,
+			details
+		});
+	}
+};
+//#endregion
+export { TestnetStatusError };

package/dist/esm/testnets/errors/TestnetValidationError.js

@@ -0,0 +1,23 @@
+import { TestnetsError } from "./TestnetsError.js";
+import { z } from "zod/v4";
+//#region src/testnets/errors/TestnetValidationError.ts
+/**
+* Thrown when anvil-manager answered, but with a payload the testnet schemas
+* do not describe, i.e. the two are of different versions.
+**/
+var TestnetValidationError = class extends TestnetsError {
+	name = "TestnetValidationError";
+	/**
+	* The zod failure itself, e.g. for `z.treeifyError(error.zodError)`.
+	**/
+	zodError;
+	constructor(url, zodError) {
+		super("The anvil-manager response does not match the testnet schemas.", {
+			url,
+			metaMessages: z.prettifyError(zodError).split("\n")
+		});
+		this.zodError = zodError;
+	}
+};
+//#endregion
+export { TestnetValidationError };