x402-proxy 0.10.7 → 0.10.9

package/dist/decodeFunctionData-JPOUdvil.js

@@ -0,0 +1,4394 @@
+import { f as equalBytes } from "./utils-BYjkXZDF.js";
+import { A as createCursor, At as formatAbiItem$1, D as formatGwei, Dt as BaseError$2, E as prettyPrint, H as isAddress, J as hexToBytes, K as InvalidAddressError, L as slice$2, M as parseAccount, N as encodeAbiParameters, O as formatEther, Ot as size$2, P as getArrayComponents, R as sliceBytes, Tt as InvalidAbiDecodingTypeError, U as checksumAddress, V as concatHex, X as bytesToHex, Y as toBytes$1, Z as numberToHex, _ as TransactionTypeNotSupportedError, at as InvalidBytesBooleanError$1, bt as AbiFunctionSignatureNotFoundError, c as FeeCapTooHighError, ct as InvalidBytesLengthError, d as IntrinsicGasTooHighError, dt as AbiDecodingDataSizeTooSmallError, et as assertSize$2, f as IntrinsicGasTooLowError, ft as AbiDecodingZeroDataError, g as TipAboveFeeCapError, h as NonceTooLowError, ht as AbiErrorSignatureNotFoundError, i as ClientChainNotConfiguredError, it as trim$2, k as stringify$1, kt as isHex, l as FeeCapTooLowError, lt as AbiConstructorNotFoundError, m as NonceTooHighError, o as maxUint256, p as NonceMaxValueError, q as keccak256, rt as hexToNumber, s as ExecutionRevertedError, t as ChainDoesNotSupportContract, tt as hexToBigInt, u as InsufficientFundsError, ut as AbiConstructorParamsNotFoundError, v as UnknownNodeError, vt as AbiFunctionNotFoundError, xt as AbiItemAmbiguityError, yt as AbiFunctionOutputsNotFoundError } from "./chain-DwfP5RGZ.js";
+//#region node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.3.6/node_modules/abitype/dist/esm/version.js
+const version$1 = "1.2.3";
+//#endregion
+//#region node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.3.6/node_modules/abitype/dist/esm/errors.js
+var BaseError$1 = class BaseError$1 extends Error {
+	constructor(shortMessage, args = {}) {
+		const details = args.cause instanceof BaseError$1 ? args.cause.details : args.cause?.message ? args.cause.message : args.details;
+		const docsPath = args.cause instanceof BaseError$1 ? args.cause.docsPath || args.docsPath : args.docsPath;
+		const message = [
+			shortMessage || "An error occurred.",
+			"",
+			...args.metaMessages ? [...args.metaMessages, ""] : [],
+			...docsPath ? [`Docs: https://abitype.dev${docsPath}`] : [],
+			...details ? [`Details: ${details}`] : [],
+			`Version: abitype@${version$1}`
+		].join("\n");
+		super(message);
+		Object.defineProperty(this, "details", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "docsPath", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "metaMessages", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "shortMessage", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "AbiTypeError"
+		});
+		if (args.cause) this.cause = args.cause;
+		this.details = details;
+		this.docsPath = docsPath;
+		this.metaMessages = args.metaMessages;
+		this.shortMessage = shortMessage;
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.3.6/node_modules/abitype/dist/esm/regex.js
+function execTyped(regex, string) {
+	return regex.exec(string)?.groups;
+}
+const bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
+const integerRegex = /^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
+const isTupleRegex = /^\(.+?\).*?$/;
+//#endregion
+//#region node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.3.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js
+const tupleRegex = /^tuple(?<array>(\[(\d*)\])*)$/;
+/**
+* Formats {@link AbiParameter} to human-readable ABI parameter.
+*
+* @param abiParameter - ABI parameter
+* @returns Human-readable ABI parameter
+*
+* @example
+* const result = formatAbiParameter({ type: 'address', name: 'from' })
+* //    ^? const result: 'address from'
+*/
+function formatAbiParameter(abiParameter) {
+	let type = abiParameter.type;
+	if (tupleRegex.test(abiParameter.type) && "components" in abiParameter) {
+		type = "(";
+		const length = abiParameter.components.length;
+		for (let i = 0; i < length; i++) {
+			const component = abiParameter.components[i];
+			type += formatAbiParameter(component);
+			if (i < length - 1) type += ", ";
+		}
+		const result = execTyped(tupleRegex, abiParameter.type);
+		type += `)${result?.array || ""}`;
+		return formatAbiParameter({
+			...abiParameter,
+			type
+		});
+	}
+	if ("indexed" in abiParameter && abiParameter.indexed) type = `${type} indexed`;
+	if (abiParameter.name) return `${type} ${abiParameter.name}`;
+	return type;
+}
+//#endregion
+//#region node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.3.6/node_modules/abitype/dist/esm/human-readable/formatAbiParameters.js
+/**
+* Formats {@link AbiParameter}s to human-readable ABI parameters.
+*
+* @param abiParameters - ABI parameters
+* @returns Human-readable ABI parameters
+*
+* @example
+* const result = formatAbiParameters([
+*   //  ^? const result: 'address from, uint256 tokenId'
+*   { type: 'address', name: 'from' },
+*   { type: 'uint256', name: 'tokenId' },
+* ])
+*/
+function formatAbiParameters(abiParameters) {
+	let params = "";
+	const length = abiParameters.length;
+	for (let i = 0; i < length; i++) {
+		const abiParameter = abiParameters[i];
+		params += formatAbiParameter(abiParameter);
+		if (i !== length - 1) params += ", ";
+	}
+	return params;
+}
+//#endregion
+//#region node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.3.6/node_modules/abitype/dist/esm/human-readable/formatAbiItem.js
+/**
+* Formats ABI item (e.g. error, event, function) into human-readable ABI item
+*
+* @param abiItem - ABI item
+* @returns Human-readable ABI item
+*/
+function formatAbiItem(abiItem) {
+	if (abiItem.type === "function") return `function ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability && abiItem.stateMutability !== "nonpayable" ? ` ${abiItem.stateMutability}` : ""}${abiItem.outputs?.length ? ` returns (${formatAbiParameters(abiItem.outputs)})` : ""}`;
+	if (abiItem.type === "event") return `event ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
+	if (abiItem.type === "error") return `error ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
+	if (abiItem.type === "constructor") return `constructor(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability === "payable" ? " payable" : ""}`;
+	if (abiItem.type === "fallback") return `fallback() external${abiItem.stateMutability === "payable" ? " payable" : ""}`;
+	return "receive() external payable";
+}
+//#endregion
+//#region node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.3.6/node_modules/abitype/dist/esm/human-readable/runtime/signatures.js
+const errorSignatureRegex = /^error (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
+function isErrorSignature(signature) {
+	return errorSignatureRegex.test(signature);
+}
+function execErrorSignature(signature) {
+	return execTyped(errorSignatureRegex, signature);
+}
+const eventSignatureRegex = /^event (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
+function isEventSignature(signature) {
+	return eventSignatureRegex.test(signature);
+}
+function execEventSignature(signature) {
+	return execTyped(eventSignatureRegex, signature);
+}
+const functionSignatureRegex = /^function (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)(?: (?<scope>external|public{1}))?(?: (?<stateMutability>pure|view|nonpayable|payable{1}))?(?: returns\s?\((?<returns>.*?)\))?$/;
+function isFunctionSignature(signature) {
+	return functionSignatureRegex.test(signature);
+}
+function execFunctionSignature(signature) {
+	return execTyped(functionSignatureRegex, signature);
+}
+const structSignatureRegex = /^struct (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*) \{(?<properties>.*?)\}$/;
+function isStructSignature(signature) {
+	return structSignatureRegex.test(signature);
+}
+function execStructSignature(signature) {
+	return execTyped(structSignatureRegex, signature);
+}
+const constructorSignatureRegex = /^constructor\((?<parameters>.*?)\)(?:\s(?<stateMutability>payable{1}))?$/;
+function isConstructorSignature(signature) {
+	return constructorSignatureRegex.test(signature);
+}
+function execConstructorSignature(signature) {
+	return execTyped(constructorSignatureRegex, signature);
+}
+const fallbackSignatureRegex = /^fallback\(\) external(?:\s(?<stateMutability>payable{1}))?$/;
+function isFallbackSignature(signature) {
+	return fallbackSignatureRegex.test(signature);
+}
+function execFallbackSignature(signature) {
+	return execTyped(fallbackSignatureRegex, signature);
+}
+const receiveSignatureRegex = /^receive\(\) external payable$/;
+function isReceiveSignature(signature) {
+	return receiveSignatureRegex.test(signature);
+}
+const modifiers = new Set([
+	"memory",
+	"indexed",
+	"storage",
+	"calldata"
+]);
+const eventModifiers = new Set(["indexed"]);
+const functionModifiers = new Set([
+	"calldata",
+	"memory",
+	"storage"
+]);
+//#endregion
+//#region node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.3.6/node_modules/abitype/dist/esm/human-readable/errors/abiItem.js
+var UnknownTypeError = class extends BaseError$1 {
+	constructor({ type }) {
+		super("Unknown type.", { metaMessages: [`Type "${type}" is not a valid ABI type. Perhaps you forgot to include a struct signature?`] });
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "UnknownTypeError"
+		});
+	}
+};
+var UnknownSolidityTypeError = class extends BaseError$1 {
+	constructor({ type }) {
+		super("Unknown type.", { metaMessages: [`Type "${type}" is not a valid ABI type.`] });
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "UnknownSolidityTypeError"
+		});
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.3.6/node_modules/abitype/dist/esm/human-readable/errors/abiParameter.js
+var InvalidAbiParametersError = class extends BaseError$1 {
+	constructor({ params }) {
+		super("Failed to parse ABI parameters.", {
+			details: `parseAbiParameters(${JSON.stringify(params, null, 2)})`,
+			docsPath: "/api/human#parseabiparameters-1"
+		});
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "InvalidAbiParametersError"
+		});
+	}
+};
+var InvalidParameterError = class extends BaseError$1 {
+	constructor({ param }) {
+		super("Invalid ABI parameter.", { details: param });
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "InvalidParameterError"
+		});
+	}
+};
+var SolidityProtectedKeywordError = class extends BaseError$1 {
+	constructor({ param, name }) {
+		super("Invalid ABI parameter.", {
+			details: param,
+			metaMessages: [`"${name}" is a protected Solidity keyword. More info: https://docs.soliditylang.org/en/latest/cheatsheet.html`]
+		});
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "SolidityProtectedKeywordError"
+		});
+	}
+};
+var InvalidModifierError = class extends BaseError$1 {
+	constructor({ param, type, modifier }) {
+		super("Invalid ABI parameter.", {
+			details: param,
+			metaMessages: [`Modifier "${modifier}" not allowed${type ? ` in "${type}" type` : ""}.`]
+		});
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "InvalidModifierError"
+		});
+	}
+};
+var InvalidFunctionModifierError = class extends BaseError$1 {
+	constructor({ param, type, modifier }) {
+		super("Invalid ABI parameter.", {
+			details: param,
+			metaMessages: [`Modifier "${modifier}" not allowed${type ? ` in "${type}" type` : ""}.`, `Data location can only be specified for array, struct, or mapping types, but "${modifier}" was given.`]
+		});
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "InvalidFunctionModifierError"
+		});
+	}
+};
+var InvalidAbiTypeParameterError = class extends BaseError$1 {
+	constructor({ abiParameter }) {
+		super("Invalid ABI parameter.", {
+			details: JSON.stringify(abiParameter, null, 2),
+			metaMessages: ["ABI parameter type is invalid."]
+		});
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "InvalidAbiTypeParameterError"
+		});
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.3.6/node_modules/abitype/dist/esm/human-readable/errors/signature.js
+var InvalidSignatureError = class extends BaseError$1 {
+	constructor({ signature, type }) {
+		super(`Invalid ${type} signature.`, { details: signature });
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "InvalidSignatureError"
+		});
+	}
+};
+var UnknownSignatureError = class extends BaseError$1 {
+	constructor({ signature }) {
+		super("Unknown signature.", { details: signature });
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "UnknownSignatureError"
+		});
+	}
+};
+var InvalidStructSignatureError = class extends BaseError$1 {
+	constructor({ signature }) {
+		super("Invalid struct signature.", {
+			details: signature,
+			metaMessages: ["No properties exist."]
+		});
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "InvalidStructSignatureError"
+		});
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.3.6/node_modules/abitype/dist/esm/human-readable/errors/struct.js
+var CircularReferenceError = class extends BaseError$1 {
+	constructor({ type }) {
+		super("Circular reference detected.", { metaMessages: [`Struct "${type}" is a circular reference.`] });
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "CircularReferenceError"
+		});
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.3.6/node_modules/abitype/dist/esm/human-readable/errors/splitParameters.js
+var InvalidParenthesisError = class extends BaseError$1 {
+	constructor({ current, depth }) {
+		super("Unbalanced parentheses.", {
+			metaMessages: [`"${current.trim()}" has too many ${depth > 0 ? "opening" : "closing"} parentheses.`],
+			details: `Depth "${depth}"`
+		});
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "InvalidParenthesisError"
+		});
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.3.6/node_modules/abitype/dist/esm/human-readable/runtime/cache.js
+/**
+* Gets {@link parameterCache} cache key namespaced by {@link type} and {@link structs}. This prevents parameters from being accessible to types that don't allow them (e.g. `string indexed foo` not allowed outside of `type: 'event'`) and ensures different struct definitions with the same name are cached separately.
+* @param param ABI parameter string
+* @param type ABI parameter type
+* @param structs Struct definitions to include in cache key
+* @returns Cache key for {@link parameterCache}
+*/
+function getParameterCacheKey(param, type, structs) {
+	let structKey = "";
+	if (structs) for (const struct of Object.entries(structs)) {
+		if (!struct) continue;
+		let propertyKey = "";
+		for (const property of struct[1]) propertyKey += `[${property.type}${property.name ? `:${property.name}` : ""}]`;
+		structKey += `(${struct[0]}{${propertyKey}})`;
+	}
+	if (type) return `${type}:${param}${structKey}`;
+	return `${param}${structKey}`;
+}
+/**
+* Basic cache seeded with common ABI parameter strings.
+*
+* **Note: When seeding more parameters, make sure you benchmark performance. The current number is the ideal balance between performance and having an already existing cache.**
+*/
+const parameterCache = new Map([
+	["address", { type: "address" }],
+	["bool", { type: "bool" }],
+	["bytes", { type: "bytes" }],
+	["bytes32", { type: "bytes32" }],
+	["int", { type: "int256" }],
+	["int256", { type: "int256" }],
+	["string", { type: "string" }],
+	["uint", { type: "uint256" }],
+	["uint8", { type: "uint8" }],
+	["uint16", { type: "uint16" }],
+	["uint24", { type: "uint24" }],
+	["uint32", { type: "uint32" }],
+	["uint64", { type: "uint64" }],
+	["uint96", { type: "uint96" }],
+	["uint112", { type: "uint112" }],
+	["uint160", { type: "uint160" }],
+	["uint192", { type: "uint192" }],
+	["uint256", { type: "uint256" }],
+	["address owner", {
+		type: "address",
+		name: "owner"
+	}],
+	["address to", {
+		type: "address",
+		name: "to"
+	}],
+	["bool approved", {
+		type: "bool",
+		name: "approved"
+	}],
+	["bytes _data", {
+		type: "bytes",
+		name: "_data"
+	}],
+	["bytes data", {
+		type: "bytes",
+		name: "data"
+	}],
+	["bytes signature", {
+		type: "bytes",
+		name: "signature"
+	}],
+	["bytes32 hash", {
+		type: "bytes32",
+		name: "hash"
+	}],
+	["bytes32 r", {
+		type: "bytes32",
+		name: "r"
+	}],
+	["bytes32 root", {
+		type: "bytes32",
+		name: "root"
+	}],
+	["bytes32 s", {
+		type: "bytes32",
+		name: "s"
+	}],
+	["string name", {
+		type: "string",
+		name: "name"
+	}],
+	["string symbol", {
+		type: "string",
+		name: "symbol"
+	}],
+	["string tokenURI", {
+		type: "string",
+		name: "tokenURI"
+	}],
+	["uint tokenId", {
+		type: "uint256",
+		name: "tokenId"
+	}],
+	["uint8 v", {
+		type: "uint8",
+		name: "v"
+	}],
+	["uint256 balance", {
+		type: "uint256",
+		name: "balance"
+	}],
+	["uint256 tokenId", {
+		type: "uint256",
+		name: "tokenId"
+	}],
+	["uint256 value", {
+		type: "uint256",
+		name: "value"
+	}],
+	["event:address indexed from", {
+		type: "address",
+		name: "from",
+		indexed: true
+	}],
+	["event:address indexed to", {
+		type: "address",
+		name: "to",
+		indexed: true
+	}],
+	["event:uint indexed tokenId", {
+		type: "uint256",
+		name: "tokenId",
+		indexed: true
+	}],
+	["event:uint256 indexed tokenId", {
+		type: "uint256",
+		name: "tokenId",
+		indexed: true
+	}]
+]);
+//#endregion
+//#region node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.3.6/node_modules/abitype/dist/esm/human-readable/runtime/utils.js
+function parseSignature(signature, structs = {}) {
+	if (isFunctionSignature(signature)) return parseFunctionSignature(signature, structs);
+	if (isEventSignature(signature)) return parseEventSignature(signature, structs);
+	if (isErrorSignature(signature)) return parseErrorSignature(signature, structs);
+	if (isConstructorSignature(signature)) return parseConstructorSignature(signature, structs);
+	if (isFallbackSignature(signature)) return parseFallbackSignature(signature);
+	if (isReceiveSignature(signature)) return {
+		type: "receive",
+		stateMutability: "payable"
+	};
+	throw new UnknownSignatureError({ signature });
+}
+function parseFunctionSignature(signature, structs = {}) {
+	const match = execFunctionSignature(signature);
+	if (!match) throw new InvalidSignatureError({
+		signature,
+		type: "function"
+	});
+	const inputParams = splitParameters(match.parameters);
+	const inputs = [];
+	const inputLength = inputParams.length;
+	for (let i = 0; i < inputLength; i++) inputs.push(parseAbiParameter(inputParams[i], {
+		modifiers: functionModifiers,
+		structs,
+		type: "function"
+	}));
+	const outputs = [];
+	if (match.returns) {
+		const outputParams = splitParameters(match.returns);
+		const outputLength = outputParams.length;
+		for (let i = 0; i < outputLength; i++) outputs.push(parseAbiParameter(outputParams[i], {
+			modifiers: functionModifiers,
+			structs,
+			type: "function"
+		}));
+	}
+	return {
+		name: match.name,
+		type: "function",
+		stateMutability: match.stateMutability ?? "nonpayable",
+		inputs,
+		outputs
+	};
+}
+function parseEventSignature(signature, structs = {}) {
+	const match = execEventSignature(signature);
+	if (!match) throw new InvalidSignatureError({
+		signature,
+		type: "event"
+	});
+	const params = splitParameters(match.parameters);
+	const abiParameters = [];
+	const length = params.length;
+	for (let i = 0; i < length; i++) abiParameters.push(parseAbiParameter(params[i], {
+		modifiers: eventModifiers,
+		structs,
+		type: "event"
+	}));
+	return {
+		name: match.name,
+		type: "event",
+		inputs: abiParameters
+	};
+}
+function parseErrorSignature(signature, structs = {}) {
+	const match = execErrorSignature(signature);
+	if (!match) throw new InvalidSignatureError({
+		signature,
+		type: "error"
+	});
+	const params = splitParameters(match.parameters);
+	const abiParameters = [];
+	const length = params.length;
+	for (let i = 0; i < length; i++) abiParameters.push(parseAbiParameter(params[i], {
+		structs,
+		type: "error"
+	}));
+	return {
+		name: match.name,
+		type: "error",
+		inputs: abiParameters
+	};
+}
+function parseConstructorSignature(signature, structs = {}) {
+	const match = execConstructorSignature(signature);
+	if (!match) throw new InvalidSignatureError({
+		signature,
+		type: "constructor"
+	});
+	const params = splitParameters(match.parameters);
+	const abiParameters = [];
+	const length = params.length;
+	for (let i = 0; i < length; i++) abiParameters.push(parseAbiParameter(params[i], {
+		structs,
+		type: "constructor"
+	}));
+	return {
+		type: "constructor",
+		stateMutability: match.stateMutability ?? "nonpayable",
+		inputs: abiParameters
+	};
+}
+function parseFallbackSignature(signature) {
+	const match = execFallbackSignature(signature);
+	if (!match) throw new InvalidSignatureError({
+		signature,
+		type: "fallback"
+	});
+	return {
+		type: "fallback",
+		stateMutability: match.stateMutability ?? "nonpayable"
+	};
+}
+const abiParameterWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*(?:\spayable)?)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
+const abiParameterWithTupleRegex = /^\((?<type>.+?)\)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
+const dynamicIntegerRegex = /^u?int$/;
+function parseAbiParameter(param, options) {
+	const parameterCacheKey = getParameterCacheKey(param, options?.type, options?.structs);
+	if (parameterCache.has(parameterCacheKey)) return parameterCache.get(parameterCacheKey);
+	const isTuple = isTupleRegex.test(param);
+	const match = execTyped(isTuple ? abiParameterWithTupleRegex : abiParameterWithoutTupleRegex, param);
+	if (!match) throw new InvalidParameterError({ param });
+	if (match.name && isSolidityKeyword(match.name)) throw new SolidityProtectedKeywordError({
+		param,
+		name: match.name
+	});
+	const name = match.name ? { name: match.name } : {};
+	const indexed = match.modifier === "indexed" ? { indexed: true } : {};
+	const structs = options?.structs ?? {};
+	let type;
+	let components = {};
+	if (isTuple) {
+		type = "tuple";
+		const params = splitParameters(match.type);
+		const components_ = [];
+		const length = params.length;
+		for (let i = 0; i < length; i++) components_.push(parseAbiParameter(params[i], { structs }));
+		components = { components: components_ };
+	} else if (match.type in structs) {
+		type = "tuple";
+		components = { components: structs[match.type] };
+	} else if (dynamicIntegerRegex.test(match.type)) type = `${match.type}256`;
+	else if (match.type === "address payable") type = "address";
+	else {
+		type = match.type;
+		if (!(options?.type === "struct") && !isSolidityType(type)) throw new UnknownSolidityTypeError({ type });
+	}
+	if (match.modifier) {
+		if (!options?.modifiers?.has?.(match.modifier)) throw new InvalidModifierError({
+			param,
+			type: options?.type,
+			modifier: match.modifier
+		});
+		if (functionModifiers.has(match.modifier) && !isValidDataLocation(type, !!match.array)) throw new InvalidFunctionModifierError({
+			param,
+			type: options?.type,
+			modifier: match.modifier
+		});
+	}
+	const abiParameter = {
+		type: `${type}${match.array ?? ""}`,
+		...name,
+		...indexed,
+		...components
+	};
+	parameterCache.set(parameterCacheKey, abiParameter);
+	return abiParameter;
+}
+function splitParameters(params, result = [], current = "", depth = 0) {
+	const length = params.trim().length;
+	for (let i = 0; i < length; i++) {
+		const char = params[i];
+		const tail = params.slice(i + 1);
+		switch (char) {
+			case ",": return depth === 0 ? splitParameters(tail, [...result, current.trim()]) : splitParameters(tail, result, `${current}${char}`, depth);
+			case "(": return splitParameters(tail, result, `${current}${char}`, depth + 1);
+			case ")": return splitParameters(tail, result, `${current}${char}`, depth - 1);
+			default: return splitParameters(tail, result, `${current}${char}`, depth);
+		}
+	}
+	if (current === "") return result;
+	if (depth !== 0) throw new InvalidParenthesisError({
+		current,
+		depth
+	});
+	result.push(current.trim());
+	return result;
+}
+function isSolidityType(type) {
+	return type === "address" || type === "bool" || type === "function" || type === "string" || bytesRegex.test(type) || integerRegex.test(type);
+}
+const protectedKeywordsRegex = /^(?:after|alias|anonymous|apply|auto|byte|calldata|case|catch|constant|copyof|default|defined|error|event|external|false|final|function|immutable|implements|in|indexed|inline|internal|let|mapping|match|memory|mutable|null|of|override|partial|private|promise|public|pure|reference|relocatable|return|returns|sizeof|static|storage|struct|super|supports|switch|this|true|try|typedef|typeof|var|view|virtual)$/;
+/** @internal */
+function isSolidityKeyword(name) {
+	return name === "address" || name === "bool" || name === "function" || name === "string" || name === "tuple" || bytesRegex.test(name) || integerRegex.test(name) || protectedKeywordsRegex.test(name);
+}
+/** @internal */
+function isValidDataLocation(type, isArray) {
+	return isArray || type === "bytes" || type === "string" || type === "tuple";
+}
+//#endregion
+//#region node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.3.6/node_modules/abitype/dist/esm/human-readable/runtime/structs.js
+function parseStructs(signatures) {
+	const shallowStructs = {};
+	const signaturesLength = signatures.length;
+	for (let i = 0; i < signaturesLength; i++) {
+		const signature = signatures[i];
+		if (!isStructSignature(signature)) continue;
+		const match = execStructSignature(signature);
+		if (!match) throw new InvalidSignatureError({
+			signature,
+			type: "struct"
+		});
+		const properties = match.properties.split(";");
+		const components = [];
+		const propertiesLength = properties.length;
+		for (let k = 0; k < propertiesLength; k++) {
+			const trimmed = properties[k].trim();
+			if (!trimmed) continue;
+			const abiParameter = parseAbiParameter(trimmed, { type: "struct" });
+			components.push(abiParameter);
+		}
+		if (!components.length) throw new InvalidStructSignatureError({ signature });
+		shallowStructs[match.name] = components;
+	}
+	const resolvedStructs = {};
+	const entries = Object.entries(shallowStructs);
+	const entriesLength = entries.length;
+	for (let i = 0; i < entriesLength; i++) {
+		const [name, parameters] = entries[i];
+		resolvedStructs[name] = resolveStructs(parameters, shallowStructs);
+	}
+	return resolvedStructs;
+}
+const typeWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?$/;
+function resolveStructs(abiParameters = [], structs = {}, ancestors = /* @__PURE__ */ new Set()) {
+	const components = [];
+	const length = abiParameters.length;
+	for (let i = 0; i < length; i++) {
+		const abiParameter = abiParameters[i];
+		if (isTupleRegex.test(abiParameter.type)) components.push(abiParameter);
+		else {
+			const match = execTyped(typeWithoutTupleRegex, abiParameter.type);
+			if (!match?.type) throw new InvalidAbiTypeParameterError({ abiParameter });
+			const { array, type } = match;
+			if (type in structs) {
+				if (ancestors.has(type)) throw new CircularReferenceError({ type });
+				components.push({
+					...abiParameter,
+					type: `tuple${array ?? ""}`,
+					components: resolveStructs(structs[type], structs, new Set([...ancestors, type]))
+				});
+			} else if (isSolidityType(type)) components.push(abiParameter);
+			else throw new UnknownTypeError({ type });
+		}
+	}
+	return components;
+}
+//#endregion
+//#region node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.3.6/node_modules/abitype/dist/esm/human-readable/parseAbi.js
+/**
+* Parses human-readable ABI into JSON {@link Abi}
+*
+* @param signatures - Human-Readable ABI
+* @returns Parsed {@link Abi}
+*
+* @example
+* const abi = parseAbi([
+*   //  ^? const abi: readonly [{ name: "balanceOf"; type: "function"; stateMutability:...
+*   'function balanceOf(address owner) view returns (uint256)',
+*   'event Transfer(address indexed from, address indexed to, uint256 amount)',
+* ])
+*/
+function parseAbi(signatures) {
+	const structs = parseStructs(signatures);
+	const abi = [];
+	const length = signatures.length;
+	for (let i = 0; i < length; i++) {
+		const signature = signatures[i];
+		if (isStructSignature(signature)) continue;
+		abi.push(parseSignature(signature, structs));
+	}
+	return abi;
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/hash/hashSignature.js
+const hash = (value) => keccak256(toBytes$1(value));
+function hashSignature(sig) {
+	return hash(sig);
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/hash/normalizeSignature.js
+function normalizeSignature(signature) {
+	let active = true;
+	let current = "";
+	let level = 0;
+	let result = "";
+	let valid = false;
+	for (let i = 0; i < signature.length; i++) {
+		const char = signature[i];
+		if ([
+			"(",
+			")",
+			","
+		].includes(char)) active = true;
+		if (char === "(") level++;
+		if (char === ")") level--;
+		if (!active) continue;
+		if (level === 0) {
+			if (char === " " && [
+				"event",
+				"function",
+				""
+			].includes(result)) result = "";
+			else {
+				result += char;
+				if (char === ")") {
+					valid = true;
+					break;
+				}
+			}
+			continue;
+		}
+		if (char === " ") {
+			if (signature[i - 1] !== "," && current !== "," && current !== ",(") {
+				current = "";
+				active = false;
+			}
+			continue;
+		}
+		result += char;
+		current += char;
+	}
+	if (!valid) throw new BaseError$2("Unable to normalize signature.");
+	return result;
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/hash/toSignature.js
+/**
+* Returns the signature for a given function or event definition.
+*
+* @example
+* const signature = toSignature('function ownerOf(uint256 tokenId)')
+* // 'ownerOf(uint256)'
+*
+* @example
+* const signature_3 = toSignature({
+*   name: 'ownerOf',
+*   type: 'function',
+*   inputs: [{ name: 'tokenId', type: 'uint256' }],
+*   outputs: [],
+*   stateMutability: 'view',
+* })
+* // 'ownerOf(uint256)'
+*/
+const toSignature = (def) => {
+	return normalizeSignature((() => {
+		if (typeof def === "string") return def;
+		return formatAbiItem(def);
+	})());
+};
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/hash/toSignatureHash.js
+/**
+* Returns the hash (of the function/event signature) for a given event or function definition.
+*/
+function toSignatureHash(fn) {
+	return hashSignature(toSignature(fn));
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/hash/toEventSelector.js
+/**
+* Returns the event selector for a given event definition.
+*
+* @example
+* const selector = toEventSelector('Transfer(address indexed from, address indexed to, uint256 amount)')
+* // 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef
+*/
+const toEventSelector = toSignatureHash;
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/hash/toFunctionSelector.js
+/**
+* Returns the function selector for a given function definition.
+*
+* @example
+* const selector = toFunctionSelector('function ownerOf(uint256 tokenId)')
+* // 0x6352211e
+*/
+const toFunctionSelector = (fn) => slice$2(toSignatureHash(fn), 0, 4);
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/abi/getAbiItem.js
+function getAbiItem(parameters) {
+	const { abi, args = [], name } = parameters;
+	const isSelector = isHex(name, { strict: false });
+	const abiItems = abi.filter((abiItem) => {
+		if (isSelector) {
+			if (abiItem.type === "function") return toFunctionSelector(abiItem) === name;
+			if (abiItem.type === "event") return toEventSelector(abiItem) === name;
+			return false;
+		}
+		return "name" in abiItem && abiItem.name === name;
+	});
+	if (abiItems.length === 0) return void 0;
+	if (abiItems.length === 1) return abiItems[0];
+	let matchedAbiItem;
+	for (const abiItem of abiItems) {
+		if (!("inputs" in abiItem)) continue;
+		if (!args || args.length === 0) {
+			if (!abiItem.inputs || abiItem.inputs.length === 0) return abiItem;
+			continue;
+		}
+		if (!abiItem.inputs) continue;
+		if (abiItem.inputs.length === 0) continue;
+		if (abiItem.inputs.length !== args.length) continue;
+		if (args.every((arg, index) => {
+			const abiParameter = "inputs" in abiItem && abiItem.inputs[index];
+			if (!abiParameter) return false;
+			return isArgOfType(arg, abiParameter);
+		})) {
+			if (matchedAbiItem && "inputs" in matchedAbiItem && matchedAbiItem.inputs) {
+				const ambiguousTypes = getAmbiguousTypes(abiItem.inputs, matchedAbiItem.inputs, args);
+				if (ambiguousTypes) throw new AbiItemAmbiguityError({
+					abiItem,
+					type: ambiguousTypes[0]
+				}, {
+					abiItem: matchedAbiItem,
+					type: ambiguousTypes[1]
+				});
+			}
+			matchedAbiItem = abiItem;
+		}
+	}
+	if (matchedAbiItem) return matchedAbiItem;
+	return abiItems[0];
+}
+/** @internal */
+function isArgOfType(arg, abiParameter) {
+	const argType = typeof arg;
+	const abiParameterType = abiParameter.type;
+	switch (abiParameterType) {
+		case "address": return isAddress(arg, { strict: false });
+		case "bool": return argType === "boolean";
+		case "function": return argType === "string";
+		case "string": return argType === "string";
+		default:
+			if (abiParameterType === "tuple" && "components" in abiParameter) return Object.values(abiParameter.components).every((component, index) => {
+				return argType === "object" && isArgOfType(Object.values(arg)[index], component);
+			});
+			if (/^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/.test(abiParameterType)) return argType === "number" || argType === "bigint";
+			if (/^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/.test(abiParameterType)) return argType === "string" || arg instanceof Uint8Array;
+			if (/[a-z]+[1-9]{0,3}(\[[0-9]{0,}\])+$/.test(abiParameterType)) return Array.isArray(arg) && arg.every((x) => isArgOfType(x, {
+				...abiParameter,
+				type: abiParameterType.replace(/(\[[0-9]{0,}\])$/, "")
+			}));
+			return false;
+	}
+}
+/** @internal */
+function getAmbiguousTypes(sourceParameters, targetParameters, args) {
+	for (const parameterIndex in sourceParameters) {
+		const sourceParameter = sourceParameters[parameterIndex];
+		const targetParameter = targetParameters[parameterIndex];
+		if (sourceParameter.type === "tuple" && targetParameter.type === "tuple" && "components" in sourceParameter && "components" in targetParameter) return getAmbiguousTypes(sourceParameter.components, targetParameter.components, args[parameterIndex]);
+		const types = [sourceParameter.type, targetParameter.type];
+		if ((() => {
+			if (types.includes("address") && types.includes("bytes20")) return true;
+			if (types.includes("address") && types.includes("string")) return isAddress(args[parameterIndex], { strict: false });
+			if (types.includes("address") && types.includes("bytes")) return isAddress(args[parameterIndex], { strict: false });
+			return false;
+		})()) return types;
+	}
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/abi/prepareEncodeFunctionData.js
+const docsPath$2 = "/docs/contract/encodeFunctionData";
+function prepareEncodeFunctionData(parameters) {
+	const { abi, args, functionName } = parameters;
+	let abiItem = abi[0];
+	if (functionName) {
+		const item = getAbiItem({
+			abi,
+			args,
+			name: functionName
+		});
+		if (!item) throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath$2 });
+		abiItem = item;
+	}
+	if (abiItem.type !== "function") throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath$2 });
+	return {
+		abi: [abiItem],
+		functionName: toFunctionSelector(formatAbiItem$1(abiItem))
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/abi/encodeFunctionData.js
+function encodeFunctionData(parameters) {
+	const { args } = parameters;
+	const { abi, functionName } = (() => {
+		if (parameters.abi.length === 1 && parameters.functionName?.startsWith("0x")) return parameters;
+		return prepareEncodeFunctionData(parameters);
+	})();
+	const abiItem = abi[0];
+	return concatHex([functionName, ("inputs" in abiItem && abiItem.inputs ? encodeAbiParameters(abiItem.inputs, args ?? []) : void 0) ?? "0x"]);
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/constants/solidity.js
+const panicReasons = {
+	1: "An `assert` condition failed.",
+	17: "Arithmetic operation resulted in underflow or overflow.",
+	18: "Division or modulo by zero (e.g. `5 / 0` or `23 % 0`).",
+	33: "Attempted to convert to an invalid type.",
+	34: "Attempted to access a storage byte array that is incorrectly encoded.",
+	49: "Performed `.pop()` on an empty array",
+	50: "Array index is out of bounds.",
+	65: "Allocated too much memory or created an array which is too large.",
+	81: "Attempted to call a zero-initialized variable of internal function type."
+};
+const solidityError = {
+	inputs: [{
+		name: "message",
+		type: "string"
+	}],
+	name: "Error",
+	type: "error"
+};
+const solidityPanic = {
+	inputs: [{
+		name: "reason",
+		type: "uint256"
+	}],
+	name: "Panic",
+	type: "error"
+};
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/encoding/fromBytes.js
+/**
+* Decodes a byte array into a bigint.
+*
+* - Docs: https://viem.sh/docs/utilities/fromBytes#bytestobigint
+*
+* @param bytes Byte array to decode.
+* @param opts Options.
+* @returns BigInt value.
+*
+* @example
+* import { bytesToBigInt } from 'viem'
+* const data = bytesToBigInt(new Uint8Array([1, 164]))
+* // 420n
+*/
+function bytesToBigInt(bytes, opts = {}) {
+	if (typeof opts.size !== "undefined") assertSize$2(bytes, { size: opts.size });
+	return hexToBigInt(bytesToHex(bytes, opts), opts);
+}
+/**
+* Decodes a byte array into a boolean.
+*
+* - Docs: https://viem.sh/docs/utilities/fromBytes#bytestobool
+*
+* @param bytes Byte array to decode.
+* @param opts Options.
+* @returns Boolean value.
+*
+* @example
+* import { bytesToBool } from 'viem'
+* const data = bytesToBool(new Uint8Array([1]))
+* // true
+*/
+function bytesToBool(bytes_, opts = {}) {
+	let bytes = bytes_;
+	if (typeof opts.size !== "undefined") {
+		assertSize$2(bytes, { size: opts.size });
+		bytes = trim$2(bytes);
+	}
+	if (bytes.length > 1 || bytes[0] > 1) throw new InvalidBytesBooleanError$1(bytes);
+	return Boolean(bytes[0]);
+}
+/**
+* Decodes a byte array into a number.
+*
+* - Docs: https://viem.sh/docs/utilities/fromBytes#bytestonumber
+*
+* @param bytes Byte array to decode.
+* @param opts Options.
+* @returns Number value.
+*
+* @example
+* import { bytesToNumber } from 'viem'
+* const data = bytesToNumber(new Uint8Array([1, 164]))
+* // 420
+*/
+function bytesToNumber(bytes, opts = {}) {
+	if (typeof opts.size !== "undefined") assertSize$2(bytes, { size: opts.size });
+	return hexToNumber(bytesToHex(bytes, opts), opts);
+}
+/**
+* Decodes a byte array into a UTF-8 string.
+*
+* - Docs: https://viem.sh/docs/utilities/fromBytes#bytestostring
+*
+* @param bytes Byte array to decode.
+* @param opts Options.
+* @returns String value.
+*
+* @example
+* import { bytesToString } from 'viem'
+* const data = bytesToString(new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]))
+* // 'Hello world'
+*/
+function bytesToString(bytes_, opts = {}) {
+	let bytes = bytes_;
+	if (typeof opts.size !== "undefined") {
+		assertSize$2(bytes, { size: opts.size });
+		bytes = trim$2(bytes, { dir: "right" });
+	}
+	return new TextDecoder().decode(bytes);
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/abi/decodeAbiParameters.js
+function decodeAbiParameters(params, data) {
+	const bytes = typeof data === "string" ? hexToBytes(data) : data;
+	const cursor = createCursor(bytes);
+	if (size$2(bytes) === 0 && params.length > 0) throw new AbiDecodingZeroDataError();
+	if (size$2(data) && size$2(data) < 32) throw new AbiDecodingDataSizeTooSmallError({
+		data: typeof data === "string" ? data : bytesToHex(data),
+		params,
+		size: size$2(data)
+	});
+	let consumed = 0;
+	const values = [];
+	for (let i = 0; i < params.length; ++i) {
+		const param = params[i];
+		cursor.setPosition(consumed);
+		const [data, consumed_] = decodeParameter(cursor, param, { staticPosition: 0 });
+		consumed += consumed_;
+		values.push(data);
+	}
+	return values;
+}
+function decodeParameter(cursor, param, { staticPosition }) {
+	const arrayComponents = getArrayComponents(param.type);
+	if (arrayComponents) {
+		const [length, type] = arrayComponents;
+		return decodeArray(cursor, {
+			...param,
+			type
+		}, {
+			length,
+			staticPosition
+		});
+	}
+	if (param.type === "tuple") return decodeTuple(cursor, param, { staticPosition });
+	if (param.type === "address") return decodeAddress(cursor);
+	if (param.type === "bool") return decodeBool(cursor);
+	if (param.type.startsWith("bytes")) return decodeBytes(cursor, param, { staticPosition });
+	if (param.type.startsWith("uint") || param.type.startsWith("int")) return decodeNumber(cursor, param);
+	if (param.type === "string") return decodeString(cursor, { staticPosition });
+	throw new InvalidAbiDecodingTypeError(param.type, { docsPath: "/docs/contract/decodeAbiParameters" });
+}
+const sizeOfLength = 32;
+const sizeOfOffset = 32;
+function decodeAddress(cursor) {
+	return [checksumAddress(bytesToHex(sliceBytes(cursor.readBytes(32), -20))), 32];
+}
+function decodeArray(cursor, param, { length, staticPosition }) {
+	if (!length) {
+		const start = staticPosition + bytesToNumber(cursor.readBytes(sizeOfOffset));
+		const startOfData = start + sizeOfLength;
+		cursor.setPosition(start);
+		const length = bytesToNumber(cursor.readBytes(sizeOfLength));
+		const dynamicChild = hasDynamicChild(param);
+		let consumed = 0;
+		const value = [];
+		for (let i = 0; i < length; ++i) {
+			cursor.setPosition(startOfData + (dynamicChild ? i * 32 : consumed));
+			const [data, consumed_] = decodeParameter(cursor, param, { staticPosition: startOfData });
+			consumed += consumed_;
+			value.push(data);
+		}
+		cursor.setPosition(staticPosition + 32);
+		return [value, 32];
+	}
+	if (hasDynamicChild(param)) {
+		const start = staticPosition + bytesToNumber(cursor.readBytes(sizeOfOffset));
+		const value = [];
+		for (let i = 0; i < length; ++i) {
+			cursor.setPosition(start + i * 32);
+			const [data] = decodeParameter(cursor, param, { staticPosition: start });
+			value.push(data);
+		}
+		cursor.setPosition(staticPosition + 32);
+		return [value, 32];
+	}
+	let consumed = 0;
+	const value = [];
+	for (let i = 0; i < length; ++i) {
+		const [data, consumed_] = decodeParameter(cursor, param, { staticPosition: staticPosition + consumed });
+		consumed += consumed_;
+		value.push(data);
+	}
+	return [value, consumed];
+}
+function decodeBool(cursor) {
+	return [bytesToBool(cursor.readBytes(32), { size: 32 }), 32];
+}
+function decodeBytes(cursor, param, { staticPosition }) {
+	const [_, size] = param.type.split("bytes");
+	if (!size) {
+		const offset = bytesToNumber(cursor.readBytes(32));
+		cursor.setPosition(staticPosition + offset);
+		const length = bytesToNumber(cursor.readBytes(32));
+		if (length === 0) {
+			cursor.setPosition(staticPosition + 32);
+			return ["0x", 32];
+		}
+		const data = cursor.readBytes(length);
+		cursor.setPosition(staticPosition + 32);
+		return [bytesToHex(data), 32];
+	}
+	return [bytesToHex(cursor.readBytes(Number.parseInt(size, 10), 32)), 32];
+}
+function decodeNumber(cursor, param) {
+	const signed = param.type.startsWith("int");
+	const size = Number.parseInt(param.type.split("int")[1] || "256", 10);
+	const value = cursor.readBytes(32);
+	return [size > 48 ? bytesToBigInt(value, { signed }) : bytesToNumber(value, { signed }), 32];
+}
+function decodeTuple(cursor, param, { staticPosition }) {
+	const hasUnnamedChild = param.components.length === 0 || param.components.some(({ name }) => !name);
+	const value = hasUnnamedChild ? [] : {};
+	let consumed = 0;
+	if (hasDynamicChild(param)) {
+		const start = staticPosition + bytesToNumber(cursor.readBytes(sizeOfOffset));
+		for (let i = 0; i < param.components.length; ++i) {
+			const component = param.components[i];
+			cursor.setPosition(start + consumed);
+			const [data, consumed_] = decodeParameter(cursor, component, { staticPosition: start });
+			consumed += consumed_;
+			value[hasUnnamedChild ? i : component?.name] = data;
+		}
+		cursor.setPosition(staticPosition + 32);
+		return [value, 32];
+	}
+	for (let i = 0; i < param.components.length; ++i) {
+		const component = param.components[i];
+		const [data, consumed_] = decodeParameter(cursor, component, { staticPosition });
+		value[hasUnnamedChild ? i : component?.name] = data;
+		consumed += consumed_;
+	}
+	return [value, consumed];
+}
+function decodeString(cursor, { staticPosition }) {
+	const start = staticPosition + bytesToNumber(cursor.readBytes(32));
+	cursor.setPosition(start);
+	const length = bytesToNumber(cursor.readBytes(32));
+	if (length === 0) {
+		cursor.setPosition(staticPosition + 32);
+		return ["", 32];
+	}
+	const value = bytesToString(trim$2(cursor.readBytes(length, 32)));
+	cursor.setPosition(staticPosition + 32);
+	return [value, 32];
+}
+function hasDynamicChild(param) {
+	const { type } = param;
+	if (type === "string") return true;
+	if (type === "bytes") return true;
+	if (type.endsWith("[]")) return true;
+	if (type === "tuple") return param.components?.some(hasDynamicChild);
+	const arrayComponents = getArrayComponents(param.type);
+	if (arrayComponents && hasDynamicChild({
+		...param,
+		type: arrayComponents[1]
+	})) return true;
+	return false;
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/abi/decodeErrorResult.js
+function decodeErrorResult(parameters) {
+	const { abi, data, cause } = parameters;
+	const signature = slice$2(data, 0, 4);
+	if (signature === "0x") throw new AbiDecodingZeroDataError({ cause });
+	const abiItem = [
+		...abi || [],
+		solidityError,
+		solidityPanic
+	].find((x) => x.type === "error" && signature === toFunctionSelector(formatAbiItem$1(x)));
+	if (!abiItem) throw new AbiErrorSignatureNotFoundError(signature, {
+		docsPath: "/docs/contract/decodeErrorResult",
+		cause
+	});
+	return {
+		abiItem,
+		args: "inputs" in abiItem && abiItem.inputs && abiItem.inputs.length > 0 ? decodeAbiParameters(abiItem.inputs, slice$2(data, 4)) : void 0,
+		errorName: abiItem.name
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/abi/formatAbiItemWithArgs.js
+function formatAbiItemWithArgs({ abiItem, args, includeFunctionName = true, includeName = false }) {
+	if (!("name" in abiItem)) return;
+	if (!("inputs" in abiItem)) return;
+	if (!abiItem.inputs) return;
+	return `${includeFunctionName ? abiItem.name : ""}(${abiItem.inputs.map((input, i) => `${includeName && input.name ? `${input.name}: ` : ""}${typeof args[i] === "object" ? stringify$1(args[i]) : args[i]}`).join(", ")})`;
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/errors/stateOverride.js
+var AccountStateConflictError = class extends BaseError$2 {
+	constructor({ address }) {
+		super(`State for account "${address}" is set multiple times.`, { name: "AccountStateConflictError" });
+	}
+};
+var StateAssignmentConflictError = class extends BaseError$2 {
+	constructor() {
+		super("state and stateDiff are set on the same account.", { name: "StateAssignmentConflictError" });
+	}
+};
+/** @internal */
+function prettyStateMapping(stateMapping) {
+	return stateMapping.reduce((pretty, { slot, value }) => {
+		return `${pretty}        ${slot}: ${value}\n`;
+	}, "");
+}
+function prettyStateOverride(stateOverride) {
+	return stateOverride.reduce((pretty, { address, ...state }) => {
+		let val = `${pretty}    ${address}:\n`;
+		if (state.nonce) val += `      nonce: ${state.nonce}\n`;
+		if (state.balance) val += `      balance: ${state.balance}\n`;
+		if (state.code) val += `      code: ${state.code}\n`;
+		if (state.state) {
+			val += "      state:\n";
+			val += prettyStateMapping(state.state);
+		}
+		if (state.stateDiff) {
+			val += "      stateDiff:\n";
+			val += prettyStateMapping(state.stateDiff);
+		}
+		return val;
+	}, "  State Override:\n").slice(0, -1);
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/errors/utils.js
+const getContractAddress = (address) => address;
+const getUrl = (url) => url;
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/errors/contract.js
+var CallExecutionError = class extends BaseError$2 {
+	constructor(cause, { account: account_, docsPath, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, stateOverride }) {
+		let prettyArgs = prettyPrint({
+			from: (account_ ? parseAccount(account_) : void 0)?.address,
+			to,
+			value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency?.symbol || "ETH"}`,
+			data,
+			gas,
+			gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
+			maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
+			maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
+			nonce
+		});
+		if (stateOverride) prettyArgs += `\n${prettyStateOverride(stateOverride)}`;
+		super(cause.shortMessage, {
+			cause,
+			docsPath,
+			metaMessages: [
+				...cause.metaMessages ? [...cause.metaMessages, " "] : [],
+				"Raw Call Arguments:",
+				prettyArgs
+			].filter(Boolean),
+			name: "CallExecutionError"
+		});
+		Object.defineProperty(this, "cause", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		this.cause = cause;
+	}
+};
+var ContractFunctionExecutionError = class extends BaseError$2 {
+	constructor(cause, { abi, args, contractAddress, docsPath, functionName, sender }) {
+		const abiItem = getAbiItem({
+			abi,
+			args,
+			name: functionName
+		});
+		const formattedArgs = abiItem ? formatAbiItemWithArgs({
+			abiItem,
+			args,
+			includeFunctionName: false,
+			includeName: false
+		}) : void 0;
+		const functionWithParams = abiItem ? formatAbiItem$1(abiItem, { includeName: true }) : void 0;
+		const prettyArgs = prettyPrint({
+			address: contractAddress && getContractAddress(contractAddress),
+			function: functionWithParams,
+			args: formattedArgs && formattedArgs !== "()" && `${[...Array(functionName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}`,
+			sender
+		});
+		super(cause.shortMessage || `An unknown error occurred while executing the contract function "${functionName}".`, {
+			cause,
+			docsPath,
+			metaMessages: [
+				...cause.metaMessages ? [...cause.metaMessages, " "] : [],
+				prettyArgs && "Contract Call:",
+				prettyArgs
+			].filter(Boolean),
+			name: "ContractFunctionExecutionError"
+		});
+		Object.defineProperty(this, "abi", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "args", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "cause", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "contractAddress", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "formattedArgs", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "functionName", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "sender", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		this.abi = abi;
+		this.args = args;
+		this.cause = cause;
+		this.contractAddress = contractAddress;
+		this.functionName = functionName;
+		this.sender = sender;
+	}
+};
+var ContractFunctionRevertedError = class extends BaseError$2 {
+	constructor({ abi, data, functionName, message, cause: error }) {
+		let cause;
+		let decodedData;
+		let metaMessages;
+		let reason;
+		if (data && data !== "0x") try {
+			decodedData = decodeErrorResult({
+				abi,
+				data,
+				cause: error
+			});
+			const { abiItem, errorName, args: errorArgs } = decodedData;
+			if (errorName === "Error") reason = errorArgs[0];
+			else if (errorName === "Panic") {
+				const [firstArg] = errorArgs;
+				reason = panicReasons[firstArg];
+			} else {
+				const errorWithParams = abiItem ? formatAbiItem$1(abiItem, { includeName: true }) : void 0;
+				const formattedArgs = abiItem && errorArgs ? formatAbiItemWithArgs({
+					abiItem,
+					args: errorArgs,
+					includeFunctionName: false,
+					includeName: false
+				}) : void 0;
+				metaMessages = [errorWithParams ? `Error: ${errorWithParams}` : "", formattedArgs && formattedArgs !== "()" ? `       ${[...Array(errorName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}` : ""];
+			}
+		} catch (err) {
+			cause = err;
+		}
+		else if (message) reason = message;
+		let signature;
+		if (cause instanceof AbiErrorSignatureNotFoundError) {
+			signature = cause.signature;
+			metaMessages = [
+				`Unable to decode signature "${signature}" as it was not found on the provided ABI.`,
+				"Make sure you are using the correct ABI and that the error exists on it.",
+				`You can look up the decoded signature here: https://4byte.sourcify.dev/?q=${signature}.`
+			];
+		}
+		super(reason && reason !== "execution reverted" || signature ? [`The contract function "${functionName}" reverted with the following ${signature ? "signature" : "reason"}:`, reason || signature].join("\n") : `The contract function "${functionName}" reverted.`, {
+			cause: cause ?? error,
+			metaMessages,
+			name: "ContractFunctionRevertedError"
+		});
+		Object.defineProperty(this, "data", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "raw", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "reason", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "signature", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		this.data = decodedData;
+		this.raw = data;
+		this.reason = reason;
+		this.signature = signature;
+	}
+};
+var ContractFunctionZeroDataError = class extends BaseError$2 {
+	constructor({ functionName, cause }) {
+		super(`The contract function "${functionName}" returned no data ("0x").`, {
+			metaMessages: [
+				"This could be due to any of the following:",
+				`  - The contract does not have the function "${functionName}",`,
+				"  - The parameters passed to the contract function may be invalid, or",
+				"  - The address is not a contract."
+			],
+			name: "ContractFunctionZeroDataError",
+			cause
+		});
+	}
+};
+var CounterfactualDeploymentFailedError = class extends BaseError$2 {
+	constructor({ factory }) {
+		super(`Deployment for counterfactual contract call failed${factory ? ` for factory "${factory}".` : ""}`, {
+			metaMessages: [
+				"Please ensure:",
+				"- The `factory` is a valid contract deployment factory (ie. Create2 Factory, ERC-4337 Factory, etc).",
+				"- The `factoryData` is a valid encoded function call for contract deployment function on the factory."
+			],
+			name: "CounterfactualDeploymentFailedError"
+		});
+	}
+};
+var RawContractError = class extends BaseError$2 {
+	constructor({ data, message }) {
+		super(message || "", { name: "RawContractError" });
+		Object.defineProperty(this, "code", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: 3
+		});
+		Object.defineProperty(this, "data", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		this.data = data;
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/errors/request.js
+var HttpRequestError = class extends BaseError$2 {
+	constructor({ body, cause, details, headers, status, url }) {
+		super("HTTP request failed.", {
+			cause,
+			details,
+			metaMessages: [
+				status && `Status: ${status}`,
+				`URL: ${getUrl(url)}`,
+				body && `Request body: ${stringify$1(body)}`
+			].filter(Boolean),
+			name: "HttpRequestError"
+		});
+		Object.defineProperty(this, "body", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "headers", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "status", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "url", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		this.body = body;
+		this.headers = headers;
+		this.status = status;
+		this.url = url;
+	}
+};
+var RpcRequestError = class extends BaseError$2 {
+	constructor({ body, error, url }) {
+		super("RPC Request failed.", {
+			cause: error,
+			details: error.message,
+			metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify$1(body)}`],
+			name: "RpcRequestError"
+		});
+		Object.defineProperty(this, "code", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "data", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "url", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		this.code = error.code;
+		this.data = error.data;
+		this.url = url;
+	}
+};
+var TimeoutError = class extends BaseError$2 {
+	constructor({ body, url }) {
+		super("The request took too long to respond.", {
+			details: "The request timed out.",
+			metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify$1(body)}`],
+			name: "TimeoutError"
+		});
+		Object.defineProperty(this, "url", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		this.url = url;
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/errors/rpc.js
+const unknownErrorCode = -1;
+var RpcError = class extends BaseError$2 {
+	constructor(cause, { code, docsPath, metaMessages, name, shortMessage }) {
+		super(shortMessage, {
+			cause,
+			docsPath,
+			metaMessages: metaMessages || cause?.metaMessages,
+			name: name || "RpcError"
+		});
+		Object.defineProperty(this, "code", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		this.name = name || cause.name;
+		this.code = cause instanceof RpcRequestError ? cause.code : code ?? unknownErrorCode;
+	}
+};
+var ProviderRpcError = class extends RpcError {
+	constructor(cause, options) {
+		super(cause, options);
+		Object.defineProperty(this, "data", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		this.data = options.data;
+	}
+};
+var ParseRpcError = class ParseRpcError extends RpcError {
+	constructor(cause) {
+		super(cause, {
+			code: ParseRpcError.code,
+			name: "ParseRpcError",
+			shortMessage: "Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text."
+		});
+	}
+};
+Object.defineProperty(ParseRpcError, "code", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: -32700
+});
+var InvalidRequestRpcError = class InvalidRequestRpcError extends RpcError {
+	constructor(cause) {
+		super(cause, {
+			code: InvalidRequestRpcError.code,
+			name: "InvalidRequestRpcError",
+			shortMessage: "JSON is not a valid request object."
+		});
+	}
+};
+Object.defineProperty(InvalidRequestRpcError, "code", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: -32600
+});
+var MethodNotFoundRpcError = class MethodNotFoundRpcError extends RpcError {
+	constructor(cause, { method } = {}) {
+		super(cause, {
+			code: MethodNotFoundRpcError.code,
+			name: "MethodNotFoundRpcError",
+			shortMessage: `The method${method ? ` "${method}"` : ""} does not exist / is not available.`
+		});
+	}
+};
+Object.defineProperty(MethodNotFoundRpcError, "code", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: -32601
+});
+var InvalidParamsRpcError = class InvalidParamsRpcError extends RpcError {
+	constructor(cause) {
+		super(cause, {
+			code: InvalidParamsRpcError.code,
+			name: "InvalidParamsRpcError",
+			shortMessage: ["Invalid parameters were provided to the RPC method.", "Double check you have provided the correct parameters."].join("\n")
+		});
+	}
+};
+Object.defineProperty(InvalidParamsRpcError, "code", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: -32602
+});
+var InternalRpcError = class InternalRpcError extends RpcError {
+	constructor(cause) {
+		super(cause, {
+			code: InternalRpcError.code,
+			name: "InternalRpcError",
+			shortMessage: "An internal error was received."
+		});
+	}
+};
+Object.defineProperty(InternalRpcError, "code", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: -32603
+});
+var InvalidInputRpcError = class InvalidInputRpcError extends RpcError {
+	constructor(cause) {
+		super(cause, {
+			code: InvalidInputRpcError.code,
+			name: "InvalidInputRpcError",
+			shortMessage: ["Missing or invalid parameters.", "Double check you have provided the correct parameters."].join("\n")
+		});
+	}
+};
+Object.defineProperty(InvalidInputRpcError, "code", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: -32e3
+});
+var ResourceNotFoundRpcError = class ResourceNotFoundRpcError extends RpcError {
+	constructor(cause) {
+		super(cause, {
+			code: ResourceNotFoundRpcError.code,
+			name: "ResourceNotFoundRpcError",
+			shortMessage: "Requested resource not found."
+		});
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "ResourceNotFoundRpcError"
+		});
+	}
+};
+Object.defineProperty(ResourceNotFoundRpcError, "code", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: -32001
+});
+var ResourceUnavailableRpcError = class ResourceUnavailableRpcError extends RpcError {
+	constructor(cause) {
+		super(cause, {
+			code: ResourceUnavailableRpcError.code,
+			name: "ResourceUnavailableRpcError",
+			shortMessage: "Requested resource not available."
+		});
+	}
+};
+Object.defineProperty(ResourceUnavailableRpcError, "code", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: -32002
+});
+var TransactionRejectedRpcError = class TransactionRejectedRpcError extends RpcError {
+	constructor(cause) {
+		super(cause, {
+			code: TransactionRejectedRpcError.code,
+			name: "TransactionRejectedRpcError",
+			shortMessage: "Transaction creation failed."
+		});
+	}
+};
+Object.defineProperty(TransactionRejectedRpcError, "code", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: -32003
+});
+var MethodNotSupportedRpcError = class MethodNotSupportedRpcError extends RpcError {
+	constructor(cause, { method } = {}) {
+		super(cause, {
+			code: MethodNotSupportedRpcError.code,
+			name: "MethodNotSupportedRpcError",
+			shortMessage: `Method${method ? ` "${method}"` : ""} is not supported.`
+		});
+	}
+};
+Object.defineProperty(MethodNotSupportedRpcError, "code", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: -32004
+});
+var LimitExceededRpcError = class LimitExceededRpcError extends RpcError {
+	constructor(cause) {
+		super(cause, {
+			code: LimitExceededRpcError.code,
+			name: "LimitExceededRpcError",
+			shortMessage: "Request exceeds defined limit."
+		});
+	}
+};
+Object.defineProperty(LimitExceededRpcError, "code", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: -32005
+});
+var JsonRpcVersionUnsupportedError = class JsonRpcVersionUnsupportedError extends RpcError {
+	constructor(cause) {
+		super(cause, {
+			code: JsonRpcVersionUnsupportedError.code,
+			name: "JsonRpcVersionUnsupportedError",
+			shortMessage: "Version of JSON-RPC protocol is not supported."
+		});
+	}
+};
+Object.defineProperty(JsonRpcVersionUnsupportedError, "code", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: -32006
+});
+var UserRejectedRequestError = class UserRejectedRequestError extends ProviderRpcError {
+	constructor(cause) {
+		super(cause, {
+			code: UserRejectedRequestError.code,
+			name: "UserRejectedRequestError",
+			shortMessage: "User rejected the request."
+		});
+	}
+};
+Object.defineProperty(UserRejectedRequestError, "code", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: 4001
+});
+var UnauthorizedProviderError = class UnauthorizedProviderError extends ProviderRpcError {
+	constructor(cause) {
+		super(cause, {
+			code: UnauthorizedProviderError.code,
+			name: "UnauthorizedProviderError",
+			shortMessage: "The requested method and/or account has not been authorized by the user."
+		});
+	}
+};
+Object.defineProperty(UnauthorizedProviderError, "code", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: 4100
+});
+var UnsupportedProviderMethodError = class UnsupportedProviderMethodError extends ProviderRpcError {
+	constructor(cause, { method } = {}) {
+		super(cause, {
+			code: UnsupportedProviderMethodError.code,
+			name: "UnsupportedProviderMethodError",
+			shortMessage: `The Provider does not support the requested method${method ? ` " ${method}"` : ""}.`
+		});
+	}
+};
+Object.defineProperty(UnsupportedProviderMethodError, "code", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: 4200
+});
+var ProviderDisconnectedError = class ProviderDisconnectedError extends ProviderRpcError {
+	constructor(cause) {
+		super(cause, {
+			code: ProviderDisconnectedError.code,
+			name: "ProviderDisconnectedError",
+			shortMessage: "The Provider is disconnected from all chains."
+		});
+	}
+};
+Object.defineProperty(ProviderDisconnectedError, "code", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: 4900
+});
+var ChainDisconnectedError = class ChainDisconnectedError extends ProviderRpcError {
+	constructor(cause) {
+		super(cause, {
+			code: ChainDisconnectedError.code,
+			name: "ChainDisconnectedError",
+			shortMessage: "The Provider is not connected to the requested chain."
+		});
+	}
+};
+Object.defineProperty(ChainDisconnectedError, "code", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: 4901
+});
+var SwitchChainError = class SwitchChainError extends ProviderRpcError {
+	constructor(cause) {
+		super(cause, {
+			code: SwitchChainError.code,
+			name: "SwitchChainError",
+			shortMessage: "An error occurred when attempting to switch chain."
+		});
+	}
+};
+Object.defineProperty(SwitchChainError, "code", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: 4902
+});
+var UnsupportedNonOptionalCapabilityError = class UnsupportedNonOptionalCapabilityError extends ProviderRpcError {
+	constructor(cause) {
+		super(cause, {
+			code: UnsupportedNonOptionalCapabilityError.code,
+			name: "UnsupportedNonOptionalCapabilityError",
+			shortMessage: "This Wallet does not support a capability that was not marked as optional."
+		});
+	}
+};
+Object.defineProperty(UnsupportedNonOptionalCapabilityError, "code", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: 5700
+});
+var UnsupportedChainIdError = class UnsupportedChainIdError extends ProviderRpcError {
+	constructor(cause) {
+		super(cause, {
+			code: UnsupportedChainIdError.code,
+			name: "UnsupportedChainIdError",
+			shortMessage: "This Wallet does not support the requested chain ID."
+		});
+	}
+};
+Object.defineProperty(UnsupportedChainIdError, "code", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: 5710
+});
+var DuplicateIdError = class DuplicateIdError extends ProviderRpcError {
+	constructor(cause) {
+		super(cause, {
+			code: DuplicateIdError.code,
+			name: "DuplicateIdError",
+			shortMessage: "There is already a bundle submitted with this ID."
+		});
+	}
+};
+Object.defineProperty(DuplicateIdError, "code", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: 5720
+});
+var UnknownBundleIdError = class UnknownBundleIdError extends ProviderRpcError {
+	constructor(cause) {
+		super(cause, {
+			code: UnknownBundleIdError.code,
+			name: "UnknownBundleIdError",
+			shortMessage: "This bundle id is unknown / has not been submitted"
+		});
+	}
+};
+Object.defineProperty(UnknownBundleIdError, "code", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: 5730
+});
+var BundleTooLargeError = class BundleTooLargeError extends ProviderRpcError {
+	constructor(cause) {
+		super(cause, {
+			code: BundleTooLargeError.code,
+			name: "BundleTooLargeError",
+			shortMessage: "The call bundle is too large for the Wallet to process."
+		});
+	}
+};
+Object.defineProperty(BundleTooLargeError, "code", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: 5740
+});
+var AtomicReadyWalletRejectedUpgradeError = class AtomicReadyWalletRejectedUpgradeError extends ProviderRpcError {
+	constructor(cause) {
+		super(cause, {
+			code: AtomicReadyWalletRejectedUpgradeError.code,
+			name: "AtomicReadyWalletRejectedUpgradeError",
+			shortMessage: "The Wallet can support atomicity after an upgrade, but the user rejected the upgrade."
+		});
+	}
+};
+Object.defineProperty(AtomicReadyWalletRejectedUpgradeError, "code", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: 5750
+});
+var AtomicityNotSupportedError = class AtomicityNotSupportedError extends ProviderRpcError {
+	constructor(cause) {
+		super(cause, {
+			code: AtomicityNotSupportedError.code,
+			name: "AtomicityNotSupportedError",
+			shortMessage: "The wallet does not support atomic execution but the request requires it."
+		});
+	}
+};
+Object.defineProperty(AtomicityNotSupportedError, "code", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: 5760
+});
+var WalletConnectSessionSettlementError = class WalletConnectSessionSettlementError extends ProviderRpcError {
+	constructor(cause) {
+		super(cause, {
+			code: WalletConnectSessionSettlementError.code,
+			name: "WalletConnectSessionSettlementError",
+			shortMessage: "WalletConnect session settlement failed."
+		});
+	}
+};
+Object.defineProperty(WalletConnectSessionSettlementError, "code", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: 7e3
+});
+var UnknownRpcError = class extends RpcError {
+	constructor(cause) {
+		super(cause, {
+			name: "UnknownRpcError",
+			shortMessage: "An unknown RPC error occurred."
+		});
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/errors/getNodeError.js
+function getNodeError(err, args) {
+	const message = (err.details || "").toLowerCase();
+	const executionRevertedError = err instanceof BaseError$2 ? err.walk((e) => e?.code === ExecutionRevertedError.code) : err;
+	if (executionRevertedError instanceof BaseError$2) return new ExecutionRevertedError({
+		cause: err,
+		message: executionRevertedError.details
+	});
+	if (ExecutionRevertedError.nodeMessage.test(message)) return new ExecutionRevertedError({
+		cause: err,
+		message: err.details
+	});
+	if (FeeCapTooHighError.nodeMessage.test(message)) return new FeeCapTooHighError({
+		cause: err,
+		maxFeePerGas: args?.maxFeePerGas
+	});
+	if (FeeCapTooLowError.nodeMessage.test(message)) return new FeeCapTooLowError({
+		cause: err,
+		maxFeePerGas: args?.maxFeePerGas
+	});
+	if (NonceTooHighError.nodeMessage.test(message)) return new NonceTooHighError({
+		cause: err,
+		nonce: args?.nonce
+	});
+	if (NonceTooLowError.nodeMessage.test(message)) return new NonceTooLowError({
+		cause: err,
+		nonce: args?.nonce
+	});
+	if (NonceMaxValueError.nodeMessage.test(message)) return new NonceMaxValueError({
+		cause: err,
+		nonce: args?.nonce
+	});
+	if (InsufficientFundsError.nodeMessage.test(message)) return new InsufficientFundsError({ cause: err });
+	if (IntrinsicGasTooHighError.nodeMessage.test(message)) return new IntrinsicGasTooHighError({
+		cause: err,
+		gas: args?.gas
+	});
+	if (IntrinsicGasTooLowError.nodeMessage.test(message)) return new IntrinsicGasTooLowError({
+		cause: err,
+		gas: args?.gas
+	});
+	if (TransactionTypeNotSupportedError.nodeMessage.test(message)) return new TransactionTypeNotSupportedError({ cause: err });
+	if (TipAboveFeeCapError.nodeMessage.test(message)) return new TipAboveFeeCapError({
+		cause: err,
+		maxFeePerGas: args?.maxFeePerGas,
+		maxPriorityFeePerGas: args?.maxPriorityFeePerGas
+	});
+	return new UnknownNodeError({ cause: err });
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/formatters/extract.js
+/**
+* @description Picks out the keys from `value` that exist in the formatter..
+*/
+function extract(value_, { format }) {
+	if (!format) return {};
+	const value = {};
+	function extract_(formatted) {
+		const keys = Object.keys(formatted);
+		for (const key of keys) {
+			if (key in value_) value[key] = value_[key];
+			if (formatted[key] && typeof formatted[key] === "object" && !Array.isArray(formatted[key])) extract_(formatted[key]);
+		}
+	}
+	extract_(format(value_ || {}));
+	return value;
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/formatters/formatter.js
+function defineFormatter(type, format) {
+	return ({ exclude, format: overrides }) => {
+		return {
+			exclude,
+			format: (args, action) => {
+				const formatted = format(args, action);
+				if (exclude) for (const key of exclude) delete formatted[key];
+				return {
+					...formatted,
+					...overrides(args, action)
+				};
+			},
+			type
+		};
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/formatters/transactionRequest.js
+const rpcTransactionType = {
+	legacy: "0x0",
+	eip2930: "0x1",
+	eip1559: "0x2",
+	eip4844: "0x3",
+	eip7702: "0x4"
+};
+function formatTransactionRequest(request, _) {
+	const rpcRequest = {};
+	if (typeof request.authorizationList !== "undefined") rpcRequest.authorizationList = formatAuthorizationList(request.authorizationList);
+	if (typeof request.accessList !== "undefined") rpcRequest.accessList = request.accessList;
+	if (typeof request.blobVersionedHashes !== "undefined") rpcRequest.blobVersionedHashes = request.blobVersionedHashes;
+	if (typeof request.blobs !== "undefined") if (typeof request.blobs[0] !== "string") rpcRequest.blobs = request.blobs.map((x) => bytesToHex(x));
+	else rpcRequest.blobs = request.blobs;
+	if (typeof request.data !== "undefined") rpcRequest.data = request.data;
+	if (request.account) rpcRequest.from = request.account.address;
+	if (typeof request.from !== "undefined") rpcRequest.from = request.from;
+	if (typeof request.gas !== "undefined") rpcRequest.gas = numberToHex(request.gas);
+	if (typeof request.gasPrice !== "undefined") rpcRequest.gasPrice = numberToHex(request.gasPrice);
+	if (typeof request.maxFeePerBlobGas !== "undefined") rpcRequest.maxFeePerBlobGas = numberToHex(request.maxFeePerBlobGas);
+	if (typeof request.maxFeePerGas !== "undefined") rpcRequest.maxFeePerGas = numberToHex(request.maxFeePerGas);
+	if (typeof request.maxPriorityFeePerGas !== "undefined") rpcRequest.maxPriorityFeePerGas = numberToHex(request.maxPriorityFeePerGas);
+	if (typeof request.nonce !== "undefined") rpcRequest.nonce = numberToHex(request.nonce);
+	if (typeof request.to !== "undefined") rpcRequest.to = request.to;
+	if (typeof request.type !== "undefined") rpcRequest.type = rpcTransactionType[request.type];
+	if (typeof request.value !== "undefined") rpcRequest.value = numberToHex(request.value);
+	return rpcRequest;
+}
+const defineTransactionRequest = /* @__PURE__ */ defineFormatter("transactionRequest", formatTransactionRequest);
+function formatAuthorizationList(authorizationList) {
+	return authorizationList.map((authorization) => ({
+		address: authorization.address,
+		r: authorization.r ? numberToHex(BigInt(authorization.r)) : authorization.r,
+		s: authorization.s ? numberToHex(BigInt(authorization.s)) : authorization.s,
+		chainId: numberToHex(authorization.chainId),
+		nonce: numberToHex(authorization.nonce),
+		...typeof authorization.yParity !== "undefined" ? { yParity: numberToHex(authorization.yParity) } : {},
+		...typeof authorization.v !== "undefined" && typeof authorization.yParity === "undefined" ? { v: numberToHex(authorization.v) } : {}
+	}));
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/stateOverride.js
+/** @internal */
+function serializeStateMapping(stateMapping) {
+	if (!stateMapping || stateMapping.length === 0) return void 0;
+	return stateMapping.reduce((acc, { slot, value }) => {
+		if (slot.length !== 66) throw new InvalidBytesLengthError({
+			size: slot.length,
+			targetSize: 66,
+			type: "hex"
+		});
+		if (value.length !== 66) throw new InvalidBytesLengthError({
+			size: value.length,
+			targetSize: 66,
+			type: "hex"
+		});
+		acc[slot] = value;
+		return acc;
+	}, {});
+}
+/** @internal */
+function serializeAccountStateOverride(parameters) {
+	const { balance, nonce, state, stateDiff, code } = parameters;
+	const rpcAccountStateOverride = {};
+	if (code !== void 0) rpcAccountStateOverride.code = code;
+	if (balance !== void 0) rpcAccountStateOverride.balance = numberToHex(balance);
+	if (nonce !== void 0) rpcAccountStateOverride.nonce = numberToHex(nonce);
+	if (state !== void 0) rpcAccountStateOverride.state = serializeStateMapping(state);
+	if (stateDiff !== void 0) {
+		if (rpcAccountStateOverride.state) throw new StateAssignmentConflictError();
+		rpcAccountStateOverride.stateDiff = serializeStateMapping(stateDiff);
+	}
+	return rpcAccountStateOverride;
+}
+/** @internal */
+function serializeStateOverride(parameters) {
+	if (!parameters) return void 0;
+	const rpcStateOverride = {};
+	for (const { address, ...accountState } of parameters) {
+		if (!isAddress(address, { strict: false })) throw new InvalidAddressError({ address });
+		if (rpcStateOverride[address]) throw new AccountStateConflictError({ address });
+		rpcStateOverride[address] = serializeAccountStateOverride(accountState);
+	}
+	return rpcStateOverride;
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/transaction/assertRequest.js
+function assertRequest(args) {
+	const { account: account_, maxFeePerGas, maxPriorityFeePerGas, to } = args;
+	const account = account_ ? parseAccount(account_) : void 0;
+	if (account && !isAddress(account.address)) throw new InvalidAddressError({ address: account.address });
+	if (to && !isAddress(to)) throw new InvalidAddressError({ address: to });
+	if (maxFeePerGas && maxFeePerGas > maxUint256) throw new FeeCapTooHighError({ maxFeePerGas });
+	if (maxPriorityFeePerGas && maxFeePerGas && maxPriorityFeePerGas > maxFeePerGas) throw new TipAboveFeeCapError({
+		maxFeePerGas,
+		maxPriorityFeePerGas
+	});
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/abi/decodeFunctionResult.js
+const docsPath$1 = "/docs/contract/decodeFunctionResult";
+function decodeFunctionResult(parameters) {
+	const { abi, args, functionName, data } = parameters;
+	let abiItem = abi[0];
+	if (functionName) {
+		const item = getAbiItem({
+			abi,
+			args,
+			name: functionName
+		});
+		if (!item) throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath$1 });
+		abiItem = item;
+	}
+	if (abiItem.type !== "function") throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath$1 });
+	if (!abiItem.outputs) throw new AbiFunctionOutputsNotFoundError(abiItem.name, { docsPath: docsPath$1 });
+	const values = decodeAbiParameters(abiItem.outputs, data);
+	if (values && values.length > 1) return values;
+	if (values && values.length === 1) return values[0];
+}
+//#endregion
+//#region node_modules/.pnpm/ox@0.14.7_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/core/version.js
+/** @internal */
+const version = "0.1.1";
+//#endregion
+//#region node_modules/.pnpm/ox@0.14.7_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/core/internal/errors.js
+/** @internal */
+function getVersion() {
+	return version;
+}
+//#endregion
+//#region node_modules/.pnpm/ox@0.14.7_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/core/Errors.js
+/**
+* Base error class inherited by all errors thrown by ox.
+*
+* @example
+* ```ts
+* import { Errors } from 'ox'
+* throw new Errors.BaseError('An error occurred')
+* ```
+*/
+var BaseError = class BaseError extends Error {
+	static setStaticOptions(options) {
+		BaseError.prototype.docsOrigin = options.docsOrigin;
+		BaseError.prototype.showVersion = options.showVersion;
+		BaseError.prototype.version = options.version;
+	}
+	constructor(shortMessage, options = {}) {
+		const details = (() => {
+			if (options.cause instanceof BaseError) {
+				if (options.cause.details) return options.cause.details;
+				if (options.cause.shortMessage) return options.cause.shortMessage;
+			}
+			if (options.cause && "details" in options.cause && typeof options.cause.details === "string") return options.cause.details;
+			if (options.cause?.message) return options.cause.message;
+			return options.details;
+		})();
+		const docsPath = (() => {
+			if (options.cause instanceof BaseError) return options.cause.docsPath || options.docsPath;
+			return options.docsPath;
+		})();
+		const docsBaseUrl = options.docsOrigin ?? BaseError.prototype.docsOrigin;
+		const docs = `${docsBaseUrl}${docsPath ?? ""}`;
+		const showVersion = Boolean(options.version ?? BaseError.prototype.showVersion);
+		const version = options.version ?? BaseError.prototype.version;
+		const message = [
+			shortMessage || "An error occurred.",
+			...options.metaMessages ? ["", ...options.metaMessages] : [],
+			...details || docsPath || showVersion ? [
+				"",
+				details ? `Details: ${details}` : void 0,
+				docsPath ? `See: ${docs}` : void 0,
+				showVersion ? `Version: ${version}` : void 0
+			] : []
+		].filter((x) => typeof x === "string").join("\n");
+		super(message, options.cause ? { cause: options.cause } : void 0);
+		Object.defineProperty(this, "details", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "docs", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "docsOrigin", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "docsPath", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "shortMessage", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "showVersion", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "version", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "cause", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "BaseError"
+		});
+		this.cause = options.cause;
+		this.details = details;
+		this.docs = docs;
+		this.docsOrigin = docsBaseUrl;
+		this.docsPath = docsPath;
+		this.shortMessage = shortMessage;
+		this.showVersion = showVersion;
+		this.version = version;
+	}
+	walk(fn) {
+		return walk(this, fn);
+	}
+};
+Object.defineProperty(BaseError, "defaultStaticOptions", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: {
+		docsOrigin: "https://oxlib.sh",
+		showVersion: false,
+		version: `ox@${getVersion()}`
+	}
+});
+BaseError.setStaticOptions(BaseError.defaultStaticOptions);
+/** @internal */
+function walk(err, fn) {
+	if (fn?.(err)) return err;
+	if (err && typeof err === "object" && "cause" in err && err.cause) return walk(err.cause, fn);
+	return fn ? null : err;
+}
+//#endregion
+//#region node_modules/.pnpm/ox@0.14.7_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/core/internal/bytes.js
+/** @internal */
+function assertSize$1(bytes, size_) {
+	if (size$1(bytes) > size_) throw new SizeOverflowError$1({
+		givenSize: size$1(bytes),
+		maxSize: size_
+	});
+}
+/** @internal */
+function assertStartOffset$1(value, start) {
+	if (typeof start === "number" && start > 0 && start > size$1(value) - 1) throw new SliceOffsetOutOfBoundsError$1({
+		offset: start,
+		position: "start",
+		size: size$1(value)
+	});
+}
+/** @internal */
+function assertEndOffset$1(value, start, end) {
+	if (typeof start === "number" && typeof end === "number" && size$1(value) !== end - start) throw new SliceOffsetOutOfBoundsError$1({
+		offset: end,
+		position: "end",
+		size: size$1(value)
+	});
+}
+/** @internal */
+const charCodeMap = {
+	zero: 48,
+	nine: 57,
+	A: 65,
+	F: 70,
+	a: 97,
+	f: 102
+};
+/** @internal */
+function charCodeToBase16(char) {
+	if (char >= charCodeMap.zero && char <= charCodeMap.nine) return char - charCodeMap.zero;
+	if (char >= charCodeMap.A && char <= charCodeMap.F) return char - (charCodeMap.A - 10);
+	if (char >= charCodeMap.a && char <= charCodeMap.f) return char - (charCodeMap.a - 10);
+}
+/** @internal */
+function pad$1(bytes, options = {}) {
+	const { dir, size = 32 } = options;
+	if (size === 0) return bytes;
+	if (bytes.length > size) throw new SizeExceedsPaddingSizeError$1({
+		size: bytes.length,
+		targetSize: size,
+		type: "Bytes"
+	});
+	const paddedBytes = new Uint8Array(size);
+	for (let i = 0; i < size; i++) {
+		const padEnd = dir === "right";
+		paddedBytes[padEnd ? i : size - i - 1] = bytes[padEnd ? i : bytes.length - i - 1];
+	}
+	return paddedBytes;
+}
+/** @internal */
+function trim$1(value, options = {}) {
+	const { dir = "left" } = options;
+	let data = value;
+	let sliceLength = 0;
+	for (let i = 0; i < data.length - 1; i++) if (data[dir === "left" ? i : data.length - i - 1].toString() === "0") sliceLength++;
+	else break;
+	data = dir === "left" ? data.slice(sliceLength) : data.slice(0, data.length - sliceLength);
+	return data;
+}
+//#endregion
+//#region node_modules/.pnpm/ox@0.14.7_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/core/internal/hex.js
+/** @internal */
+function assertSize(hex, size_) {
+	if (size(hex) > size_) throw new SizeOverflowError({
+		givenSize: size(hex),
+		maxSize: size_
+	});
+}
+/** @internal */
+function assertStartOffset(value, start) {
+	if (typeof start === "number" && start > 0 && start > size(value) - 1) throw new SliceOffsetOutOfBoundsError({
+		offset: start,
+		position: "start",
+		size: size(value)
+	});
+}
+/** @internal */
+function assertEndOffset(value, start, end) {
+	if (typeof start === "number" && typeof end === "number" && size(value) !== end - start) throw new SliceOffsetOutOfBoundsError({
+		offset: end,
+		position: "end",
+		size: size(value)
+	});
+}
+/** @internal */
+function pad(hex_, options = {}) {
+	const { dir, size = 32 } = options;
+	if (size === 0) return hex_;
+	const hex = hex_.replace("0x", "");
+	if (hex.length > size * 2) throw new SizeExceedsPaddingSizeError({
+		size: Math.ceil(hex.length / 2),
+		targetSize: size,
+		type: "Hex"
+	});
+	return `0x${hex[dir === "right" ? "padEnd" : "padStart"](size * 2, "0")}`;
+}
+/** @internal */
+function trim(value, options = {}) {
+	const { dir = "left" } = options;
+	let data = value.replace("0x", "");
+	let sliceLength = 0;
+	for (let i = 0; i < data.length - 1; i++) if (data[dir === "left" ? i : data.length - i - 1].toString() === "0") sliceLength++;
+	else break;
+	data = dir === "left" ? data.slice(sliceLength) : data.slice(0, data.length - sliceLength);
+	if (data === "0") return "0x";
+	if (dir === "right" && data.length % 2 === 1) return `0x${data}0`;
+	return `0x${data}`;
+}
+//#endregion
+//#region node_modules/.pnpm/ox@0.14.7_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/core/Json.js
+const bigIntSuffix = "#__bigint";
+/**
+* Stringifies a value to its JSON representation, with support for `bigint`.
+*
+* @example
+* ```ts twoslash
+* import { Json } from 'ox'
+*
+* const json = Json.stringify({
+*   foo: 'bar',
+*   baz: 69420694206942069420694206942069420694206942069420n,
+* })
+* // @log: '{"foo":"bar","baz":"69420694206942069420694206942069420694206942069420#__bigint"}'
+* ```
+*
+* @param value - The value to stringify.
+* @param replacer - A function that transforms the results. It is passed the key and value of the property, and must return the value to be used in the JSON string. If this function returns `undefined`, the property is not included in the resulting JSON string.
+* @param space - A string or number that determines the indentation of the JSON string. If it is a number, it indicates the number of spaces to use as indentation; if it is a string (e.g. `'\t'`), it uses the string as the indentation character.
+* @returns The JSON string.
+*/
+function stringify(value, replacer, space) {
+	return JSON.stringify(value, (key, value) => {
+		if (typeof replacer === "function") return replacer(key, value);
+		if (typeof value === "bigint") return value.toString() + bigIntSuffix;
+		return value;
+	}, space);
+}
+//#endregion
+//#region node_modules/.pnpm/ox@0.14.7_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/core/Bytes.js
+const decoder = /* @__PURE__ */ new TextDecoder();
+const encoder$1 = /* @__PURE__ */ new TextEncoder();
+/**
+* Asserts if the given value is {@link ox#Bytes.Bytes}.
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* Bytes.assert('abc')
+* // @error: Bytes.InvalidBytesTypeError:
+* // @error: Value `"abc"` of type `string` is an invalid Bytes value.
+* // @error: Bytes values must be of type `Uint8Array`.
+* ```
+*
+* @param value - Value to assert.
+*/
+function assert$1(value) {
+	if (value instanceof Uint8Array) return;
+	if (!value) throw new InvalidBytesTypeError(value);
+	if (typeof value !== "object") throw new InvalidBytesTypeError(value);
+	if (!("BYTES_PER_ELEMENT" in value)) throw new InvalidBytesTypeError(value);
+	if (value.BYTES_PER_ELEMENT !== 1 || value.constructor.name !== "Uint8Array") throw new InvalidBytesTypeError(value);
+}
+/**
+* Concatenates two or more {@link ox#Bytes.Bytes}.
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* const bytes = Bytes.concat(
+*   Bytes.from([1]),
+*   Bytes.from([69]),
+*   Bytes.from([420, 69]),
+* )
+* // @log: Uint8Array [ 1, 69, 420, 69 ]
+* ```
+*
+* @param values - Values to concatenate.
+* @returns Concatenated {@link ox#Bytes.Bytes}.
+*/
+function concat$1(...values) {
+	let length = 0;
+	for (const arr of values) length += arr.length;
+	const result = new Uint8Array(length);
+	for (let i = 0, index = 0; i < values.length; i++) {
+		const arr = values[i];
+		result.set(arr, index);
+		index += arr.length;
+	}
+	return result;
+}
+/**
+* Instantiates a {@link ox#Bytes.Bytes} value from a `Uint8Array`, a hex string, or an array of unsigned 8-bit integers.
+*
+* :::tip
+*
+* To instantiate from a **Boolean**, **String**, or **Number**, use one of the following:
+*
+* - `Bytes.fromBoolean`
+*
+* - `Bytes.fromString`
+*
+* - `Bytes.fromNumber`
+*
+* :::
+*
+* @example
+* ```ts twoslash
+* // @noErrors
+* import { Bytes } from 'ox'
+*
+* const data = Bytes.from([255, 124, 5, 4])
+* // @log: Uint8Array([255, 124, 5, 4])
+*
+* const data = Bytes.from('0xdeadbeef')
+* // @log: Uint8Array([222, 173, 190, 239])
+* ```
+*
+* @param value - Value to convert.
+* @returns A {@link ox#Bytes.Bytes} instance.
+*/
+function from$1(value) {
+	if (value instanceof Uint8Array) return value;
+	if (typeof value === "string") return fromHex(value);
+	return fromArray(value);
+}
+/**
+* Converts an array of unsigned 8-bit integers into {@link ox#Bytes.Bytes}.
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* const data = Bytes.fromArray([255, 124, 5, 4])
+* // @log: Uint8Array([255, 124, 5, 4])
+* ```
+*
+* @param value - Value to convert.
+* @returns A {@link ox#Bytes.Bytes} instance.
+*/
+function fromArray(value) {
+	return value instanceof Uint8Array ? value : new Uint8Array(value);
+}
+/**
+* Encodes a {@link ox#Hex.Hex} value into {@link ox#Bytes.Bytes}.
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* const data = Bytes.fromHex('0x48656c6c6f20776f726c6421')
+* // @log: Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33])
+* ```
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* const data = Bytes.fromHex('0x48656c6c6f20776f726c6421', { size: 32 })
+* // @log: Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+* ```
+*
+* @param value - {@link ox#Hex.Hex} value to encode.
+* @param options - Encoding options.
+* @returns Encoded {@link ox#Bytes.Bytes}.
+*/
+function fromHex(value, options = {}) {
+	const { size } = options;
+	let hex = value;
+	if (size) {
+		assertSize(value, size);
+		hex = padRight(value, size);
+	}
+	let hexString = hex.slice(2);
+	if (hexString.length % 2) hexString = `0${hexString}`;
+	const length = hexString.length / 2;
+	const bytes = new Uint8Array(length);
+	for (let index = 0, j = 0; index < length; index++) {
+		const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
+		const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
+		if (nibbleLeft === void 0 || nibbleRight === void 0) throw new BaseError(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
+		bytes[index] = nibbleLeft << 4 | nibbleRight;
+	}
+	return bytes;
+}
+/**
+* Encodes a string into {@link ox#Bytes.Bytes}.
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* const data = Bytes.fromString('Hello world!')
+* // @log: Uint8Array([72, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 33])
+* ```
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* const data = Bytes.fromString('Hello world!', { size: 32 })
+* // @log: Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+* ```
+*
+* @param value - String to encode.
+* @param options - Encoding options.
+* @returns Encoded {@link ox#Bytes.Bytes}.
+*/
+function fromString$1(value, options = {}) {
+	const { size } = options;
+	const bytes = encoder$1.encode(value);
+	if (typeof size === "number") {
+		assertSize$1(bytes, size);
+		return padRight$1(bytes, size);
+	}
+	return bytes;
+}
+/**
+* Checks if two {@link ox#Bytes.Bytes} values are equal.
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* Bytes.isEqual(Bytes.from([1]), Bytes.from([1]))
+* // @log: true
+*
+* Bytes.isEqual(Bytes.from([1]), Bytes.from([2]))
+* // @log: false
+* ```
+*
+* @param bytesA - First {@link ox#Bytes.Bytes} value.
+* @param bytesB - Second {@link ox#Bytes.Bytes} value.
+* @returns `true` if the two values are equal, otherwise `false`.
+*/
+function isEqual(bytesA, bytesB) {
+	return equalBytes(bytesA, bytesB);
+}
+/**
+* Pads a {@link ox#Bytes.Bytes} value to the right with zero bytes until it reaches the given `size` (default: 32 bytes).
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* Bytes.padRight(Bytes.from([1]), 4)
+* // @log: Uint8Array([1, 0, 0, 0])
+* ```
+*
+* @param value - {@link ox#Bytes.Bytes} value to pad.
+* @param size - Size to pad the {@link ox#Bytes.Bytes} value to.
+* @returns Padded {@link ox#Bytes.Bytes} value.
+*/
+function padRight$1(value, size) {
+	return pad$1(value, {
+		dir: "right",
+		size
+	});
+}
+/**
+* Generates random {@link ox#Bytes.Bytes} of the specified length.
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* const bytes = Bytes.random(32)
+* // @log: Uint8Array([... x32])
+* ```
+*
+* @param length - Length of the random {@link ox#Bytes.Bytes} to generate.
+* @returns Random {@link ox#Bytes.Bytes} of the specified length.
+*/
+function random$1(length) {
+	return crypto.getRandomValues(new Uint8Array(length));
+}
+/**
+* Retrieves the size of a {@link ox#Bytes.Bytes} value.
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* Bytes.size(Bytes.from([1, 2, 3, 4]))
+* // @log: 4
+* ```
+*
+* @param value - {@link ox#Bytes.Bytes} value.
+* @returns Size of the {@link ox#Bytes.Bytes} value.
+*/
+function size$1(value) {
+	return value.length;
+}
+/**
+* Returns a section of a {@link ox#Bytes.Bytes} value given a start/end bytes offset.
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* Bytes.slice(
+*   Bytes.from([1, 2, 3, 4, 5, 6, 7, 8, 9]),
+*   1,
+*   4,
+* )
+* // @log: Uint8Array([2, 3, 4])
+* ```
+*
+* @param value - The {@link ox#Bytes.Bytes} value.
+* @param start - Start offset.
+* @param end - End offset.
+* @param options - Slice options.
+* @returns Sliced {@link ox#Bytes.Bytes} value.
+*/
+function slice$1(value, start, end, options = {}) {
+	const { strict } = options;
+	assertStartOffset$1(value, start);
+	const value_ = value.slice(start, end);
+	if (strict) assertEndOffset$1(value_, start, end);
+	return value_;
+}
+/**
+* Decodes a {@link ox#Bytes.Bytes} into a bigint.
+*
+* @example
+* ```ts
+* import { Bytes } from 'ox'
+*
+* Bytes.toBigInt(Bytes.from([1, 164]))
+* // @log: 420n
+* ```
+*
+* @param bytes - The {@link ox#Bytes.Bytes} to decode.
+* @param options - Decoding options.
+* @returns Decoded bigint.
+*/
+function toBigInt$1(bytes, options = {}) {
+	const { size } = options;
+	if (typeof size !== "undefined") assertSize$1(bytes, size);
+	return toBigInt(fromBytes(bytes, options), options);
+}
+/**
+* Decodes a {@link ox#Bytes.Bytes} into a boolean.
+*
+* @example
+* ```ts
+* import { Bytes } from 'ox'
+*
+* Bytes.toBoolean(Bytes.from([1]))
+* // @log: true
+* ```
+*
+* @param bytes - The {@link ox#Bytes.Bytes} to decode.
+* @param options - Decoding options.
+* @returns Decoded boolean.
+*/
+function toBoolean(bytes, options = {}) {
+	const { size } = options;
+	let bytes_ = bytes;
+	if (typeof size !== "undefined") {
+		assertSize$1(bytes_, size);
+		bytes_ = trimLeft$1(bytes_);
+	}
+	if (bytes_.length > 1 || bytes_[0] > 1) throw new InvalidBytesBooleanError(bytes_);
+	return Boolean(bytes_[0]);
+}
+/**
+* Decodes a {@link ox#Bytes.Bytes} into a number.
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* Bytes.toNumber(Bytes.from([1, 164]))
+* // @log: 420
+* ```
+*/
+function toNumber$1(bytes, options = {}) {
+	const { size } = options;
+	if (typeof size !== "undefined") assertSize$1(bytes, size);
+	return toNumber(fromBytes(bytes, options), options);
+}
+/**
+* Decodes a {@link ox#Bytes.Bytes} into a string.
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* const data = Bytes.toString(Bytes.from([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]))
+* // @log: 'Hello world'
+* ```
+*
+* @param bytes - The {@link ox#Bytes.Bytes} to decode.
+* @param options - Options.
+* @returns Decoded string.
+*/
+function toString$1(bytes, options = {}) {
+	const { size } = options;
+	let bytes_ = bytes;
+	if (typeof size !== "undefined") {
+		assertSize$1(bytes_, size);
+		bytes_ = trimRight(bytes_);
+	}
+	return decoder.decode(bytes_);
+}
+/**
+* Trims leading zeros from a {@link ox#Bytes.Bytes} value.
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* Bytes.trimLeft(Bytes.from([0, 0, 0, 0, 1, 2, 3]))
+* // @log: Uint8Array([1, 2, 3])
+* ```
+*
+* @param value - {@link ox#Bytes.Bytes} value.
+* @returns Trimmed {@link ox#Bytes.Bytes} value.
+*/
+function trimLeft$1(value) {
+	return trim$1(value, { dir: "left" });
+}
+/**
+* Trims trailing zeros from a {@link ox#Bytes.Bytes} value.
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* Bytes.trimRight(Bytes.from([1, 2, 3, 0, 0, 0, 0]))
+* // @log: Uint8Array([1, 2, 3])
+* ```
+*
+* @param value - {@link ox#Bytes.Bytes} value.
+* @returns Trimmed {@link ox#Bytes.Bytes} value.
+*/
+function trimRight(value) {
+	return trim$1(value, { dir: "right" });
+}
+/**
+* Checks if the given value is {@link ox#Bytes.Bytes}.
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* Bytes.validate('0x')
+* // @log: false
+*
+* Bytes.validate(Bytes.from([1, 2, 3]))
+* // @log: true
+* ```
+*
+* @param value - Value to check.
+* @returns `true` if the value is {@link ox#Bytes.Bytes}, otherwise `false`.
+*/
+function validate$1(value) {
+	try {
+		assert$1(value);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Thrown when the bytes value cannot be represented as a boolean.
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* Bytes.toBoolean(Bytes.from([5]))
+* // @error: Bytes.InvalidBytesBooleanError: Bytes value `[5]` is not a valid boolean.
+* // @error: The bytes array must contain a single byte of either a `0` or `1` value.
+* ```
+*/
+var InvalidBytesBooleanError = class extends BaseError {
+	constructor(bytes) {
+		super(`Bytes value \`${bytes}\` is not a valid boolean.`, { metaMessages: ["The bytes array must contain a single byte of either a `0` or `1` value."] });
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Bytes.InvalidBytesBooleanError"
+		});
+	}
+};
+/**
+* Thrown when a value cannot be converted to bytes.
+*
+* @example
+* ```ts twoslash
+* // @noErrors
+* import { Bytes } from 'ox'
+*
+* Bytes.from('foo')
+* // @error: Bytes.InvalidBytesTypeError: Value `foo` of type `string` is an invalid Bytes value.
+* ```
+*/
+var InvalidBytesTypeError = class extends BaseError {
+	constructor(value) {
+		super(`Value \`${typeof value === "object" ? stringify(value) : value}\` of type \`${typeof value}\` is an invalid Bytes value.`, { metaMessages: ["Bytes values must be of type `Bytes`."] });
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Bytes.InvalidBytesTypeError"
+		});
+	}
+};
+/**
+* Thrown when a size exceeds the maximum allowed size.
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* Bytes.fromString('Hello World!', { size: 8 })
+* // @error: Bytes.SizeOverflowError: Size cannot exceed `8` bytes. Given size: `12` bytes.
+* ```
+*/
+var SizeOverflowError$1 = class extends BaseError {
+	constructor({ givenSize, maxSize }) {
+		super(`Size cannot exceed \`${maxSize}\` bytes. Given size: \`${givenSize}\` bytes.`);
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Bytes.SizeOverflowError"
+		});
+	}
+};
+/**
+* Thrown when a slice offset is out-of-bounds.
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* Bytes.slice(Bytes.from([1, 2, 3]), 4)
+* // @error: Bytes.SliceOffsetOutOfBoundsError: Slice starting at offset `4` is out-of-bounds (size: `3`).
+* ```
+*/
+var SliceOffsetOutOfBoundsError$1 = class extends BaseError {
+	constructor({ offset, position, size }) {
+		super(`Slice ${position === "start" ? "starting" : "ending"} at offset \`${offset}\` is out-of-bounds (size: \`${size}\`).`);
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Bytes.SliceOffsetOutOfBoundsError"
+		});
+	}
+};
+/**
+* Thrown when a the padding size exceeds the maximum allowed size.
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* Bytes.padLeft(Bytes.fromString('Hello World!'), 8)
+* // @error: [Bytes.SizeExceedsPaddingSizeError: Bytes size (`12`) exceeds padding size (`8`).
+* ```
+*/
+var SizeExceedsPaddingSizeError$1 = class extends BaseError {
+	constructor({ size, targetSize, type }) {
+		super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (\`${size}\`) exceeds padding size (\`${targetSize}\`).`);
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Bytes.SizeExceedsPaddingSizeError"
+		});
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/ox@0.14.7_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/core/Hex.js
+const encoder = /* @__PURE__ */ new TextEncoder();
+const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
+/**
+* Asserts if the given value is {@link ox#Hex.Hex}.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.assert('abc')
+* // @error: InvalidHexValueTypeError:
+* // @error: Value `"abc"` of type `string` is an invalid hex type.
+* // @error: Hex types must be represented as `"0x\${string}"`.
+* ```
+*
+* @param value - The value to assert.
+* @param options - Options.
+*/
+function assert(value, options = {}) {
+	const { strict = false } = options;
+	if (!value) throw new InvalidHexTypeError(value);
+	if (typeof value !== "string") throw new InvalidHexTypeError(value);
+	if (strict) {
+		if (!/^0x[0-9a-fA-F]*$/.test(value)) throw new InvalidHexValueError(value);
+	}
+	if (!value.startsWith("0x")) throw new InvalidHexValueError(value);
+}
+/**
+* Concatenates two or more {@link ox#Hex.Hex}.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.concat('0x123', '0x456')
+* // @log: '0x123456'
+* ```
+*
+* @param values - The {@link ox#Hex.Hex} values to concatenate.
+* @returns The concatenated {@link ox#Hex.Hex} value.
+*/
+function concat(...values) {
+	return `0x${values.reduce((acc, x) => acc + x.replace("0x", ""), "")}`;
+}
+/**
+* Instantiates a {@link ox#Hex.Hex} value from a hex string or {@link ox#Bytes.Bytes} value.
+*
+* :::tip
+*
+* To instantiate from a **Boolean**, **String**, or **Number**, use one of the following:
+*
+* - `Hex.fromBoolean`
+*
+* - `Hex.fromString`
+*
+* - `Hex.fromNumber`
+*
+* :::
+*
+* @example
+* ```ts twoslash
+* import { Bytes, Hex } from 'ox'
+*
+* Hex.from('0x48656c6c6f20576f726c6421')
+* // @log: '0x48656c6c6f20576f726c6421'
+*
+* Hex.from(Bytes.from([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]))
+* // @log: '0x48656c6c6f20576f726c6421'
+* ```
+*
+* @param value - The {@link ox#Bytes.Bytes} value to encode.
+* @returns The encoded {@link ox#Hex.Hex} value.
+*/
+function from(value) {
+	if (value instanceof Uint8Array) return fromBytes(value);
+	if (Array.isArray(value)) return fromBytes(new Uint8Array(value));
+	return value;
+}
+/**
+* Encodes a boolean into a {@link ox#Hex.Hex} value.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.fromBoolean(true)
+* // @log: '0x1'
+*
+* Hex.fromBoolean(false)
+* // @log: '0x0'
+*
+* Hex.fromBoolean(true, { size: 32 })
+* // @log: '0x0000000000000000000000000000000000000000000000000000000000000001'
+* ```
+*
+* @param value - The boolean value to encode.
+* @param options - Options.
+* @returns The encoded {@link ox#Hex.Hex} value.
+*/
+function fromBoolean(value, options = {}) {
+	const hex = `0x${Number(value)}`;
+	if (typeof options.size === "number") {
+		assertSize(hex, options.size);
+		return padLeft(hex, options.size);
+	}
+	return hex;
+}
+/**
+* Encodes a {@link ox#Bytes.Bytes} value into a {@link ox#Hex.Hex} value.
+*
+* @example
+* ```ts twoslash
+* import { Bytes, Hex } from 'ox'
+*
+* Hex.fromBytes(Bytes.from([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]))
+* // @log: '0x48656c6c6f20576f726c6421'
+* ```
+*
+* @param value - The {@link ox#Bytes.Bytes} value to encode.
+* @param options - Options.
+* @returns The encoded {@link ox#Hex.Hex} value.
+*/
+function fromBytes(value, options = {}) {
+	let string = "";
+	for (let i = 0; i < value.length; i++) string += hexes[value[i]];
+	const hex = `0x${string}`;
+	if (typeof options.size === "number") {
+		assertSize(hex, options.size);
+		return padRight(hex, options.size);
+	}
+	return hex;
+}
+/**
+* Encodes a number or bigint into a {@link ox#Hex.Hex} value.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.fromNumber(420)
+* // @log: '0x1a4'
+*
+* Hex.fromNumber(420, { size: 32 })
+* // @log: '0x00000000000000000000000000000000000000000000000000000000000001a4'
+* ```
+*
+* @param value - The number or bigint value to encode.
+* @param options - Options.
+* @returns The encoded {@link ox#Hex.Hex} value.
+*/
+function fromNumber(value, options = {}) {
+	const { signed, size } = options;
+	const value_ = BigInt(value);
+	let maxValue;
+	if (size) if (signed) maxValue = (1n << BigInt(size) * 8n - 1n) - 1n;
+	else maxValue = 2n ** (BigInt(size) * 8n) - 1n;
+	else if (typeof value === "number") maxValue = BigInt(Number.MAX_SAFE_INTEGER);
+	const minValue = typeof maxValue === "bigint" && signed ? -maxValue - 1n : 0;
+	if (maxValue && value_ > maxValue || value_ < minValue) {
+		const suffix = typeof value === "bigint" ? "n" : "";
+		throw new IntegerOutOfRangeError({
+			max: maxValue ? `${maxValue}${suffix}` : void 0,
+			min: `${minValue}${suffix}`,
+			signed,
+			size,
+			value: `${value}${suffix}`
+		});
+	}
+	const hex = `0x${(signed && value_ < 0 ? BigInt.asUintN(size * 8, BigInt(value_)) : value_).toString(16)}`;
+	if (size) return padLeft(hex, size);
+	return hex;
+}
+/**
+* Encodes a string into a {@link ox#Hex.Hex} value.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+* Hex.fromString('Hello World!')
+* // '0x48656c6c6f20576f726c6421'
+*
+* Hex.fromString('Hello World!', { size: 32 })
+* // '0x48656c6c6f20576f726c64210000000000000000000000000000000000000000'
+* ```
+*
+* @param value - The string value to encode.
+* @param options - Options.
+* @returns The encoded {@link ox#Hex.Hex} value.
+*/
+function fromString(value, options = {}) {
+	return fromBytes(encoder.encode(value), options);
+}
+/**
+* Pads a {@link ox#Hex.Hex} value to the left with zero bytes until it reaches the given `size` (default: 32 bytes).
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.padLeft('0x1234', 4)
+* // @log: '0x00001234'
+* ```
+*
+* @param value - The {@link ox#Hex.Hex} value to pad.
+* @param size - The size (in bytes) of the output hex value.
+* @returns The padded {@link ox#Hex.Hex} value.
+*/
+function padLeft(value, size) {
+	return pad(value, {
+		dir: "left",
+		size
+	});
+}
+/**
+* Pads a {@link ox#Hex.Hex} value to the right with zero bytes until it reaches the given `size` (default: 32 bytes).
+*
+* @example
+* ```ts
+* import { Hex } from 'ox'
+*
+* Hex.padRight('0x1234', 4)
+* // @log: '0x12340000'
+* ```
+*
+* @param value - The {@link ox#Hex.Hex} value to pad.
+* @param size - The size (in bytes) of the output hex value.
+* @returns The padded {@link ox#Hex.Hex} value.
+*/
+function padRight(value, size) {
+	return pad(value, {
+		dir: "right",
+		size
+	});
+}
+/**
+* Generates a random {@link ox#Hex.Hex} value of the specified length.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* const hex = Hex.random(32)
+* // @log: '0x...'
+* ```
+*
+* @returns Random {@link ox#Hex.Hex} value.
+*/
+function random(length) {
+	return fromBytes(random$1(length));
+}
+/**
+* Returns a section of a {@link ox#Bytes.Bytes} value given a start/end bytes offset.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.slice('0x0123456789', 1, 4)
+* // @log: '0x234567'
+* ```
+*
+* @param value - The {@link ox#Hex.Hex} value to slice.
+* @param start - The start offset (in bytes).
+* @param end - The end offset (in bytes).
+* @param options - Options.
+* @returns The sliced {@link ox#Hex.Hex} value.
+*/
+function slice(value, start, end, options = {}) {
+	const { strict } = options;
+	assertStartOffset(value, start);
+	const value_ = `0x${value.replace("0x", "").slice((start ?? 0) * 2, (end ?? value.length) * 2)}`;
+	if (strict) assertEndOffset(value_, start, end);
+	return value_;
+}
+/**
+* Retrieves the size of a {@link ox#Hex.Hex} value (in bytes).
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.size('0xdeadbeef')
+* // @log: 4
+* ```
+*
+* @param value - The {@link ox#Hex.Hex} value to get the size of.
+* @returns The size of the {@link ox#Hex.Hex} value (in bytes).
+*/
+function size(value) {
+	return Math.ceil((value.length - 2) / 2);
+}
+/**
+* Trims leading zeros from a {@link ox#Hex.Hex} value.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.trimLeft('0x00000000deadbeef')
+* // @log: '0xdeadbeef'
+* ```
+*
+* @param value - The {@link ox#Hex.Hex} value to trim.
+* @returns The trimmed {@link ox#Hex.Hex} value.
+*/
+function trimLeft(value) {
+	return trim(value, { dir: "left" });
+}
+/**
+* Decodes a {@link ox#Hex.Hex} value into a BigInt.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.toBigInt('0x1a4')
+* // @log: 420n
+*
+* Hex.toBigInt('0x00000000000000000000000000000000000000000000000000000000000001a4', { size: 32 })
+* // @log: 420n
+* ```
+*
+* @param hex - The {@link ox#Hex.Hex} value to decode.
+* @param options - Options.
+* @returns The decoded BigInt.
+*/
+function toBigInt(hex, options = {}) {
+	const { signed } = options;
+	if (options.size) assertSize(hex, options.size);
+	const value = BigInt(hex);
+	if (!signed) return value;
+	const size = (hex.length - 2) / 2;
+	const max_unsigned = (1n << BigInt(size) * 8n) - 1n;
+	if (value <= max_unsigned >> 1n) return value;
+	return value - max_unsigned - 1n;
+}
+/**
+* Decodes a {@link ox#Hex.Hex} value into a {@link ox#Bytes.Bytes}.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* const data = Hex.toBytes('0x48656c6c6f20776f726c6421')
+* // @log: Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33])
+* ```
+*
+* @param hex - The {@link ox#Hex.Hex} value to decode.
+* @param options - Options.
+* @returns The decoded {@link ox#Bytes.Bytes}.
+*/
+function toBytes(hex, options = {}) {
+	return fromHex(hex, options);
+}
+/**
+* Decodes a {@link ox#Hex.Hex} value into a number.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.toNumber('0x1a4')
+* // @log: 420
+*
+* Hex.toNumber('0x00000000000000000000000000000000000000000000000000000000000001a4', { size: 32 })
+* // @log: 420
+* ```
+*
+* @param hex - The {@link ox#Hex.Hex} value to decode.
+* @param options - Options.
+* @returns The decoded number.
+*/
+function toNumber(hex, options = {}) {
+	const { signed, size } = options;
+	if (!signed && !size) return Number(hex);
+	return Number(toBigInt(hex, options));
+}
+/**
+* Decodes a {@link ox#Hex.Hex} value into a string.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.toString('0x48656c6c6f20576f726c6421')
+* // @log: 'Hello world!'
+*
+* Hex.toString('0x48656c6c6f20576f726c64210000000000000000000000000000000000000000', {
+*  size: 32,
+* })
+* // @log: 'Hello world'
+* ```
+*
+* @param hex - The {@link ox#Hex.Hex} value to decode.
+* @param options - Options.
+* @returns The decoded string.
+*/
+function toString(hex, options = {}) {
+	const { size } = options;
+	let bytes = fromHex(hex);
+	if (size) {
+		assertSize$1(bytes, size);
+		bytes = trimRight(bytes);
+	}
+	return new TextDecoder().decode(bytes);
+}
+/**
+* Checks if the given value is {@link ox#Hex.Hex}.
+*
+* @example
+* ```ts twoslash
+* import { Bytes, Hex } from 'ox'
+*
+* Hex.validate('0xdeadbeef')
+* // @log: true
+*
+* Hex.validate(Bytes.from([1, 2, 3]))
+* // @log: false
+* ```
+*
+* @param value - The value to check.
+* @param options - Options.
+* @returns `true` if the value is a {@link ox#Hex.Hex}, `false` otherwise.
+*/
+function validate(value, options = {}) {
+	const { strict = false } = options;
+	try {
+		assert(value, { strict });
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Thrown when the provided integer is out of range, and cannot be represented as a hex value.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.fromNumber(420182738912731283712937129)
+* // @error: Hex.IntegerOutOfRangeError: Number \`4.2018273891273126e+26\` is not in safe unsigned integer range (`0` to `9007199254740991`)
+* ```
+*/
+var IntegerOutOfRangeError = class extends BaseError {
+	constructor({ max, min, signed, size, value }) {
+		super(`Number \`${value}\` is not in safe${size ? ` ${size * 8}-bit` : ""}${signed ? " signed" : " unsigned"} integer range ${max ? `(\`${min}\` to \`${max}\`)` : `(above \`${min}\`)`}`);
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Hex.IntegerOutOfRangeError"
+		});
+	}
+};
+/**
+* Thrown when the provided value is not a valid hex type.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.assert(1)
+* // @error: Hex.InvalidHexTypeError: Value `1` of type `number` is an invalid hex type.
+* ```
+*/
+var InvalidHexTypeError = class extends BaseError {
+	constructor(value) {
+		super(`Value \`${typeof value === "object" ? stringify(value) : value}\` of type \`${typeof value}\` is an invalid hex type.`, { metaMessages: ["Hex types must be represented as `\"0x${string}\"`."] });
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Hex.InvalidHexTypeError"
+		});
+	}
+};
+/**
+* Thrown when the provided hex value is invalid.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.assert('0x0123456789abcdefg')
+* // @error: Hex.InvalidHexValueError: Value `0x0123456789abcdefg` is an invalid hex value.
+* // @error: Hex values must start with `"0x"` and contain only hexadecimal characters (0-9, a-f, A-F).
+* ```
+*/
+var InvalidHexValueError = class extends BaseError {
+	constructor(value) {
+		super(`Value \`${value}\` is an invalid hex value.`, { metaMessages: ["Hex values must start with `\"0x\"` and contain only hexadecimal characters (0-9, a-f, A-F)."] });
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Hex.InvalidHexValueError"
+		});
+	}
+};
+/**
+* Thrown when the provided hex value is an odd length.
+*
+* @example
+* ```ts twoslash
+* import { Bytes } from 'ox'
+*
+* Bytes.fromHex('0xabcde')
+* // @error: Hex.InvalidLengthError: Hex value `"0xabcde"` is an odd length (5 nibbles).
+* ```
+*/
+var InvalidLengthError = class extends BaseError {
+	constructor(value) {
+		super(`Hex value \`"${value}"\` is an odd length (${value.length - 2} nibbles).`, { metaMessages: ["It must be an even length."] });
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Hex.InvalidLengthError"
+		});
+	}
+};
+/**
+* Thrown when the size of the value exceeds the expected max size.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.fromString('Hello World!', { size: 8 })
+* // @error: Hex.SizeOverflowError: Size cannot exceed `8` bytes. Given size: `12` bytes.
+* ```
+*/
+var SizeOverflowError = class extends BaseError {
+	constructor({ givenSize, maxSize }) {
+		super(`Size cannot exceed \`${maxSize}\` bytes. Given size: \`${givenSize}\` bytes.`);
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Hex.SizeOverflowError"
+		});
+	}
+};
+/**
+* Thrown when the slice offset exceeds the bounds of the value.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.slice('0x0123456789', 6)
+* // @error: Hex.SliceOffsetOutOfBoundsError: Slice starting at offset `6` is out-of-bounds (size: `5`).
+* ```
+*/
+var SliceOffsetOutOfBoundsError = class extends BaseError {
+	constructor({ offset, position, size }) {
+		super(`Slice ${position === "start" ? "starting" : "ending"} at offset \`${offset}\` is out-of-bounds (size: \`${size}\`).`);
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Hex.SliceOffsetOutOfBoundsError"
+		});
+	}
+};
+/**
+* Thrown when the size of the value exceeds the pad size.
+*
+* @example
+* ```ts twoslash
+* import { Hex } from 'ox'
+*
+* Hex.padLeft('0x1a4e12a45a21323123aaa87a897a897a898a6567a578a867a98778a667a85a875a87a6a787a65a675a6a9', 32)
+* // @error: Hex.SizeExceedsPaddingSizeError: Hex size (`43`) exceeds padding size (`32`).
+* ```
+*/
+var SizeExceedsPaddingSizeError = class extends BaseError {
+	constructor({ size, targetSize, type }) {
+		super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (\`${size}\`) exceeds padding size (\`${targetSize}\`).`);
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Hex.SizeExceedsPaddingSizeError"
+		});
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/ox@0.14.7_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/core/Withdrawal.js
+/**
+* Converts a {@link ox#Withdrawal.Withdrawal} to an {@link ox#Withdrawal.Rpc}.
+*
+* @example
+* ```ts twoslash
+* import { Withdrawal } from 'ox'
+*
+* const withdrawal = Withdrawal.toRpc({
+*   address: '0x00000000219ab540356cBB839Cbe05303d7705Fa',
+*   amount: 6423331n,
+*   index: 0,
+*   validatorIndex: 1,
+* })
+* // @log: {
+* // @log:   address: '0x00000000219ab540356cBB839Cbe05303d7705Fa',
+* // @log:   amount: '0x620323',
+* // @log:   index: '0x0',
+* // @log:   validatorIndex: '0x1',
+* // @log: }
+* ```
+*
+* @param withdrawal - The Withdrawal to convert.
+* @returns An RPC Withdrawal.
+*/
+function toRpc$1(withdrawal) {
+	return {
+		address: withdrawal.address,
+		amount: fromNumber(withdrawal.amount),
+		index: fromNumber(withdrawal.index),
+		validatorIndex: fromNumber(withdrawal.validatorIndex)
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/ox@0.14.7_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/core/BlockOverrides.js
+/**
+* Converts an {@link ox#BlockOverrides.BlockOverrides} to an {@link ox#BlockOverrides.Rpc}.
+*
+* @example
+* ```ts twoslash
+* import { BlockOverrides } from 'ox'
+*
+* const blockOverrides = BlockOverrides.toRpc({
+*   baseFeePerGas: 1n,
+*   blobBaseFee: 2n,
+*   feeRecipient: '0x0000000000000000000000000000000000000000',
+*   gasLimit: 4n,
+*   number: 5n,
+*   prevRandao: 6n,
+*   time: 78187493520n,
+*   withdrawals: [
+*     {
+*       address: '0x0000000000000000000000000000000000000000',
+*       amount: 1n,
+*       index: 0,
+*       validatorIndex: 1,
+*     },
+*   ],
+* })
+* ```
+*
+* @param blockOverrides - The block overrides to convert.
+* @returns An instantiated {@link ox#BlockOverrides.Rpc}.
+*/
+function toRpc(blockOverrides) {
+	return {
+		...typeof blockOverrides.baseFeePerGas === "bigint" && { baseFeePerGas: fromNumber(blockOverrides.baseFeePerGas) },
+		...typeof blockOverrides.blobBaseFee === "bigint" && { blobBaseFee: fromNumber(blockOverrides.blobBaseFee) },
+		...typeof blockOverrides.feeRecipient === "string" && { feeRecipient: blockOverrides.feeRecipient },
+		...typeof blockOverrides.gasLimit === "bigint" && { gasLimit: fromNumber(blockOverrides.gasLimit) },
+		...typeof blockOverrides.number === "bigint" && { number: fromNumber(blockOverrides.number) },
+		...typeof blockOverrides.prevRandao === "bigint" && { prevRandao: fromNumber(blockOverrides.prevRandao) },
+		...typeof blockOverrides.time === "bigint" && { time: fromNumber(blockOverrides.time) },
+		...blockOverrides.withdrawals && { withdrawals: blockOverrides.withdrawals.map(toRpc$1) }
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/constants/abis.js
+const multicall3Abi = [
+	{
+		inputs: [{
+			components: [
+				{
+					name: "target",
+					type: "address"
+				},
+				{
+					name: "allowFailure",
+					type: "bool"
+				},
+				{
+					name: "callData",
+					type: "bytes"
+				}
+			],
+			name: "calls",
+			type: "tuple[]"
+		}],
+		name: "aggregate3",
+		outputs: [{
+			components: [{
+				name: "success",
+				type: "bool"
+			}, {
+				name: "returnData",
+				type: "bytes"
+			}],
+			name: "returnData",
+			type: "tuple[]"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			name: "addr",
+			type: "address"
+		}],
+		name: "getEthBalance",
+		outputs: [{
+			name: "balance",
+			type: "uint256"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "getCurrentBlockTimestamp",
+		outputs: [{
+			internalType: "uint256",
+			name: "timestamp",
+			type: "uint256"
+		}],
+		stateMutability: "view",
+		type: "function"
+	}
+];
+const batchGatewayAbi = [{
+	name: "query",
+	type: "function",
+	stateMutability: "view",
+	inputs: [{
+		type: "tuple[]",
+		name: "queries",
+		components: [
+			{
+				type: "address",
+				name: "sender"
+			},
+			{
+				type: "string[]",
+				name: "urls"
+			},
+			{
+				type: "bytes",
+				name: "data"
+			}
+		]
+	}],
+	outputs: [{
+		type: "bool[]",
+		name: "failures"
+	}, {
+		type: "bytes[]",
+		name: "responses"
+	}]
+}, {
+	name: "HttpError",
+	type: "error",
+	inputs: [{
+		type: "uint16",
+		name: "status"
+	}, {
+		type: "string",
+		name: "message"
+	}]
+}];
+const universalResolverErrors = [
+	{
+		inputs: [{
+			name: "dns",
+			type: "bytes"
+		}],
+		name: "DNSDecodingFailed",
+		type: "error"
+	},
+	{
+		inputs: [{
+			name: "ens",
+			type: "string"
+		}],
+		name: "DNSEncodingFailed",
+		type: "error"
+	},
+	{
+		inputs: [],
+		name: "EmptyAddress",
+		type: "error"
+	},
+	{
+		inputs: [{
+			name: "status",
+			type: "uint16"
+		}, {
+			name: "message",
+			type: "string"
+		}],
+		name: "HttpError",
+		type: "error"
+	},
+	{
+		inputs: [],
+		name: "InvalidBatchGatewayResponse",
+		type: "error"
+	},
+	{
+		inputs: [{
+			name: "errorData",
+			type: "bytes"
+		}],
+		name: "ResolverError",
+		type: "error"
+	},
+	{
+		inputs: [{
+			name: "name",
+			type: "bytes"
+		}, {
+			name: "resolver",
+			type: "address"
+		}],
+		name: "ResolverNotContract",
+		type: "error"
+	},
+	{
+		inputs: [{
+			name: "name",
+			type: "bytes"
+		}],
+		name: "ResolverNotFound",
+		type: "error"
+	},
+	{
+		inputs: [{
+			name: "primary",
+			type: "string"
+		}, {
+			name: "primaryAddress",
+			type: "bytes"
+		}],
+		name: "ReverseAddressMismatch",
+		type: "error"
+	},
+	{
+		inputs: [{
+			internalType: "bytes4",
+			name: "selector",
+			type: "bytes4"
+		}],
+		name: "UnsupportedResolverProfile",
+		type: "error"
+	}
+];
+[...universalResolverErrors];
+[...universalResolverErrors];
+/** @internal */
+const erc1271Abi = [{
+	name: "isValidSignature",
+	type: "function",
+	stateMutability: "view",
+	inputs: [{
+		name: "hash",
+		type: "bytes32"
+	}, {
+		name: "signature",
+		type: "bytes"
+	}],
+	outputs: [{
+		name: "",
+		type: "bytes4"
+	}]
+}];
+const erc6492SignatureValidatorAbi = [{
+	inputs: [
+		{
+			name: "_signer",
+			type: "address"
+		},
+		{
+			name: "_hash",
+			type: "bytes32"
+		},
+		{
+			name: "_signature",
+			type: "bytes"
+		}
+	],
+	stateMutability: "nonpayable",
+	type: "constructor"
+}, {
+	inputs: [
+		{
+			name: "_signer",
+			type: "address"
+		},
+		{
+			name: "_hash",
+			type: "bytes32"
+		},
+		{
+			name: "_signature",
+			type: "bytes"
+		}
+	],
+	outputs: [{ type: "bool" }],
+	stateMutability: "nonpayable",
+	type: "function",
+	name: "isValidSig"
+}];
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/constants/contracts.js
+const deploylessCallViaBytecodeBytecode = "0x608060405234801561001057600080fd5b5060405161018e38038061018e83398101604081905261002f91610124565b6000808351602085016000f59050803b61004857600080fd5b6000808351602085016000855af16040513d6000823e81610067573d81fd5b3d81f35b634e487b7160e01b600052604160045260246000fd5b600082601f83011261009257600080fd5b81516001600160401b038111156100ab576100ab61006b565b604051601f8201601f19908116603f011681016001600160401b03811182821017156100d9576100d961006b565b6040528181528382016020018510156100f157600080fd5b60005b82811015610110576020818601810151838301820152016100f4565b506000918101602001919091529392505050565b6000806040838503121561013757600080fd5b82516001600160401b0381111561014d57600080fd5b61015985828601610081565b602085015190935090506001600160401b0381111561017757600080fd5b61018385828601610081565b915050925092905056fe";
+const deploylessCallViaFactoryBytecode = "0x608060405234801561001057600080fd5b506040516102c03803806102c083398101604081905261002f916101e6565b836001600160a01b03163b6000036100e457600080836001600160a01b03168360405161005c9190610270565b6000604051808303816000865af19150503d8060008114610099576040519150601f19603f3d011682016040523d82523d6000602084013e61009e565b606091505b50915091508115806100b857506001600160a01b0386163b155b156100e1578060405163101bb98d60e01b81526004016100d8919061028c565b60405180910390fd5b50505b6000808451602086016000885af16040513d6000823e81610103573d81fd5b3d81f35b80516001600160a01b038116811461011e57600080fd5b919050565b634e487b7160e01b600052604160045260246000fd5b60005b8381101561015457818101518382015260200161013c565b50506000910152565b600082601f83011261016e57600080fd5b81516001600160401b0381111561018757610187610123565b604051601f8201601f19908116603f011681016001600160401b03811182821017156101b5576101b5610123565b6040528181528382016020018510156101cd57600080fd5b6101de826020830160208701610139565b949350505050565b600080600080608085870312156101fc57600080fd5b61020585610107565b60208601519094506001600160401b0381111561022157600080fd5b61022d8782880161015d565b93505061023c60408601610107565b60608601519092506001600160401b0381111561025857600080fd5b6102648782880161015d565b91505092959194509250565b60008251610282818460208701610139565b9190910192915050565b60208152600082518060208401526102ab816040850160208701610139565b601f01601f1916919091016040019291505056fe";
+const erc6492SignatureValidatorByteCode = "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";
+const multicall3Bytecode = "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";
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/abi/encodeDeployData.js
+const docsPath = "/docs/contract/encodeDeployData";
+function encodeDeployData(parameters) {
+	const { abi, args, bytecode } = parameters;
+	if (!args || args.length === 0) return bytecode;
+	const description = abi.find((x) => "type" in x && x.type === "constructor");
+	if (!description) throw new AbiConstructorNotFoundError({ docsPath });
+	if (!("inputs" in description)) throw new AbiConstructorParamsNotFoundError({ docsPath });
+	if (!description.inputs || description.inputs.length === 0) throw new AbiConstructorParamsNotFoundError({ docsPath });
+	return concatHex([bytecode, encodeAbiParameters(description.inputs, args)]);
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/chain/getChainContractAddress.js
+function getChainContractAddress({ blockNumber, chain, contract: name }) {
+	const contract = chain?.contracts?.[name];
+	if (!contract) throw new ChainDoesNotSupportContract({
+		chain,
+		contract: { name }
+	});
+	if (blockNumber && contract.blockCreated && contract.blockCreated > blockNumber) throw new ChainDoesNotSupportContract({
+		blockNumber,
+		chain,
+		contract: {
+			name,
+			blockCreated: contract.blockCreated
+		}
+	});
+	return contract.address;
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/errors/getCallError.js
+function getCallError(err, { docsPath, ...args }) {
+	return new CallExecutionError((() => {
+		const cause = getNodeError(err, args);
+		if (cause instanceof UnknownNodeError) return err;
+		return cause;
+	})(), {
+		docsPath,
+		...args
+	});
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/promise/withResolvers.js
+/** @internal */
+function withResolvers() {
+	let resolve = () => void 0;
+	let reject = () => void 0;
+	return {
+		promise: new Promise((resolve_, reject_) => {
+			resolve = resolve_;
+			reject = reject_;
+		}),
+		resolve,
+		reject
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/promise/createBatchScheduler.js
+const schedulerCache = /* @__PURE__ */ new Map();
+/** @internal */
+function createBatchScheduler({ fn, id, shouldSplitBatch, wait = 0, sort }) {
+	const exec = async () => {
+		const scheduler = getScheduler();
+		flush();
+		const args = scheduler.map(({ args }) => args);
+		if (args.length === 0) return;
+		fn(args).then((data) => {
+			if (sort && Array.isArray(data)) data.sort(sort);
+			for (let i = 0; i < scheduler.length; i++) {
+				const { resolve } = scheduler[i];
+				resolve?.([data[i], data]);
+			}
+		}).catch((err) => {
+			for (let i = 0; i < scheduler.length; i++) {
+				const { reject } = scheduler[i];
+				reject?.(err);
+			}
+		});
+	};
+	const flush = () => schedulerCache.delete(id);
+	const getBatchedArgs = () => getScheduler().map(({ args }) => args);
+	const getScheduler = () => schedulerCache.get(id) || [];
+	const setScheduler = (item) => schedulerCache.set(id, [...getScheduler(), item]);
+	return {
+		flush,
+		async schedule(args) {
+			const { promise, resolve, reject } = withResolvers();
+			if (shouldSplitBatch?.([...getBatchedArgs(), args])) exec();
+			if (getScheduler().length > 0) {
+				setScheduler({
+					args,
+					resolve,
+					reject
+				});
+				return promise;
+			}
+			setScheduler({
+				args,
+				resolve,
+				reject
+			});
+			setTimeout(exec, wait);
+			return promise;
+		}
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/actions/public/call.js
+/**
+* Executes a new message call immediately without submitting a transaction to the network.
+*
+* - Docs: https://viem.sh/docs/actions/public/call
+* - JSON-RPC Methods: [`eth_call`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_call)
+*
+* @param client - Client to use
+* @param parameters - {@link CallParameters}
+* @returns The call data. {@link CallReturnType}
+*
+* @example
+* import { createPublicClient, http } from 'viem'
+* import { mainnet } from 'viem/chains'
+* import { call } from 'viem/public'
+*
+* const client = createPublicClient({
+*   chain: mainnet,
+*   transport: http(),
+* })
+* const data = await call(client, {
+*   account: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
+*   data: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+*   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+* })
+*/
+async function call(client, args) {
+	const { account: account_ = client.account, authorizationList, batch = Boolean(client.batch?.multicall), blockNumber, blockTag = client.experimental_blockTag ?? "latest", accessList, blobs, blockOverrides, code, data: data_, factory, factoryData, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, stateOverride, ...rest } = args;
+	const account = account_ ? parseAccount(account_) : void 0;
+	if (code && (factory || factoryData)) throw new BaseError$2("Cannot provide both `code` & `factory`/`factoryData` as parameters.");
+	if (code && to) throw new BaseError$2("Cannot provide both `code` & `to` as parameters.");
+	const deploylessCallViaBytecode = code && data_;
+	const deploylessCallViaFactory = factory && factoryData && to && data_;
+	const deploylessCall = deploylessCallViaBytecode || deploylessCallViaFactory;
+	const data = (() => {
+		if (deploylessCallViaBytecode) return toDeploylessCallViaBytecodeData({
+			code,
+			data: data_
+		});
+		if (deploylessCallViaFactory) return toDeploylessCallViaFactoryData({
+			data: data_,
+			factory,
+			factoryData,
+			to
+		});
+		return data_;
+	})();
+	try {
+		assertRequest(args);
+		const block = (typeof blockNumber === "bigint" ? numberToHex(blockNumber) : void 0) || blockTag;
+		const rpcBlockOverrides = blockOverrides ? toRpc(blockOverrides) : void 0;
+		const rpcStateOverride = serializeStateOverride(stateOverride);
+		const chainFormat = client.chain?.formatters?.transactionRequest?.format;
+		const request = (chainFormat || formatTransactionRequest)({
+			...extract(rest, { format: chainFormat }),
+			accessList,
+			account,
+			authorizationList,
+			blobs,
+			data,
+			gas,
+			gasPrice,
+			maxFeePerBlobGas,
+			maxFeePerGas,
+			maxPriorityFeePerGas,
+			nonce,
+			to: deploylessCall ? void 0 : to,
+			value
+		}, "call");
+		if (batch && shouldPerformMulticall({ request }) && !rpcStateOverride && !rpcBlockOverrides) try {
+			return await scheduleMulticall(client, {
+				...request,
+				blockNumber,
+				blockTag
+			});
+		} catch (err) {
+			if (!(err instanceof ClientChainNotConfiguredError) && !(err instanceof ChainDoesNotSupportContract)) throw err;
+		}
+		const params = (() => {
+			const base = [request, block];
+			if (rpcStateOverride && rpcBlockOverrides) return [
+				...base,
+				rpcStateOverride,
+				rpcBlockOverrides
+			];
+			if (rpcStateOverride) return [...base, rpcStateOverride];
+			if (rpcBlockOverrides) return [
+				...base,
+				{},
+				rpcBlockOverrides
+			];
+			return base;
+		})();
+		const response = await client.request({
+			method: "eth_call",
+			params
+		});
+		if (response === "0x") return { data: void 0 };
+		return { data: response };
+	} catch (err) {
+		const data = getRevertErrorData(err);
+		const { offchainLookup, offchainLookupSignature } = await import("./ccip-Bx-zoUCJ.js");
+		if (client.ccipRead !== false && data?.slice(0, 10) === offchainLookupSignature && to) return { data: await offchainLookup(client, {
+			data,
+			to
+		}) };
+		if (deploylessCall && data?.slice(0, 10) === "0x101bb98d") throw new CounterfactualDeploymentFailedError({ factory });
+		throw getCallError(err, {
+			...args,
+			account,
+			chain: client.chain
+		});
+	}
+}
+function shouldPerformMulticall({ request }) {
+	const { data, to, ...request_ } = request;
+	if (!data) return false;
+	if (data.startsWith("0x82ad56cb")) return false;
+	if (!to) return false;
+	if (Object.values(request_).filter((x) => typeof x !== "undefined").length > 0) return false;
+	return true;
+}
+async function scheduleMulticall(client, args) {
+	const { batchSize = 1024, deployless = false, wait = 0 } = typeof client.batch?.multicall === "object" ? client.batch.multicall : {};
+	const { blockNumber, blockTag = client.experimental_blockTag ?? "latest", data, to } = args;
+	const multicallAddress = (() => {
+		if (deployless) return null;
+		if (args.multicallAddress) return args.multicallAddress;
+		if (client.chain) return getChainContractAddress({
+			blockNumber,
+			chain: client.chain,
+			contract: "multicall3"
+		});
+		throw new ClientChainNotConfiguredError();
+	})();
+	const block = (typeof blockNumber === "bigint" ? numberToHex(blockNumber) : void 0) || blockTag;
+	const { schedule } = createBatchScheduler({
+		id: `${client.uid}.${block}`,
+		wait,
+		shouldSplitBatch(args) {
+			return args.reduce((size, { data }) => size + (data.length - 2), 0) > batchSize * 2;
+		},
+		fn: async (requests) => {
+			const calls = requests.map((request) => ({
+				allowFailure: true,
+				callData: request.data,
+				target: request.to
+			}));
+			const calldata = encodeFunctionData({
+				abi: multicall3Abi,
+				args: [calls],
+				functionName: "aggregate3"
+			});
+			const data = await client.request({
+				method: "eth_call",
+				params: [{ ...multicallAddress === null ? { data: toDeploylessCallViaBytecodeData({
+					code: multicall3Bytecode,
+					data: calldata
+				}) } : {
+					to: multicallAddress,
+					data: calldata
+				} }, block]
+			});
+			return decodeFunctionResult({
+				abi: multicall3Abi,
+				args: [calls],
+				functionName: "aggregate3",
+				data: data || "0x"
+			});
+		}
+	});
+	const [{ returnData, success }] = await schedule({
+		data,
+		to
+	});
+	if (!success) throw new RawContractError({ data: returnData });
+	if (returnData === "0x") return { data: void 0 };
+	return { data: returnData };
+}
+function toDeploylessCallViaBytecodeData(parameters) {
+	const { code, data } = parameters;
+	return encodeDeployData({
+		abi: parseAbi(["constructor(bytes, bytes)"]),
+		bytecode: deploylessCallViaBytecodeBytecode,
+		args: [code, data]
+	});
+}
+function toDeploylessCallViaFactoryData(parameters) {
+	const { data, factory, factoryData, to } = parameters;
+	return encodeDeployData({
+		abi: parseAbi(["constructor(address, bytes, address, bytes)"]),
+		bytecode: deploylessCallViaFactoryBytecode,
+		args: [
+			to,
+			data,
+			factory,
+			factoryData
+		]
+	});
+}
+/** @internal */
+function getRevertErrorData(err) {
+	if (!(err instanceof BaseError$2)) return void 0;
+	const error = err.walk();
+	return typeof error?.data === "object" ? error.data?.data : error.data;
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/abi/decodeFunctionData.js
+function decodeFunctionData(parameters) {
+	const { abi, data } = parameters;
+	const signature = slice$2(data, 0, 4);
+	const description = abi.find((x) => x.type === "function" && signature === toFunctionSelector(formatAbiItem$1(x)));
+	if (!description) throw new AbiFunctionSignatureNotFoundError(signature, { docsPath: "/docs/contract/decodeFunctionData" });
+	return {
+		functionName: description.name,
+		args: "inputs" in description && description.inputs && description.inputs.length > 0 ? decodeAbiParameters(description.inputs, slice$2(data, 4)) : void 0
+	};
+}
+//#endregion
+export { extract as $, trimLeft as A, TimeoutError as At, toBoolean as B, encodeFunctionData as Bt, random as C, UnsupportedChainIdError as Ct, toBytes as D, WalletConnectSessionSettlementError as Dt, toBigInt as E, UserRejectedRequestError as Et, fromString$1 as F, RawContractError as Ft, stringify as G, parseAbiParameter as Gt, toString$1 as H, toFunctionSelector as Ht, isEqual as I, getUrl as It, assertRequest as J, isStructSignature as Jt, BaseError as K, splitParameters as Kt, size$1 as L, decodeErrorResult as Lt, concat$1 as M, ContractFunctionExecutionError as Mt, from$1 as N, ContractFunctionRevertedError as Nt, toNumber as O, HttpRequestError as Ot, fromHex as P, ContractFunctionZeroDataError as Pt, defineFormatter as Q, slice$1 as R, decodeAbiParameters as Rt, padRight as S, UnknownRpcError as St, slice as T, UnsupportedProviderMethodError as Tt, trimLeft$1 as U, toEventSelector as Ut, toNumber$1 as V, getAbiItem as Vt, validate$1 as W, parseStructs as Wt, defineTransactionRequest as X, formatAbiItem as Xt, serializeStateOverride as Y, modifiers as Yt, formatTransactionRequest as Z, formatAbiParameters as Zt, fromBoolean as _, ResourceUnavailableRpcError as _t, encodeDeployData as a, DuplicateIdError as at, fromString as b, UnauthorizedProviderError as bt, batchGatewayAbi as c, InvalidParamsRpcError as ct, multicall3Abi as d, LimitExceededRpcError as dt, getNodeError as et, IntegerOutOfRangeError as f, MethodNotFoundRpcError as ft, from as g, ResourceNotFoundRpcError as gt, concat as h, ProviderDisconnectedError as ht, withResolvers as i, ChainDisconnectedError as it, validate as j, CallExecutionError as jt, toString as k, RpcRequestError as kt, erc1271Abi as l, InvalidRequestRpcError as lt, assert as m, ParseRpcError as mt, call as n, AtomicityNotSupportedError as nt, erc6492SignatureValidatorByteCode as o, InternalRpcError as ot, InvalidLengthError as p, MethodNotSupportedRpcError as pt, decodeFunctionResult as q, InvalidAbiParametersError as qt, createBatchScheduler as r, BundleTooLargeError as rt, multicall3Bytecode as s, InvalidInputRpcError as st, decodeFunctionData as t, AtomicReadyWalletRejectedUpgradeError as tt, erc6492SignatureValidatorAbi as u, JsonRpcVersionUnsupportedError as ut, fromBytes as v, SwitchChainError as vt, size as w, UnsupportedNonOptionalCapabilityError as wt, padLeft as x, UnknownBundleIdError as xt, fromNumber as y, TransactionRejectedRpcError as yt, toBigInt$1 as z, solidityError as zt };