x402-proxy 0.10.7 → 0.10.9

package/dist/chain-DwfP5RGZ.js

@@ -0,0 +1,1968 @@
+import { t as keccak_256 } from "./sha3-DbMJRJ3C.js";
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/abi/formatAbiItem.js
+function formatAbiItem(abiItem, { includeName = false } = {}) {
+	if (abiItem.type !== "function" && abiItem.type !== "event" && abiItem.type !== "error") throw new InvalidDefinitionTypeError(abiItem.type);
+	return `${abiItem.name}(${formatAbiParams(abiItem.inputs, { includeName })})`;
+}
+function formatAbiParams(params, { includeName = false } = {}) {
+	if (!params) return "";
+	return params.map((param) => formatAbiParam(param, { includeName })).join(includeName ? ", " : ",");
+}
+function formatAbiParam(param, { includeName }) {
+	if (param.type.startsWith("tuple")) return `(${formatAbiParams(param.components, { includeName })})${param.type.slice(5)}`;
+	return param.type + (includeName && param.name ? ` ${param.name}` : "");
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/data/isHex.js
+function isHex(value, { strict = true } = {}) {
+	if (!value) return false;
+	if (typeof value !== "string") return false;
+	return strict ? /^0x[0-9a-fA-F]*$/.test(value) : value.startsWith("0x");
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/data/size.js
+/**
+* @description Retrieves the size of the value (in bytes).
+*
+* @param value The value (hex or byte array) to retrieve the size of.
+* @returns The size of the value (in bytes).
+*/
+function size(value) {
+	if (isHex(value, { strict: false })) return Math.ceil((value.length - 2) / 2);
+	return value.length;
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/errors/version.js
+const version = "2.47.6";
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/errors/base.js
+let errorConfig = {
+	getDocsUrl: ({ docsBaseUrl, docsPath = "", docsSlug }) => docsPath ? `${docsBaseUrl ?? "https://viem.sh"}${docsPath}${docsSlug ? `#${docsSlug}` : ""}` : void 0,
+	version: `viem@${version}`
+};
+var BaseError = class BaseError extends Error {
+	constructor(shortMessage, args = {}) {
+		const details = (() => {
+			if (args.cause instanceof BaseError) return args.cause.details;
+			if (args.cause?.message) return args.cause.message;
+			return args.details;
+		})();
+		const docsPath = (() => {
+			if (args.cause instanceof BaseError) return args.cause.docsPath || args.docsPath;
+			return args.docsPath;
+		})();
+		const docsUrl = errorConfig.getDocsUrl?.({
+			...args,
+			docsPath
+		});
+		const message = [
+			shortMessage || "An error occurred.",
+			"",
+			...args.metaMessages ? [...args.metaMessages, ""] : [],
+			...docsUrl ? [`Docs: ${docsUrl}`] : [],
+			...details ? [`Details: ${details}`] : [],
+			...errorConfig.version ? [`Version: ${errorConfig.version}`] : []
+		].join("\n");
+		super(message, args.cause ? { cause: args.cause } : void 0);
+		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, "version", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "BaseError"
+		});
+		this.details = details;
+		this.docsPath = docsPath;
+		this.metaMessages = args.metaMessages;
+		this.name = args.name ?? this.name;
+		this.shortMessage = shortMessage;
+		this.version = version;
+	}
+	walk(fn) {
+		return walk(this, fn);
+	}
+};
+function walk(err, fn) {
+	if (fn?.(err)) return err;
+	if (err && typeof err === "object" && "cause" in err && err.cause !== void 0) return walk(err.cause, fn);
+	return fn ? null : err;
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/errors/abi.js
+var AbiConstructorNotFoundError = class extends BaseError {
+	constructor({ docsPath }) {
+		super(["A constructor was not found on the ABI.", "Make sure you are using the correct ABI and that the constructor exists on it."].join("\n"), {
+			docsPath,
+			name: "AbiConstructorNotFoundError"
+		});
+	}
+};
+var AbiConstructorParamsNotFoundError = class extends BaseError {
+	constructor({ docsPath }) {
+		super(["Constructor arguments were provided (`args`), but a constructor parameters (`inputs`) were not found on the ABI.", "Make sure you are using the correct ABI, and that the `inputs` attribute on the constructor exists."].join("\n"), {
+			docsPath,
+			name: "AbiConstructorParamsNotFoundError"
+		});
+	}
+};
+var AbiDecodingDataSizeTooSmallError = class extends BaseError {
+	constructor({ data, params, size }) {
+		super([`Data size of ${size} bytes is too small for given parameters.`].join("\n"), {
+			metaMessages: [`Params: (${formatAbiParams(params, { includeName: true })})`, `Data:   ${data} (${size} bytes)`],
+			name: "AbiDecodingDataSizeTooSmallError"
+		});
+		Object.defineProperty(this, "data", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "params", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "size", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		this.data = data;
+		this.params = params;
+		this.size = size;
+	}
+};
+var AbiDecodingZeroDataError = class extends BaseError {
+	constructor({ cause } = {}) {
+		super("Cannot decode zero data (\"0x\") with ABI parameters.", {
+			name: "AbiDecodingZeroDataError",
+			cause
+		});
+	}
+};
+var AbiEncodingArrayLengthMismatchError = class extends BaseError {
+	constructor({ expectedLength, givenLength, type }) {
+		super([
+			`ABI encoding array length mismatch for type ${type}.`,
+			`Expected length: ${expectedLength}`,
+			`Given length: ${givenLength}`
+		].join("\n"), { name: "AbiEncodingArrayLengthMismatchError" });
+	}
+};
+var AbiEncodingBytesSizeMismatchError = class extends BaseError {
+	constructor({ expectedSize, value }) {
+		super(`Size of bytes "${value}" (bytes${size(value)}) does not match expected size (bytes${expectedSize}).`, { name: "AbiEncodingBytesSizeMismatchError" });
+	}
+};
+var AbiEncodingLengthMismatchError = class extends BaseError {
+	constructor({ expectedLength, givenLength }) {
+		super([
+			"ABI encoding params/values length mismatch.",
+			`Expected length (params): ${expectedLength}`,
+			`Given length (values): ${givenLength}`
+		].join("\n"), { name: "AbiEncodingLengthMismatchError" });
+	}
+};
+var AbiErrorInputsNotFoundError = class extends BaseError {
+	constructor(errorName, { docsPath }) {
+		super([
+			`Arguments (\`args\`) were provided to "${errorName}", but "${errorName}" on the ABI does not contain any parameters (\`inputs\`).`,
+			"Cannot encode error result without knowing what the parameter types are.",
+			"Make sure you are using the correct ABI and that the inputs exist on it."
+		].join("\n"), {
+			docsPath,
+			name: "AbiErrorInputsNotFoundError"
+		});
+	}
+};
+var AbiErrorNotFoundError = class extends BaseError {
+	constructor(errorName, { docsPath } = {}) {
+		super([`Error ${errorName ? `"${errorName}" ` : ""}not found on ABI.`, "Make sure you are using the correct ABI and that the error exists on it."].join("\n"), {
+			docsPath,
+			name: "AbiErrorNotFoundError"
+		});
+	}
+};
+var AbiErrorSignatureNotFoundError = class extends BaseError {
+	constructor(signature, { docsPath, cause }) {
+		super([
+			`Encoded error signature "${signature}" not found on 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}.`
+		].join("\n"), {
+			docsPath,
+			name: "AbiErrorSignatureNotFoundError",
+			cause
+		});
+		Object.defineProperty(this, "signature", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		this.signature = signature;
+	}
+};
+var AbiEventSignatureEmptyTopicsError = class extends BaseError {
+	constructor({ docsPath }) {
+		super("Cannot extract event signature from empty topics.", {
+			docsPath,
+			name: "AbiEventSignatureEmptyTopicsError"
+		});
+	}
+};
+var AbiEventSignatureNotFoundError = class extends BaseError {
+	constructor(signature, { docsPath }) {
+		super([
+			`Encoded event signature "${signature}" not found on ABI.`,
+			"Make sure you are using the correct ABI and that the event exists on it.",
+			`You can look up the signature here: https://4byte.sourcify.dev/?q=${signature}.`
+		].join("\n"), {
+			docsPath,
+			name: "AbiEventSignatureNotFoundError"
+		});
+	}
+};
+var AbiFunctionNotFoundError = class extends BaseError {
+	constructor(functionName, { docsPath } = {}) {
+		super([`Function ${functionName ? `"${functionName}" ` : ""}not found on ABI.`, "Make sure you are using the correct ABI and that the function exists on it."].join("\n"), {
+			docsPath,
+			name: "AbiFunctionNotFoundError"
+		});
+	}
+};
+var AbiFunctionOutputsNotFoundError = class extends BaseError {
+	constructor(functionName, { docsPath }) {
+		super([
+			`Function "${functionName}" does not contain any \`outputs\` on ABI.`,
+			"Cannot decode function result without knowing what the parameter types are.",
+			"Make sure you are using the correct ABI and that the function exists on it."
+		].join("\n"), {
+			docsPath,
+			name: "AbiFunctionOutputsNotFoundError"
+		});
+	}
+};
+var AbiFunctionSignatureNotFoundError = class extends BaseError {
+	constructor(signature, { docsPath }) {
+		super([
+			`Encoded function signature "${signature}" not found on ABI.`,
+			"Make sure you are using the correct ABI and that the function exists on it.",
+			`You can look up the signature here: https://4byte.sourcify.dev/?q=${signature}.`
+		].join("\n"), {
+			docsPath,
+			name: "AbiFunctionSignatureNotFoundError"
+		});
+	}
+};
+var AbiItemAmbiguityError = class extends BaseError {
+	constructor(x, y) {
+		super("Found ambiguous types in overloaded ABI items.", {
+			metaMessages: [
+				`\`${x.type}\` in \`${formatAbiItem(x.abiItem)}\`, and`,
+				`\`${y.type}\` in \`${formatAbiItem(y.abiItem)}\``,
+				"",
+				"These types encode differently and cannot be distinguished at runtime.",
+				"Remove one of the ambiguous items in the ABI."
+			],
+			name: "AbiItemAmbiguityError"
+		});
+	}
+};
+var BytesSizeMismatchError = class extends BaseError {
+	constructor({ expectedSize, givenSize }) {
+		super(`Expected bytes${expectedSize}, got bytes${givenSize}.`, { name: "BytesSizeMismatchError" });
+	}
+};
+var DecodeLogDataMismatch = class extends BaseError {
+	constructor({ abiItem, data, params, size }) {
+		super([`Data size of ${size} bytes is too small for non-indexed event parameters.`].join("\n"), {
+			metaMessages: [`Params: (${formatAbiParams(params, { includeName: true })})`, `Data:   ${data} (${size} bytes)`],
+			name: "DecodeLogDataMismatch"
+		});
+		Object.defineProperty(this, "abiItem", {
+			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, "params", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "size", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		this.abiItem = abiItem;
+		this.data = data;
+		this.params = params;
+		this.size = size;
+	}
+};
+var DecodeLogTopicsMismatch = class extends BaseError {
+	constructor({ abiItem, param }) {
+		super([`Expected a topic for indexed event parameter${param.name ? ` "${param.name}"` : ""} on event "${formatAbiItem(abiItem, { includeName: true })}".`].join("\n"), { name: "DecodeLogTopicsMismatch" });
+		Object.defineProperty(this, "abiItem", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		this.abiItem = abiItem;
+	}
+};
+var InvalidAbiEncodingTypeError = class extends BaseError {
+	constructor(type, { docsPath }) {
+		super([`Type "${type}" is not a valid encoding type.`, "Please provide a valid ABI type."].join("\n"), {
+			docsPath,
+			name: "InvalidAbiEncodingType"
+		});
+	}
+};
+var InvalidAbiDecodingTypeError = class extends BaseError {
+	constructor(type, { docsPath }) {
+		super([`Type "${type}" is not a valid decoding type.`, "Please provide a valid ABI type."].join("\n"), {
+			docsPath,
+			name: "InvalidAbiDecodingType"
+		});
+	}
+};
+var InvalidArrayError = class extends BaseError {
+	constructor(value) {
+		super([`Value "${value}" is not a valid array.`].join("\n"), { name: "InvalidArrayError" });
+	}
+};
+var InvalidDefinitionTypeError = class extends BaseError {
+	constructor(type) {
+		super([`"${type}" is not a valid definition type.`, "Valid types: \"function\", \"event\", \"error\""].join("\n"), { name: "InvalidDefinitionTypeError" });
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/errors/data.js
+var SliceOffsetOutOfBoundsError = class extends BaseError {
+	constructor({ offset, position, size }) {
+		super(`Slice ${position === "start" ? "starting" : "ending"} at offset "${offset}" is out-of-bounds (size: ${size}).`, { name: "SliceOffsetOutOfBoundsError" });
+	}
+};
+var SizeExceedsPaddingSizeError = class extends BaseError {
+	constructor({ size, targetSize, type }) {
+		super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
+	}
+};
+var InvalidBytesLengthError = class extends BaseError {
+	constructor({ size, targetSize, type }) {
+		super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} is expected to be ${targetSize} ${type} long, but is ${size} ${type} long.`, { name: "InvalidBytesLengthError" });
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/data/pad.js
+function pad(hexOrBytes, { dir, size = 32 } = {}) {
+	if (typeof hexOrBytes === "string") return padHex(hexOrBytes, {
+		dir,
+		size
+	});
+	return padBytes(hexOrBytes, {
+		dir,
+		size
+	});
+}
+function padHex(hex_, { dir, size = 32 } = {}) {
+	if (size === null) 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")}`;
+}
+function padBytes(bytes, { dir, size = 32 } = {}) {
+	if (size === null) return bytes;
+	if (bytes.length > size) throw new SizeExceedsPaddingSizeError({
+		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;
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/errors/encoding.js
+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})`}`, { name: "IntegerOutOfRangeError" });
+	}
+};
+var InvalidBytesBooleanError = class extends BaseError {
+	constructor(bytes) {
+		super(`Bytes value "${bytes}" is not a valid boolean. The bytes array must contain a single byte of either a 0 or 1 value.`, { name: "InvalidBytesBooleanError" });
+	}
+};
+var InvalidHexBooleanError = class extends BaseError {
+	constructor(hex) {
+		super(`Hex value "${hex}" is not a valid boolean. The hex value must be "0x0" (false) or "0x1" (true).`, { name: "InvalidHexBooleanError" });
+	}
+};
+var InvalidHexValueError = class extends BaseError {
+	constructor(value) {
+		super(`Hex value "${value}" is an odd length (${value.length}). It must be an even length.`, { name: "InvalidHexValueError" });
+	}
+};
+var SizeOverflowError = class extends BaseError {
+	constructor({ givenSize, maxSize }) {
+		super(`Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`, { name: "SizeOverflowError" });
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/data/trim.js
+function trim(hexOrBytes, { dir = "left" } = {}) {
+	let data = typeof hexOrBytes === "string" ? hexOrBytes.replace("0x", "") : hexOrBytes;
+	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 (typeof hexOrBytes === "string") {
+		if (data.length === 1 && dir === "right") data = `${data}0`;
+		return `0x${data.length % 2 === 1 ? `0${data}` : data}`;
+	}
+	return data;
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/encoding/fromHex.js
+function assertSize(hexOrBytes, { size: size$1 }) {
+	if (size(hexOrBytes) > size$1) throw new SizeOverflowError({
+		givenSize: size(hexOrBytes),
+		maxSize: size$1
+	});
+}
+/**
+* Decodes a hex value into a bigint.
+*
+* - Docs: https://viem.sh/docs/utilities/fromHex#hextobigint
+*
+* @param hex Hex value to decode.
+* @param opts Options.
+* @returns BigInt value.
+*
+* @example
+* import { hexToBigInt } from 'viem'
+* const data = hexToBigInt('0x1a4', { signed: true })
+* // 420n
+*
+* @example
+* import { hexToBigInt } from 'viem'
+* const data = hexToBigInt('0x00000000000000000000000000000000000000000000000000000000000001a4', { size: 32 })
+* // 420n
+*/
+function hexToBigInt(hex, opts = {}) {
+	const { signed } = opts;
+	if (opts.size) assertSize(hex, { size: opts.size });
+	const value = BigInt(hex);
+	if (!signed) return value;
+	const size = (hex.length - 2) / 2;
+	if (value <= (1n << BigInt(size) * 8n - 1n) - 1n) return value;
+	return value - BigInt(`0x${"f".padStart(size * 2, "f")}`) - 1n;
+}
+/**
+* Decodes a hex value into a boolean.
+*
+* - Docs: https://viem.sh/docs/utilities/fromHex#hextobool
+*
+* @param hex Hex value to decode.
+* @param opts Options.
+* @returns Boolean value.
+*
+* @example
+* import { hexToBool } from 'viem'
+* const data = hexToBool('0x01')
+* // true
+*
+* @example
+* import { hexToBool } from 'viem'
+* const data = hexToBool('0x0000000000000000000000000000000000000000000000000000000000000001', { size: 32 })
+* // true
+*/
+function hexToBool(hex_, opts = {}) {
+	let hex = hex_;
+	if (opts.size) {
+		assertSize(hex, { size: opts.size });
+		hex = trim(hex);
+	}
+	if (trim(hex) === "0x00") return false;
+	if (trim(hex) === "0x01") return true;
+	throw new InvalidHexBooleanError(hex);
+}
+/**
+* Decodes a hex string into a number.
+*
+* - Docs: https://viem.sh/docs/utilities/fromHex#hextonumber
+*
+* @param hex Hex value to decode.
+* @param opts Options.
+* @returns Number value.
+*
+* @example
+* import { hexToNumber } from 'viem'
+* const data = hexToNumber('0x1a4')
+* // 420
+*
+* @example
+* import { hexToNumber } from 'viem'
+* const data = hexToBigInt('0x00000000000000000000000000000000000000000000000000000000000001a4', { size: 32 })
+* // 420
+*/
+function hexToNumber(hex, opts = {}) {
+	const value = hexToBigInt(hex, opts);
+	const number = Number(value);
+	if (!Number.isSafeInteger(number)) throw new IntegerOutOfRangeError({
+		max: `${Number.MAX_SAFE_INTEGER}`,
+		min: `${Number.MIN_SAFE_INTEGER}`,
+		signed: opts.signed,
+		size: opts.size,
+		value: `${value}n`
+	});
+	return number;
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/encoding/toHex.js
+const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
+/**
+* Encodes a string, number, bigint, or ByteArray into a hex string
+*
+* - Docs: https://viem.sh/docs/utilities/toHex
+* - Example: https://viem.sh/docs/utilities/toHex#usage
+*
+* @param value Value to encode.
+* @param opts Options.
+* @returns Hex value.
+*
+* @example
+* import { toHex } from 'viem'
+* const data = toHex('Hello world')
+* // '0x48656c6c6f20776f726c6421'
+*
+* @example
+* import { toHex } from 'viem'
+* const data = toHex(420)
+* // '0x1a4'
+*
+* @example
+* import { toHex } from 'viem'
+* const data = toHex('Hello world', { size: 32 })
+* // '0x48656c6c6f20776f726c64210000000000000000000000000000000000000000'
+*/
+function toHex(value, opts = {}) {
+	if (typeof value === "number" || typeof value === "bigint") return numberToHex(value, opts);
+	if (typeof value === "string") return stringToHex(value, opts);
+	if (typeof value === "boolean") return boolToHex(value, opts);
+	return bytesToHex(value, opts);
+}
+/**
+* Encodes a boolean into a hex string
+*
+* - Docs: https://viem.sh/docs/utilities/toHex#booltohex
+*
+* @param value Value to encode.
+* @param opts Options.
+* @returns Hex value.
+*
+* @example
+* import { boolToHex } from 'viem'
+* const data = boolToHex(true)
+* // '0x1'
+*
+* @example
+* import { boolToHex } from 'viem'
+* const data = boolToHex(false)
+* // '0x0'
+*
+* @example
+* import { boolToHex } from 'viem'
+* const data = boolToHex(true, { size: 32 })
+* // '0x0000000000000000000000000000000000000000000000000000000000000001'
+*/
+function boolToHex(value, opts = {}) {
+	const hex = `0x${Number(value)}`;
+	if (typeof opts.size === "number") {
+		assertSize(hex, { size: opts.size });
+		return pad(hex, { size: opts.size });
+	}
+	return hex;
+}
+/**
+* Encodes a bytes array into a hex string
+*
+* - Docs: https://viem.sh/docs/utilities/toHex#bytestohex
+*
+* @param value Value to encode.
+* @param opts Options.
+* @returns Hex value.
+*
+* @example
+* import { bytesToHex } from 'viem'
+* const data = bytesToHex(Uint8Array.from([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33])
+* // '0x48656c6c6f20576f726c6421'
+*
+* @example
+* import { bytesToHex } from 'viem'
+* const data = bytesToHex(Uint8Array.from([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]), { size: 32 })
+* // '0x48656c6c6f20576f726c64210000000000000000000000000000000000000000'
+*/
+function bytesToHex(value, opts = {}) {
+	let string = "";
+	for (let i = 0; i < value.length; i++) string += hexes[value[i]];
+	const hex = `0x${string}`;
+	if (typeof opts.size === "number") {
+		assertSize(hex, { size: opts.size });
+		return pad(hex, {
+			dir: "right",
+			size: opts.size
+		});
+	}
+	return hex;
+}
+/**
+* Encodes a number or bigint into a hex string
+*
+* - Docs: https://viem.sh/docs/utilities/toHex#numbertohex
+*
+* @param value Value to encode.
+* @param opts Options.
+* @returns Hex value.
+*
+* @example
+* import { numberToHex } from 'viem'
+* const data = numberToHex(420)
+* // '0x1a4'
+*
+* @example
+* import { numberToHex } from 'viem'
+* const data = numberToHex(420, { size: 32 })
+* // '0x00000000000000000000000000000000000000000000000000000000000001a4'
+*/
+function numberToHex(value_, opts = {}) {
+	const { signed, size } = opts;
+	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 ? (1n << BigInt(size * 8)) + BigInt(value) : value).toString(16)}`;
+	if (size) return pad(hex, { size });
+	return hex;
+}
+const encoder$1 = /* @__PURE__ */ new TextEncoder();
+/**
+* Encodes a UTF-8 string into a hex string
+*
+* - Docs: https://viem.sh/docs/utilities/toHex#stringtohex
+*
+* @param value Value to encode.
+* @param opts Options.
+* @returns Hex value.
+*
+* @example
+* import { stringToHex } from 'viem'
+* const data = stringToHex('Hello World!')
+* // '0x48656c6c6f20576f726c6421'
+*
+* @example
+* import { stringToHex } from 'viem'
+* const data = stringToHex('Hello World!', { size: 32 })
+* // '0x48656c6c6f20576f726c64210000000000000000000000000000000000000000'
+*/
+function stringToHex(value_, opts = {}) {
+	return bytesToHex(encoder$1.encode(value_), opts);
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/encoding/toBytes.js
+const encoder = /* @__PURE__ */ new TextEncoder();
+/**
+* Encodes a UTF-8 string, hex value, bigint, number or boolean to a byte array.
+*
+* - Docs: https://viem.sh/docs/utilities/toBytes
+* - Example: https://viem.sh/docs/utilities/toBytes#usage
+*
+* @param value Value to encode.
+* @param opts Options.
+* @returns Byte array value.
+*
+* @example
+* import { toBytes } from 'viem'
+* const data = toBytes('Hello world')
+* // Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33])
+*
+* @example
+* import { toBytes } from 'viem'
+* const data = toBytes(420)
+* // Uint8Array([1, 164])
+*
+* @example
+* import { toBytes } from 'viem'
+* const data = toBytes(420, { size: 4 })
+* // Uint8Array([0, 0, 1, 164])
+*/
+function toBytes(value, opts = {}) {
+	if (typeof value === "number" || typeof value === "bigint") return numberToBytes(value, opts);
+	if (typeof value === "boolean") return boolToBytes(value, opts);
+	if (isHex(value)) return hexToBytes(value, opts);
+	return stringToBytes(value, opts);
+}
+/**
+* Encodes a boolean into a byte array.
+*
+* - Docs: https://viem.sh/docs/utilities/toBytes#booltobytes
+*
+* @param value Boolean value to encode.
+* @param opts Options.
+* @returns Byte array value.
+*
+* @example
+* import { boolToBytes } from 'viem'
+* const data = boolToBytes(true)
+* // Uint8Array([1])
+*
+* @example
+* import { boolToBytes } from 'viem'
+* const data = boolToBytes(true, { size: 32 })
+* // Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])
+*/
+function boolToBytes(value, opts = {}) {
+	const bytes = new Uint8Array(1);
+	bytes[0] = Number(value);
+	if (typeof opts.size === "number") {
+		assertSize(bytes, { size: opts.size });
+		return pad(bytes, { size: opts.size });
+	}
+	return bytes;
+}
+const charCodeMap = {
+	zero: 48,
+	nine: 57,
+	A: 65,
+	F: 70,
+	a: 97,
+	f: 102
+};
+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);
+}
+/**
+* Encodes a hex string into a byte array.
+*
+* - Docs: https://viem.sh/docs/utilities/toBytes#hextobytes
+*
+* @param hex Hex string to encode.
+* @param opts Options.
+* @returns Byte array value.
+*
+* @example
+* import { hexToBytes } from 'viem'
+* const data = hexToBytes('0x48656c6c6f20776f726c6421')
+* // Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33])
+*
+* @example
+* import { hexToBytes } from 'viem'
+* const data = hexToBytes('0x48656c6c6f20776f726c6421', { size: 32 })
+* // 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])
+*/
+function hexToBytes(hex_, opts = {}) {
+	let hex = hex_;
+	if (opts.size) {
+		assertSize(hex, { size: opts.size });
+		hex = pad(hex, {
+			dir: "right",
+			size: opts.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 * 16 + nibbleRight;
+	}
+	return bytes;
+}
+/**
+* Encodes a number into a byte array.
+*
+* - Docs: https://viem.sh/docs/utilities/toBytes#numbertobytes
+*
+* @param value Number to encode.
+* @param opts Options.
+* @returns Byte array value.
+*
+* @example
+* import { numberToBytes } from 'viem'
+* const data = numberToBytes(420)
+* // Uint8Array([1, 164])
+*
+* @example
+* import { numberToBytes } from 'viem'
+* const data = numberToBytes(420, { size: 4 })
+* // Uint8Array([0, 0, 1, 164])
+*/
+function numberToBytes(value, opts) {
+	return hexToBytes(numberToHex(value, opts));
+}
+/**
+* Encodes a UTF-8 string into a byte array.
+*
+* - Docs: https://viem.sh/docs/utilities/toBytes#stringtobytes
+*
+* @param value String to encode.
+* @param opts Options.
+* @returns Byte array value.
+*
+* @example
+* import { stringToBytes } from 'viem'
+* const data = stringToBytes('Hello world!')
+* // Uint8Array([72, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 33])
+*
+* @example
+* import { stringToBytes } from 'viem'
+* const data = stringToBytes('Hello world!', { size: 32 })
+* // 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])
+*/
+function stringToBytes(value, opts = {}) {
+	const bytes = encoder.encode(value);
+	if (typeof opts.size === "number") {
+		assertSize(bytes, { size: opts.size });
+		return pad(bytes, {
+			dir: "right",
+			size: opts.size
+		});
+	}
+	return bytes;
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/hash/keccak256.js
+function keccak256(value, to_) {
+	const to = to_ || "hex";
+	const bytes = keccak_256(isHex(value, { strict: false }) ? toBytes(value) : value);
+	if (to === "bytes") return bytes;
+	return toHex(bytes);
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/errors/address.js
+var InvalidAddressError = class extends BaseError {
+	constructor({ address }) {
+		super(`Address "${address}" is invalid.`, {
+			metaMessages: ["- Address must be a hex value of 20 bytes (40 hex characters).", "- Address must match its checksum counterpart."],
+			name: "InvalidAddressError"
+		});
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/lru.js
+/**
+* Map with a LRU (Least recently used) policy.
+*
+* @link https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU
+*/
+var LruMap = class extends Map {
+	constructor(size) {
+		super();
+		Object.defineProperty(this, "maxSize", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		this.maxSize = size;
+	}
+	get(key) {
+		const value = super.get(key);
+		if (super.has(key)) {
+			super.delete(key);
+			super.set(key, value);
+		}
+		return value;
+	}
+	set(key, value) {
+		if (super.has(key)) super.delete(key);
+		super.set(key, value);
+		if (this.maxSize && this.size > this.maxSize) {
+			const firstKey = super.keys().next().value;
+			if (firstKey !== void 0) super.delete(firstKey);
+		}
+		return this;
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/address/getAddress.js
+const checksumAddressCache = /* @__PURE__ */ new LruMap(8192);
+function checksumAddress(address_, chainId) {
+	if (checksumAddressCache.has(`${address_}.${chainId}`)) return checksumAddressCache.get(`${address_}.${chainId}`);
+	const hexAddress = chainId ? `${chainId}${address_.toLowerCase()}` : address_.substring(2).toLowerCase();
+	const hash = keccak256(stringToBytes(hexAddress), "bytes");
+	const address = (chainId ? hexAddress.substring(`${chainId}0x`.length) : hexAddress).split("");
+	for (let i = 0; i < 40; i += 2) {
+		if (hash[i >> 1] >> 4 >= 8 && address[i]) address[i] = address[i].toUpperCase();
+		if ((hash[i >> 1] & 15) >= 8 && address[i + 1]) address[i + 1] = address[i + 1].toUpperCase();
+	}
+	const result = `0x${address.join("")}`;
+	checksumAddressCache.set(`${address_}.${chainId}`, result);
+	return result;
+}
+function getAddress(address, chainId) {
+	if (!isAddress(address, { strict: false })) throw new InvalidAddressError({ address });
+	return checksumAddress(address, chainId);
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/address/isAddress.js
+const addressRegex = /^0x[a-fA-F0-9]{40}$/;
+/** @internal */
+const isAddressCache = /* @__PURE__ */ new LruMap(8192);
+function isAddress(address, options) {
+	const { strict = true } = options ?? {};
+	const cacheKey = `${address}.${strict}`;
+	if (isAddressCache.has(cacheKey)) return isAddressCache.get(cacheKey);
+	const result = (() => {
+		if (!addressRegex.test(address)) return false;
+		if (address.toLowerCase() === address) return true;
+		if (strict) return checksumAddress(address) === address;
+		return true;
+	})();
+	isAddressCache.set(cacheKey, result);
+	return result;
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/data/concat.js
+function concat(values) {
+	if (typeof values[0] === "string") return concatHex(values);
+	return concatBytes(values);
+}
+function concatBytes(values) {
+	let length = 0;
+	for (const arr of values) length += arr.length;
+	const result = new Uint8Array(length);
+	let offset = 0;
+	for (const arr of values) {
+		result.set(arr, offset);
+		offset += arr.length;
+	}
+	return result;
+}
+function concatHex(values) {
+	return `0x${values.reduce((acc, x) => acc + x.replace("0x", ""), "")}`;
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/data/slice.js
+/**
+* @description Returns a section of the hex or byte array given a start/end bytes offset.
+*
+* @param value The hex or byte array to slice.
+* @param start The start offset (in bytes).
+* @param end The end offset (in bytes).
+*/
+function slice(value, start, end, { strict } = {}) {
+	if (isHex(value, { strict: false })) return sliceHex(value, start, end, { strict });
+	return sliceBytes(value, start, end, { strict });
+}
+function assertStartOffset(value, start) {
+	if (typeof start === "number" && start > 0 && start > size(value) - 1) throw new SliceOffsetOutOfBoundsError({
+		offset: start,
+		position: "start",
+		size: size(value)
+	});
+}
+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)
+	});
+}
+/**
+* @description Returns a section of the byte array given a start/end bytes offset.
+*
+* @param value The byte array to slice.
+* @param start The start offset (in bytes).
+* @param end The end offset (in bytes).
+*/
+function sliceBytes(value_, start, end, { strict } = {}) {
+	assertStartOffset(value_, start);
+	const value = value_.slice(start, end);
+	if (strict) assertEndOffset(value, start, end);
+	return value;
+}
+/**
+* @description Returns a section of the hex value given a start/end bytes offset.
+*
+* @param value The hex value to slice.
+* @param start The start offset (in bytes).
+* @param end The end offset (in bytes).
+*/
+function sliceHex(value_, start, end, { strict } = {}) {
+	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;
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/regex.js
+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)?$/;
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/abi/encodeAbiParameters.js
+/**
+* @description Encodes a list of primitive values into an ABI-encoded hex value.
+*
+* - Docs: https://viem.sh/docs/abi/encodeAbiParameters#encodeabiparameters
+*
+*   Generates ABI encoded data using the [ABI specification](https://docs.soliditylang.org/en/latest/abi-spec), given a set of ABI parameters (inputs/outputs) and their corresponding values.
+*
+* @param params - a set of ABI Parameters (params), that can be in the shape of the inputs or outputs attribute of an ABI Item.
+* @param values - a set of values (values) that correspond to the given params.
+* @example
+* ```typescript
+* import { encodeAbiParameters } from 'viem'
+*
+* const encodedData = encodeAbiParameters(
+*   [
+*     { name: 'x', type: 'string' },
+*     { name: 'y', type: 'uint' },
+*     { name: 'z', type: 'bool' }
+*   ],
+*   ['wagmi', 420n, true]
+* )
+* ```
+*
+* You can also pass in Human Readable parameters with the parseAbiParameters utility.
+*
+* @example
+* ```typescript
+* import { encodeAbiParameters, parseAbiParameters } from 'viem'
+*
+* const encodedData = encodeAbiParameters(
+*   parseAbiParameters('string x, uint y, bool z'),
+*   ['wagmi', 420n, true]
+* )
+* ```
+*/
+function encodeAbiParameters(params, values) {
+	if (params.length !== values.length) throw new AbiEncodingLengthMismatchError({
+		expectedLength: params.length,
+		givenLength: values.length
+	});
+	const data = encodeParams(prepareParams({
+		params,
+		values
+	}));
+	if (data.length === 0) return "0x";
+	return data;
+}
+function prepareParams({ params, values }) {
+	const preparedParams = [];
+	for (let i = 0; i < params.length; i++) preparedParams.push(prepareParam({
+		param: params[i],
+		value: values[i]
+	}));
+	return preparedParams;
+}
+function prepareParam({ param, value }) {
+	const arrayComponents = getArrayComponents(param.type);
+	if (arrayComponents) {
+		const [length, type] = arrayComponents;
+		return encodeArray(value, {
+			length,
+			param: {
+				...param,
+				type
+			}
+		});
+	}
+	if (param.type === "tuple") return encodeTuple(value, { param });
+	if (param.type === "address") return encodeAddress(value);
+	if (param.type === "bool") return encodeBool(value);
+	if (param.type.startsWith("uint") || param.type.startsWith("int")) {
+		const signed = param.type.startsWith("int");
+		const [, , size = "256"] = integerRegex.exec(param.type) ?? [];
+		return encodeNumber(value, {
+			signed,
+			size: Number(size)
+		});
+	}
+	if (param.type.startsWith("bytes")) return encodeBytes(value, { param });
+	if (param.type === "string") return encodeString(value);
+	throw new InvalidAbiEncodingTypeError(param.type, { docsPath: "/docs/contract/encodeAbiParameters" });
+}
+function encodeParams(preparedParams) {
+	let staticSize = 0;
+	for (let i = 0; i < preparedParams.length; i++) {
+		const { dynamic, encoded } = preparedParams[i];
+		if (dynamic) staticSize += 32;
+		else staticSize += size(encoded);
+	}
+	const staticParams = [];
+	const dynamicParams = [];
+	let dynamicSize = 0;
+	for (let i = 0; i < preparedParams.length; i++) {
+		const { dynamic, encoded } = preparedParams[i];
+		if (dynamic) {
+			staticParams.push(numberToHex(staticSize + dynamicSize, { size: 32 }));
+			dynamicParams.push(encoded);
+			dynamicSize += size(encoded);
+		} else staticParams.push(encoded);
+	}
+	return concat([...staticParams, ...dynamicParams]);
+}
+function encodeAddress(value) {
+	if (!isAddress(value)) throw new InvalidAddressError({ address: value });
+	return {
+		dynamic: false,
+		encoded: padHex(value.toLowerCase())
+	};
+}
+function encodeArray(value, { length, param }) {
+	const dynamic = length === null;
+	if (!Array.isArray(value)) throw new InvalidArrayError(value);
+	if (!dynamic && value.length !== length) throw new AbiEncodingArrayLengthMismatchError({
+		expectedLength: length,
+		givenLength: value.length,
+		type: `${param.type}[${length}]`
+	});
+	let dynamicChild = false;
+	const preparedParams = [];
+	for (let i = 0; i < value.length; i++) {
+		const preparedParam = prepareParam({
+			param,
+			value: value[i]
+		});
+		if (preparedParam.dynamic) dynamicChild = true;
+		preparedParams.push(preparedParam);
+	}
+	if (dynamic || dynamicChild) {
+		const data = encodeParams(preparedParams);
+		if (dynamic) {
+			const length = numberToHex(preparedParams.length, { size: 32 });
+			return {
+				dynamic: true,
+				encoded: preparedParams.length > 0 ? concat([length, data]) : length
+			};
+		}
+		if (dynamicChild) return {
+			dynamic: true,
+			encoded: data
+		};
+	}
+	return {
+		dynamic: false,
+		encoded: concat(preparedParams.map(({ encoded }) => encoded))
+	};
+}
+function encodeBytes(value, { param }) {
+	const [, paramSize] = param.type.split("bytes");
+	const bytesSize = size(value);
+	if (!paramSize) {
+		let value_ = value;
+		if (bytesSize % 32 !== 0) value_ = padHex(value_, {
+			dir: "right",
+			size: Math.ceil((value.length - 2) / 2 / 32) * 32
+		});
+		return {
+			dynamic: true,
+			encoded: concat([padHex(numberToHex(bytesSize, { size: 32 })), value_])
+		};
+	}
+	if (bytesSize !== Number.parseInt(paramSize, 10)) throw new AbiEncodingBytesSizeMismatchError({
+		expectedSize: Number.parseInt(paramSize, 10),
+		value
+	});
+	return {
+		dynamic: false,
+		encoded: padHex(value, { dir: "right" })
+	};
+}
+function encodeBool(value) {
+	if (typeof value !== "boolean") throw new BaseError(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
+	return {
+		dynamic: false,
+		encoded: padHex(boolToHex(value))
+	};
+}
+function encodeNumber(value, { signed, size = 256 }) {
+	if (typeof size === "number") {
+		const max = 2n ** (BigInt(size) - (signed ? 1n : 0n)) - 1n;
+		const min = signed ? -max - 1n : 0n;
+		if (value > max || value < min) throw new IntegerOutOfRangeError({
+			max: max.toString(),
+			min: min.toString(),
+			signed,
+			size: size / 8,
+			value: value.toString()
+		});
+	}
+	return {
+		dynamic: false,
+		encoded: numberToHex(value, {
+			size: 32,
+			signed
+		})
+	};
+}
+function encodeString(value) {
+	const hexValue = stringToHex(value);
+	const partsLength = Math.ceil(size(hexValue) / 32);
+	const parts = [];
+	for (let i = 0; i < partsLength; i++) parts.push(padHex(slice(hexValue, i * 32, (i + 1) * 32), { dir: "right" }));
+	return {
+		dynamic: true,
+		encoded: concat([padHex(numberToHex(size(hexValue), { size: 32 })), ...parts])
+	};
+}
+function encodeTuple(value, { param }) {
+	let dynamic = false;
+	const preparedParams = [];
+	for (let i = 0; i < param.components.length; i++) {
+		const param_ = param.components[i];
+		const preparedParam = prepareParam({
+			param: param_,
+			value: value[Array.isArray(value) ? i : param_.name]
+		});
+		preparedParams.push(preparedParam);
+		if (preparedParam.dynamic) dynamic = true;
+	}
+	return {
+		dynamic,
+		encoded: dynamic ? encodeParams(preparedParams) : concat(preparedParams.map(({ encoded }) => encoded))
+	};
+}
+function getArrayComponents(type) {
+	const matches = type.match(/^(.*)\[(\d+)?\]$/);
+	return matches ? [matches[2] ? Number(matches[2]) : null, matches[1]] : void 0;
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/accounts/utils/parseAccount.js
+function parseAccount(account) {
+	if (typeof account === "string") return {
+		address: account,
+		type: "json-rpc"
+	};
+	return account;
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/errors/cursor.js
+var NegativeOffsetError = class extends BaseError {
+	constructor({ offset }) {
+		super(`Offset \`${offset}\` cannot be negative.`, { name: "NegativeOffsetError" });
+	}
+};
+var PositionOutOfBoundsError = class extends BaseError {
+	constructor({ length, position }) {
+		super(`Position \`${position}\` is out of bounds (\`0 < position < ${length}\`).`, { name: "PositionOutOfBoundsError" });
+	}
+};
+var RecursiveReadLimitExceededError = class extends BaseError {
+	constructor({ count, limit }) {
+		super(`Recursive read limit of \`${limit}\` exceeded (recursive read count: \`${count}\`).`, { name: "RecursiveReadLimitExceededError" });
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/cursor.js
+const staticCursor = {
+	bytes: new Uint8Array(),
+	dataView: /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(0)),
+	position: 0,
+	positionReadCount: /* @__PURE__ */ new Map(),
+	recursiveReadCount: 0,
+	recursiveReadLimit: Number.POSITIVE_INFINITY,
+	assertReadLimit() {
+		if (this.recursiveReadCount >= this.recursiveReadLimit) throw new RecursiveReadLimitExceededError({
+			count: this.recursiveReadCount + 1,
+			limit: this.recursiveReadLimit
+		});
+	},
+	assertPosition(position) {
+		if (position < 0 || position > this.bytes.length - 1) throw new PositionOutOfBoundsError({
+			length: this.bytes.length,
+			position
+		});
+	},
+	decrementPosition(offset) {
+		if (offset < 0) throw new NegativeOffsetError({ offset });
+		const position = this.position - offset;
+		this.assertPosition(position);
+		this.position = position;
+	},
+	getReadCount(position) {
+		return this.positionReadCount.get(position || this.position) || 0;
+	},
+	incrementPosition(offset) {
+		if (offset < 0) throw new NegativeOffsetError({ offset });
+		const position = this.position + offset;
+		this.assertPosition(position);
+		this.position = position;
+	},
+	inspectByte(position_) {
+		const position = position_ ?? this.position;
+		this.assertPosition(position);
+		return this.bytes[position];
+	},
+	inspectBytes(length, position_) {
+		const position = position_ ?? this.position;
+		this.assertPosition(position + length - 1);
+		return this.bytes.subarray(position, position + length);
+	},
+	inspectUint8(position_) {
+		const position = position_ ?? this.position;
+		this.assertPosition(position);
+		return this.bytes[position];
+	},
+	inspectUint16(position_) {
+		const position = position_ ?? this.position;
+		this.assertPosition(position + 1);
+		return this.dataView.getUint16(position);
+	},
+	inspectUint24(position_) {
+		const position = position_ ?? this.position;
+		this.assertPosition(position + 2);
+		return (this.dataView.getUint16(position) << 8) + this.dataView.getUint8(position + 2);
+	},
+	inspectUint32(position_) {
+		const position = position_ ?? this.position;
+		this.assertPosition(position + 3);
+		return this.dataView.getUint32(position);
+	},
+	pushByte(byte) {
+		this.assertPosition(this.position);
+		this.bytes[this.position] = byte;
+		this.position++;
+	},
+	pushBytes(bytes) {
+		this.assertPosition(this.position + bytes.length - 1);
+		this.bytes.set(bytes, this.position);
+		this.position += bytes.length;
+	},
+	pushUint8(value) {
+		this.assertPosition(this.position);
+		this.bytes[this.position] = value;
+		this.position++;
+	},
+	pushUint16(value) {
+		this.assertPosition(this.position + 1);
+		this.dataView.setUint16(this.position, value);
+		this.position += 2;
+	},
+	pushUint24(value) {
+		this.assertPosition(this.position + 2);
+		this.dataView.setUint16(this.position, value >> 8);
+		this.dataView.setUint8(this.position + 2, value & 255);
+		this.position += 3;
+	},
+	pushUint32(value) {
+		this.assertPosition(this.position + 3);
+		this.dataView.setUint32(this.position, value);
+		this.position += 4;
+	},
+	readByte() {
+		this.assertReadLimit();
+		this._touch();
+		const value = this.inspectByte();
+		this.position++;
+		return value;
+	},
+	readBytes(length, size) {
+		this.assertReadLimit();
+		this._touch();
+		const value = this.inspectBytes(length);
+		this.position += size ?? length;
+		return value;
+	},
+	readUint8() {
+		this.assertReadLimit();
+		this._touch();
+		const value = this.inspectUint8();
+		this.position += 1;
+		return value;
+	},
+	readUint16() {
+		this.assertReadLimit();
+		this._touch();
+		const value = this.inspectUint16();
+		this.position += 2;
+		return value;
+	},
+	readUint24() {
+		this.assertReadLimit();
+		this._touch();
+		const value = this.inspectUint24();
+		this.position += 3;
+		return value;
+	},
+	readUint32() {
+		this.assertReadLimit();
+		this._touch();
+		const value = this.inspectUint32();
+		this.position += 4;
+		return value;
+	},
+	get remaining() {
+		return this.bytes.length - this.position;
+	},
+	setPosition(position) {
+		const oldPosition = this.position;
+		this.assertPosition(position);
+		this.position = position;
+		return () => this.position = oldPosition;
+	},
+	_touch() {
+		if (this.recursiveReadLimit === Number.POSITIVE_INFINITY) return;
+		const count = this.getReadCount();
+		this.positionReadCount.set(this.position, count + 1);
+		if (count > 0) this.recursiveReadCount++;
+	}
+};
+function createCursor(bytes, { recursiveReadLimit = 8192 } = {}) {
+	const cursor = Object.create(staticCursor);
+	cursor.bytes = bytes;
+	cursor.dataView = new DataView(bytes.buffer ?? bytes, bytes.byteOffset, bytes.byteLength);
+	cursor.positionReadCount = /* @__PURE__ */ new Map();
+	cursor.recursiveReadLimit = recursiveReadLimit;
+	return cursor;
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/stringify.js
+const stringify = (value, replacer, space) => JSON.stringify(value, (key, value_) => {
+	const value = typeof value_ === "bigint" ? value_.toString() : value_;
+	return typeof replacer === "function" ? replacer(key, value) : value;
+}, space);
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/constants/unit.js
+const etherUnits = {
+	gwei: 9,
+	wei: 18
+};
+const gweiUnits = {
+	ether: -9,
+	wei: 9
+};
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/unit/formatUnits.js
+/**
+*  Divides a number by a given exponent of base 10 (10exponent), and formats it into a string representation of the number..
+*
+* - Docs: https://viem.sh/docs/utilities/formatUnits
+*
+* @example
+* import { formatUnits } from 'viem'
+*
+* formatUnits(420000000000n, 9)
+* // '420'
+*/
+function formatUnits(value, decimals) {
+	let display = value.toString();
+	const negative = display.startsWith("-");
+	if (negative) display = display.slice(1);
+	display = display.padStart(decimals, "0");
+	let [integer, fraction] = [display.slice(0, display.length - decimals), display.slice(display.length - decimals)];
+	fraction = fraction.replace(/(0+)$/, "");
+	return `${negative ? "-" : ""}${integer || "0"}${fraction ? `.${fraction}` : ""}`;
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/unit/formatEther.js
+/**
+* Converts numerical wei to a string representation of ether.
+*
+* - Docs: https://viem.sh/docs/utilities/formatEther
+*
+* @example
+* import { formatEther } from 'viem'
+*
+* formatEther(1000000000000000000n)
+* // '1'
+*/
+function formatEther(wei, unit = "wei") {
+	return formatUnits(wei, etherUnits[unit]);
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/unit/formatGwei.js
+/**
+* Converts numerical wei to a string representation of gwei.
+*
+* - Docs: https://viem.sh/docs/utilities/formatGwei
+*
+* @example
+* import { formatGwei } from 'viem'
+*
+* formatGwei(1000000000n)
+* // '1'
+*/
+function formatGwei(wei, unit = "wei") {
+	return formatUnits(wei, gweiUnits[unit]);
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/errors/transaction.js
+function prettyPrint(args) {
+	const entries = Object.entries(args).map(([key, value]) => {
+		if (value === void 0 || value === false) return null;
+		return [key, value];
+	}).filter(Boolean);
+	const maxLength = entries.reduce((acc, [key]) => Math.max(acc, key.length), 0);
+	return entries.map(([key, value]) => `  ${`${key}:`.padEnd(maxLength + 1)}  ${value}`).join("\n");
+}
+var InvalidLegacyVError = class extends BaseError {
+	constructor({ v }) {
+		super(`Invalid \`v\` value "${v}". Expected 27 or 28.`, { name: "InvalidLegacyVError" });
+	}
+};
+var InvalidSerializableTransactionError = class extends BaseError {
+	constructor({ transaction }) {
+		super("Cannot infer a transaction type from provided transaction.", {
+			metaMessages: [
+				"Provided Transaction:",
+				"{",
+				prettyPrint(transaction),
+				"}",
+				"",
+				"To infer the type, either provide:",
+				"- a `type` to the Transaction, or",
+				"- an EIP-1559 Transaction with `maxFeePerGas`, or",
+				"- an EIP-2930 Transaction with `gasPrice` & `accessList`, or",
+				"- an EIP-4844 Transaction with `blobs`, `blobVersionedHashes`, `sidecars`, or",
+				"- an EIP-7702 Transaction with `authorizationList`, or",
+				"- a Legacy Transaction with `gasPrice`"
+			],
+			name: "InvalidSerializableTransactionError"
+		});
+	}
+};
+var InvalidSerializedTransactionTypeError = class extends BaseError {
+	constructor({ serializedType }) {
+		super(`Serialized transaction type "${serializedType}" is invalid.`, { name: "InvalidSerializedTransactionType" });
+		Object.defineProperty(this, "serializedType", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		this.serializedType = serializedType;
+	}
+};
+var InvalidSerializedTransactionError = class extends BaseError {
+	constructor({ attributes, serializedTransaction, type }) {
+		const missing = Object.entries(attributes).map(([key, value]) => typeof value === "undefined" ? key : void 0).filter(Boolean);
+		super(`Invalid serialized transaction of type "${type}" was provided.`, {
+			metaMessages: [`Serialized Transaction: "${serializedTransaction}"`, missing.length > 0 ? `Missing Attributes: ${missing.join(", ")}` : ""].filter(Boolean),
+			name: "InvalidSerializedTransactionError"
+		});
+		Object.defineProperty(this, "serializedTransaction", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		Object.defineProperty(this, "type", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		this.serializedTransaction = serializedTransaction;
+		this.type = type;
+	}
+};
+var InvalidStorageKeySizeError = class extends BaseError {
+	constructor({ storageKey }) {
+		super(`Size for storage key "${storageKey}" is invalid. Expected 32 bytes. Got ${Math.floor((storageKey.length - 2) / 2)} bytes.`, { name: "InvalidStorageKeySizeError" });
+	}
+};
+var TransactionExecutionError = class extends BaseError {
+	constructor(cause, { account, docsPath, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value }) {
+		const prettyArgs = prettyPrint({
+			chain: chain && `${chain?.name} (id: ${chain?.id})`,
+			from: account?.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
+		});
+		super(cause.shortMessage, {
+			cause,
+			docsPath,
+			metaMessages: [
+				...cause.metaMessages ? [...cause.metaMessages, " "] : [],
+				"Request Arguments:",
+				prettyArgs
+			].filter(Boolean),
+			name: "TransactionExecutionError"
+		});
+		Object.defineProperty(this, "cause", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		this.cause = cause;
+	}
+};
+var TransactionReceiptRevertedError = class extends BaseError {
+	constructor({ receipt }) {
+		super(`Transaction with hash "${receipt.transactionHash}" reverted.`, {
+			metaMessages: [
+				"The receipt marked the transaction as \"reverted\". This could mean that the function on the contract you are trying to call threw an error.",
+				" ",
+				"You can attempt to extract the revert reason by:",
+				"- calling the `simulateContract` or `simulateCalls` Action with the `abi` and `functionName` of the contract",
+				"- using the `call` Action with raw `data`"
+			],
+			name: "TransactionReceiptRevertedError"
+		});
+		Object.defineProperty(this, "receipt", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		this.receipt = receipt;
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/errors/node.js
+var ExecutionRevertedError = class extends BaseError {
+	constructor({ cause, message } = {}) {
+		const reason = message?.replace("execution reverted: ", "")?.replace("execution reverted", "");
+		super(`Execution reverted ${reason ? `with reason: ${reason}` : "for an unknown reason"}.`, {
+			cause,
+			name: "ExecutionRevertedError"
+		});
+	}
+};
+Object.defineProperty(ExecutionRevertedError, "code", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: 3
+});
+Object.defineProperty(ExecutionRevertedError, "nodeMessage", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: /execution reverted|gas required exceeds allowance/
+});
+var FeeCapTooHighError = class extends BaseError {
+	constructor({ cause, maxFeePerGas } = {}) {
+		super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}) cannot be higher than the maximum allowed value (2^256-1).`, {
+			cause,
+			name: "FeeCapTooHighError"
+		});
+	}
+};
+Object.defineProperty(FeeCapTooHighError, "nodeMessage", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: /max fee per gas higher than 2\^256-1|fee cap higher than 2\^256-1/
+});
+var FeeCapTooLowError = class extends BaseError {
+	constructor({ cause, maxFeePerGas } = {}) {
+		super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)}` : ""} gwei) cannot be lower than the block base fee.`, {
+			cause,
+			name: "FeeCapTooLowError"
+		});
+	}
+};
+Object.defineProperty(FeeCapTooLowError, "nodeMessage", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: /max fee per gas less than block base fee|fee cap less than block base fee|transaction is outdated/
+});
+var NonceTooHighError = class extends BaseError {
+	constructor({ cause, nonce } = {}) {
+		super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is higher than the next one expected.`, {
+			cause,
+			name: "NonceTooHighError"
+		});
+	}
+};
+Object.defineProperty(NonceTooHighError, "nodeMessage", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: /nonce too high/
+});
+var NonceTooLowError = class extends BaseError {
+	constructor({ cause, nonce } = {}) {
+		super([`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is lower than the current nonce of the account.`, "Try increasing the nonce or find the latest nonce with `getTransactionCount`."].join("\n"), {
+			cause,
+			name: "NonceTooLowError"
+		});
+	}
+};
+Object.defineProperty(NonceTooLowError, "nodeMessage", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: /nonce too low|transaction already imported|already known/
+});
+var NonceMaxValueError = class extends BaseError {
+	constructor({ cause, nonce } = {}) {
+		super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}exceeds the maximum allowed nonce.`, {
+			cause,
+			name: "NonceMaxValueError"
+		});
+	}
+};
+Object.defineProperty(NonceMaxValueError, "nodeMessage", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: /nonce has max value/
+});
+var InsufficientFundsError = class extends BaseError {
+	constructor({ cause } = {}) {
+		super(["The total cost (gas * gas fee + value) of executing this transaction exceeds the balance of the account."].join("\n"), {
+			cause,
+			metaMessages: [
+				"This error could arise when the account does not have enough funds to:",
+				" - pay for the total gas fee,",
+				" - pay for the value to send.",
+				" ",
+				"The cost of the transaction is calculated as `gas * gas fee + value`, where:",
+				" - `gas` is the amount of gas needed for transaction to execute,",
+				" - `gas fee` is the gas fee,",
+				" - `value` is the amount of ether to send to the recipient."
+			],
+			name: "InsufficientFundsError"
+		});
+	}
+};
+Object.defineProperty(InsufficientFundsError, "nodeMessage", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: /insufficient funds|exceeds transaction sender account balance/
+});
+var IntrinsicGasTooHighError = class extends BaseError {
+	constructor({ cause, gas } = {}) {
+		super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction exceeds the limit allowed for the block.`, {
+			cause,
+			name: "IntrinsicGasTooHighError"
+		});
+	}
+};
+Object.defineProperty(IntrinsicGasTooHighError, "nodeMessage", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: /intrinsic gas too high|gas limit reached/
+});
+var IntrinsicGasTooLowError = class extends BaseError {
+	constructor({ cause, gas } = {}) {
+		super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction is too low.`, {
+			cause,
+			name: "IntrinsicGasTooLowError"
+		});
+	}
+};
+Object.defineProperty(IntrinsicGasTooLowError, "nodeMessage", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: /intrinsic gas too low/
+});
+var TransactionTypeNotSupportedError = class extends BaseError {
+	constructor({ cause }) {
+		super("The transaction type is not supported for this chain.", {
+			cause,
+			name: "TransactionTypeNotSupportedError"
+		});
+	}
+};
+Object.defineProperty(TransactionTypeNotSupportedError, "nodeMessage", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: /transaction type not valid/
+});
+var TipAboveFeeCapError = class extends BaseError {
+	constructor({ cause, maxPriorityFeePerGas, maxFeePerGas } = {}) {
+		super([`The provided tip (\`maxPriorityFeePerGas\`${maxPriorityFeePerGas ? ` = ${formatGwei(maxPriorityFeePerGas)} gwei` : ""}) cannot be higher than the fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}).`].join("\n"), {
+			cause,
+			name: "TipAboveFeeCapError"
+		});
+	}
+};
+Object.defineProperty(TipAboveFeeCapError, "nodeMessage", {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: /max priority fee per gas higher than max fee per gas|tip higher than fee cap/
+});
+var UnknownNodeError = class extends BaseError {
+	constructor({ cause }) {
+		super(`An error occurred while executing: ${cause?.shortMessage}`, {
+			cause,
+			name: "UnknownNodeError"
+		});
+	}
+};
+2n ** (8n - 1n) - 1n;
+2n ** (16n - 1n) - 1n;
+2n ** (24n - 1n) - 1n;
+2n ** (32n - 1n) - 1n;
+2n ** (40n - 1n) - 1n;
+2n ** (48n - 1n) - 1n;
+2n ** (56n - 1n) - 1n;
+2n ** (64n - 1n) - 1n;
+2n ** (72n - 1n) - 1n;
+2n ** (80n - 1n) - 1n;
+2n ** (88n - 1n) - 1n;
+2n ** (96n - 1n) - 1n;
+2n ** (104n - 1n) - 1n;
+2n ** (112n - 1n) - 1n;
+2n ** (120n - 1n) - 1n;
+2n ** (128n - 1n) - 1n;
+2n ** (136n - 1n) - 1n;
+2n ** (144n - 1n) - 1n;
+2n ** (152n - 1n) - 1n;
+2n ** (160n - 1n) - 1n;
+2n ** (168n - 1n) - 1n;
+2n ** (176n - 1n) - 1n;
+2n ** (184n - 1n) - 1n;
+2n ** (192n - 1n) - 1n;
+2n ** (200n - 1n) - 1n;
+2n ** (208n - 1n) - 1n;
+2n ** (216n - 1n) - 1n;
+2n ** (224n - 1n) - 1n;
+2n ** (232n - 1n) - 1n;
+2n ** (240n - 1n) - 1n;
+2n ** (248n - 1n) - 1n;
+2n ** (256n - 1n) - 1n;
+-(2n ** (8n - 1n));
+-(2n ** (16n - 1n));
+-(2n ** (24n - 1n));
+-(2n ** (32n - 1n));
+-(2n ** (40n - 1n));
+-(2n ** (48n - 1n));
+-(2n ** (56n - 1n));
+-(2n ** (64n - 1n));
+-(2n ** (72n - 1n));
+-(2n ** (80n - 1n));
+-(2n ** (88n - 1n));
+-(2n ** (96n - 1n));
+-(2n ** (104n - 1n));
+-(2n ** (112n - 1n));
+-(2n ** (120n - 1n));
+-(2n ** (128n - 1n));
+-(2n ** (136n - 1n));
+-(2n ** (144n - 1n));
+-(2n ** (152n - 1n));
+-(2n ** (160n - 1n));
+-(2n ** (168n - 1n));
+-(2n ** (176n - 1n));
+-(2n ** (184n - 1n));
+-(2n ** (192n - 1n));
+-(2n ** (200n - 1n));
+-(2n ** (208n - 1n));
+-(2n ** (216n - 1n));
+-(2n ** (224n - 1n));
+-(2n ** (232n - 1n));
+-(2n ** (240n - 1n));
+-(2n ** (248n - 1n));
+-(2n ** (256n - 1n));
+const maxUint256 = 2n ** 256n - 1n;
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/errors/chain.js
+var ChainDoesNotSupportContract = class extends BaseError {
+	constructor({ blockNumber, chain, contract }) {
+		super(`Chain "${chain.name}" does not support contract "${contract.name}".`, {
+			metaMessages: ["This could be due to any of the following:", ...blockNumber && contract.blockCreated && contract.blockCreated > blockNumber ? [`- The contract "${contract.name}" was not deployed until block ${contract.blockCreated} (current block ${blockNumber}).`] : [`- The chain does not have the contract "${contract.name}" configured.`]],
+			name: "ChainDoesNotSupportContract"
+		});
+	}
+};
+var ChainMismatchError = class extends BaseError {
+	constructor({ chain, currentChainId }) {
+		super(`The current chain of the wallet (id: ${currentChainId}) does not match the target chain for the transaction (id: ${chain.id} – ${chain.name}).`, {
+			metaMessages: [`Current Chain ID:  ${currentChainId}`, `Expected Chain ID: ${chain.id} – ${chain.name}`],
+			name: "ChainMismatchError"
+		});
+	}
+};
+var ChainNotFoundError = class extends BaseError {
+	constructor() {
+		super(["No chain was provided to the request.", "Please provide a chain with the `chain` argument on the Action, or by supplying a `chain` to WalletClient."].join("\n"), { name: "ChainNotFoundError" });
+	}
+};
+var ClientChainNotConfiguredError = class extends BaseError {
+	constructor() {
+		super("No chain was provided to the Client.", { name: "ClientChainNotConfiguredError" });
+	}
+};
+var InvalidChainIdError = class extends BaseError {
+	constructor({ chainId }) {
+		super(typeof chainId === "number" ? `Chain ID "${chainId}" is invalid.` : "Chain ID is invalid.", { name: "InvalidChainIdError" });
+	}
+};
+//#endregion
+export { toHex as $, createCursor as A, formatAbiItem as At, concat as B, InvalidStorageKeySizeError as C, DecodeLogDataMismatch as Ct, formatGwei as D, BaseError as Dt, prettyPrint as E, InvalidArrayError as Et, bytesRegex as F, LruMap as G, isAddress as H, integerRegex as I, hexToBytes as J, InvalidAddressError as K, slice as L, parseAccount as M, encodeAbiParameters as N, formatEther as O, size as Ot, getArrayComponents as P, stringToHex as Q, sliceBytes as R, InvalidSerializedTransactionTypeError as S, BytesSizeMismatchError as St, TransactionReceiptRevertedError as T, InvalidAbiDecodingTypeError as Tt, checksumAddress as U, concatHex as V, getAddress as W, bytesToHex as X, toBytes as Y, numberToHex as Z, TransactionTypeNotSupportedError as _, AbiEventSignatureNotFoundError as _t, InvalidChainIdError as a, InvalidBytesBooleanError as at, InvalidSerializableTransactionError as b, AbiFunctionSignatureNotFoundError as bt, FeeCapTooHighError as c, InvalidBytesLengthError as ct, IntrinsicGasTooHighError as d, AbiDecodingDataSizeTooSmallError as dt, assertSize as et, IntrinsicGasTooLowError as f, AbiDecodingZeroDataError as ft, TipAboveFeeCapError as g, AbiEventSignatureEmptyTopicsError as gt, NonceTooLowError as h, AbiErrorSignatureNotFoundError as ht, ClientChainNotConfiguredError as i, trim as it, PositionOutOfBoundsError as j, stringify as k, isHex as kt, FeeCapTooLowError as l, AbiConstructorNotFoundError as lt, NonceTooHighError as m, AbiErrorNotFoundError as mt, ChainMismatchError as n, hexToBool as nt, maxUint256 as o, InvalidHexValueError as ot, NonceMaxValueError as p, AbiErrorInputsNotFoundError as pt, keccak256 as q, ChainNotFoundError as r, hexToNumber as rt, ExecutionRevertedError as s, padHex as st, ChainDoesNotSupportContract as t, hexToBigInt as tt, InsufficientFundsError as u, AbiConstructorParamsNotFoundError as ut, UnknownNodeError as v, AbiFunctionNotFoundError as vt, TransactionExecutionError as w, DecodeLogTopicsMismatch as wt, InvalidSerializedTransactionError as x, AbiItemAmbiguityError as xt, InvalidLegacyVError as y, AbiFunctionOutputsNotFoundError as yt, sliceHex as z };