@capxul/cli 4.20.0-beta.3 → 4.20.0-beta.30

package/dist/record-U7Yu4KQP.mjs

@@ -0,0 +1,1295 @@
+import { a as anumber, h as u32, l as createHasher, m as toBytes$1, n as abytes, o as aoutput, p as swap32IfBE, r as aexists, s as clean, t as Hash } from "./utils-DmKXBQjM.mjs";
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/errors/version.js
+const version = "2.55.18";
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/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.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/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 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.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/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.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/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.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/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.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/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" });
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/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.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/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.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/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 = /* @__PURE__ */ 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.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/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 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 = hexToNumber('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.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/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.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/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.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/utils/cursor.js
+const staticCursor = {
+	bytes: /* @__PURE__ */ 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.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/utils/encoding/toRlp.js
+function toRlp(bytes, to = "hex") {
+	const encodable = getEncodable(bytes);
+	const cursor = createCursor(new Uint8Array(encodable.length));
+	encodable.encode(cursor);
+	if (to === "hex") return bytesToHex(cursor.bytes);
+	return cursor.bytes;
+}
+function getEncodable(bytes) {
+	if (Array.isArray(bytes)) return getEncodableList(bytes.map((x) => getEncodable(x)));
+	return getEncodableBytes(bytes);
+}
+function getEncodableList(list) {
+	const bodyLength = list.reduce((acc, x) => acc + x.length, 0);
+	const sizeOfBodyLength = getSizeOfLength(bodyLength);
+	return {
+		length: (() => {
+			if (bodyLength <= 55) return 1 + bodyLength;
+			return 1 + sizeOfBodyLength + bodyLength;
+		})(),
+		encode(cursor) {
+			if (bodyLength <= 55) cursor.pushByte(192 + bodyLength);
+			else {
+				cursor.pushByte(247 + sizeOfBodyLength);
+				if (sizeOfBodyLength === 1) cursor.pushUint8(bodyLength);
+				else if (sizeOfBodyLength === 2) cursor.pushUint16(bodyLength);
+				else if (sizeOfBodyLength === 3) cursor.pushUint24(bodyLength);
+				else cursor.pushUint32(bodyLength);
+			}
+			for (const { encode } of list) encode(cursor);
+		}
+	};
+}
+function getEncodableBytes(bytesOrHex) {
+	const bytes = typeof bytesOrHex === "string" ? hexToBytes(bytesOrHex) : bytesOrHex;
+	const sizeOfBytesLength = getSizeOfLength(bytes.length);
+	return {
+		length: (() => {
+			if (bytes.length === 1 && bytes[0] < 128) return 1;
+			if (bytes.length <= 55) return 1 + bytes.length;
+			return 1 + sizeOfBytesLength + bytes.length;
+		})(),
+		encode(cursor) {
+			if (bytes.length === 1 && bytes[0] < 128) cursor.pushBytes(bytes);
+			else if (bytes.length <= 55) {
+				cursor.pushByte(128 + bytes.length);
+				cursor.pushBytes(bytes);
+			} else {
+				cursor.pushByte(183 + sizeOfBytesLength);
+				if (sizeOfBytesLength === 1) cursor.pushUint8(bytes.length);
+				else if (sizeOfBytesLength === 2) cursor.pushUint16(bytes.length);
+				else if (sizeOfBytesLength === 3) cursor.pushUint24(bytes.length);
+				else cursor.pushUint32(bytes.length);
+				cursor.pushBytes(bytes);
+			}
+		}
+	};
+}
+function getSizeOfLength(length) {
+	if (length < 256) return 1;
+	if (length < 2 ** 16) return 2;
+	if (length < 2 ** 24) return 3;
+	if (length < 2 ** 32) return 4;
+	throw new BaseError("Length is too large.");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/node_modules/viem/_esm/utils/unit/Value.js
+/** @see https://ethereum.github.io/yellowpaper/paper.pdf */
+const exponents = {
+	wei: 0,
+	gwei: 9,
+	szabo: 12,
+	finney: 15,
+	ether: 18
+};
+/**
+* Formats a `bigint` Value to its string representation (divided by the given exponent).
+*
+* @example
+* ```ts twoslash
+* import { Value } from 'ox'
+*
+* Value.format(420_000_000_000n, 9)
+* // @log: '420'
+* ```
+*
+* @param value - The `bigint` Value to format.
+* @param decimals - The exponent to divide the `bigint` Value by.
+* @returns The string representation of the Value.
+*/
+function format(value, decimals = 0) {
+	if (!Number.isInteger(decimals) || decimals < 0) throw new InvalidDecimalsError({ 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}` : ""}`;
+}
+/**
+* Formats a `bigint` Value (default: wei) to a string representation of Gwei.
+*
+* @example
+* ```ts twoslash
+* import { Value } from 'ox'
+*
+* Value.formatGwei(1_000_000_000n)
+* // @log: '1'
+* ```
+*
+* @param wei - The Value to format.
+* @param unit - The unit to format the Value in. @default 'wei'.
+* @returns The Gwei string representation of the Value.
+*/
+function formatGwei(wei, unit = "wei") {
+	return format(wei, exponents.gwei - exponents[unit]);
+}
+/**
+* Thrown when the `decimals` argument is not a non-negative integer.
+*
+* @example
+* ```ts twoslash
+* import { Value } from 'ox'
+*
+* Value.from('1', -1)
+* // @error: Value.InvalidDecimalsError: `decimals` must be a non-negative integer. Got `-1`.
+* ```
+*/
+var InvalidDecimalsError = class extends Error {
+	constructor({ decimals }) {
+		super(`\`decimals\` must be a non-negative integer. Got \`${decimals}\`.`);
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Value.InvalidDecimalsError"
+		});
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/_u64.js
+/**
+* Internal helpers for u64. BigUint64Array is too slow as per 2025, so we implement it using Uint32Array.
+* @todo re-check https://issues.chromium.org/issues/42212588
+* @module
+*/
+const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+const _32n = /* @__PURE__ */ BigInt(32);
+function fromBig(n, le = false) {
+	if (le) return {
+		h: Number(n & U32_MASK64),
+		l: Number(n >> _32n & U32_MASK64)
+	};
+	return {
+		h: Number(n >> _32n & U32_MASK64) | 0,
+		l: Number(n & U32_MASK64) | 0
+	};
+}
+function split(lst, le = false) {
+	const len = lst.length;
+	let Ah = new Uint32Array(len);
+	let Al = new Uint32Array(len);
+	for (let i = 0; i < len; i++) {
+		const { h, l } = fromBig(lst[i], le);
+		[Ah[i], Al[i]] = [h, l];
+	}
+	return [Ah, Al];
+}
+const rotlSH = (h, l, s) => h << s | l >>> 32 - s;
+const rotlSL = (h, l, s) => l << s | h >>> 32 - s;
+const rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
+const rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/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.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/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/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/sha3.js
+/**
+* SHA3 (keccak) hash function, based on a new "Sponge function" design.
+* Different from older hashes, the internal state is bigger than output size.
+*
+* Check out [FIPS-202](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.202.pdf),
+* [Website](https://keccak.team/keccak.html),
+* [the differences between SHA-3 and Keccak](https://crypto.stackexchange.com/questions/15727/what-are-the-key-differences-between-the-draft-sha-3-standard-and-the-keccak-sub).
+*
+* Check out `sha3-addons` module for cSHAKE, k12, and others.
+* @module
+*/
+const _0n = BigInt(0);
+const _1n = BigInt(1);
+const _2n = BigInt(2);
+const _7n = BigInt(7);
+const _256n = BigInt(256);
+const _0x71n = BigInt(113);
+const SHA3_PI = [];
+const SHA3_ROTL = [];
+const _SHA3_IOTA = [];
+for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
+	[x, y] = [y, (2 * x + 3 * y) % 5];
+	SHA3_PI.push(2 * (5 * y + x));
+	SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
+	let t = _0n;
+	for (let j = 0; j < 7; j++) {
+		R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
+		if (R & _2n) t ^= _1n << (_1n << /* @__PURE__ */ BigInt(j)) - _1n;
+	}
+	_SHA3_IOTA.push(t);
+}
+const IOTAS = split(_SHA3_IOTA, true);
+const SHA3_IOTA_H = IOTAS[0];
+const SHA3_IOTA_L = IOTAS[1];
+const rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
+const rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
+/** `keccakf1600` internal function, additionally allows to adjust round count. */
+function keccakP(s, rounds = 24) {
+	const B = /* @__PURE__ */ new Uint32Array(10);
+	for (let round = 24 - rounds; round < 24; round++) {
+		for (let x = 0; x < 10; x++) B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+		for (let x = 0; x < 10; x += 2) {
+			const idx1 = (x + 8) % 10;
+			const idx0 = (x + 2) % 10;
+			const B0 = B[idx0];
+			const B1 = B[idx0 + 1];
+			const Th = rotlH(B0, B1, 1) ^ B[idx1];
+			const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+			for (let y = 0; y < 50; y += 10) {
+				s[x + y] ^= Th;
+				s[x + y + 1] ^= Tl;
+			}
+		}
+		let curH = s[2];
+		let curL = s[3];
+		for (let t = 0; t < 24; t++) {
+			const shift = SHA3_ROTL[t];
+			const Th = rotlH(curH, curL, shift);
+			const Tl = rotlL(curH, curL, shift);
+			const PI = SHA3_PI[t];
+			curH = s[PI];
+			curL = s[PI + 1];
+			s[PI] = Th;
+			s[PI + 1] = Tl;
+		}
+		for (let y = 0; y < 50; y += 10) {
+			for (let x = 0; x < 10; x++) B[x] = s[y + x];
+			for (let x = 0; x < 10; x++) s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
+		}
+		s[0] ^= SHA3_IOTA_H[round];
+		s[1] ^= SHA3_IOTA_L[round];
+	}
+	clean(B);
+}
+/** Keccak sponge function. */
+var Keccak = class Keccak extends Hash {
+	constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
+		super();
+		this.pos = 0;
+		this.posOut = 0;
+		this.finished = false;
+		this.destroyed = false;
+		this.enableXOF = false;
+		this.blockLen = blockLen;
+		this.suffix = suffix;
+		this.outputLen = outputLen;
+		this.enableXOF = enableXOF;
+		this.rounds = rounds;
+		anumber(outputLen);
+		if (!(0 < blockLen && blockLen < 200)) throw new Error("only keccak-f1600 function is supported");
+		this.state = /* @__PURE__ */ new Uint8Array(200);
+		this.state32 = u32(this.state);
+	}
+	clone() {
+		return this._cloneInto();
+	}
+	keccak() {
+		swap32IfBE(this.state32);
+		keccakP(this.state32, this.rounds);
+		swap32IfBE(this.state32);
+		this.posOut = 0;
+		this.pos = 0;
+	}
+	update(data) {
+		aexists(this);
+		data = toBytes$1(data);
+		abytes(data);
+		const { blockLen, state } = this;
+		const len = data.length;
+		for (let pos = 0; pos < len;) {
+			const take = Math.min(blockLen - this.pos, len - pos);
+			for (let i = 0; i < take; i++) state[this.pos++] ^= data[pos++];
+			if (this.pos === blockLen) this.keccak();
+		}
+		return this;
+	}
+	finish() {
+		if (this.finished) return;
+		this.finished = true;
+		const { state, suffix, pos, blockLen } = this;
+		state[pos] ^= suffix;
+		if ((suffix & 128) !== 0 && pos === blockLen - 1) this.keccak();
+		state[blockLen - 1] ^= 128;
+		this.keccak();
+	}
+	writeInto(out) {
+		aexists(this, false);
+		abytes(out);
+		this.finish();
+		const bufferOut = this.state;
+		const { blockLen } = this;
+		for (let pos = 0, len = out.length; pos < len;) {
+			if (this.posOut >= blockLen) this.keccak();
+			const take = Math.min(blockLen - this.posOut, len - pos);
+			out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+			this.posOut += take;
+			pos += take;
+		}
+		return out;
+	}
+	xofInto(out) {
+		if (!this.enableXOF) throw new Error("XOF is not possible for this instance");
+		return this.writeInto(out);
+	}
+	xof(bytes) {
+		anumber(bytes);
+		return this.xofInto(new Uint8Array(bytes));
+	}
+	digestInto(out) {
+		aoutput(out, this);
+		if (this.finished) throw new Error("digest() was already called");
+		this.writeInto(out);
+		this.destroy();
+		return out;
+	}
+	digest() {
+		return this.digestInto(new Uint8Array(this.outputLen));
+	}
+	destroy() {
+		this.destroyed = true;
+		clean(this.state);
+	}
+	_cloneInto(to) {
+		const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
+		to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
+		to.state32.set(this.state32);
+		to.pos = this.pos;
+		to.posOut = this.posOut;
+		to.finished = this.finished;
+		to.rounds = rounds;
+		to.suffix = suffix;
+		to.outputLen = outputLen;
+		to.enableXOF = enableXOF;
+		to.destroyed = this.destroyed;
+		return to;
+	}
+};
+const gen = (suffix, blockLen, outputLen) => createHasher(() => new Keccak(blockLen, suffix, outputLen));
+/** keccak-256 hash function. Different from SHA3-256. */
+const keccak_256 = /* @__PURE__ */ (() => gen(1, 136, 32))();
+//#endregion
+//#region ../../node_modules/.pnpm/viem@2.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/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.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/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.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/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.55.18_@typescript+typescript6@6.0.2_zod@4.6.5/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 ../../packages/protocol/src/primitives/record.ts
+/** A non-null object that is not an array: a value whose fields can be read by name. */
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** The field `key` of `value` when `value` is a record, else undefined. */
+function readField(value, key) {
+	return isRecord(value) ? value[key] : void 0;
+}
+//#endregion
+export { isHex as A, numberToHex as C, padHex as D, pad as E, InvalidBytesBooleanError as M, BaseError as N, trim as O, bytesToHex as S, toHex as T, hexToBigInt as _, isAddress as a, toBytes as b, keccak256 as c, formatGwei as d, toRlp as f, assertSize as g, concatHex as h, sliceBytes as i, IntegerOutOfRangeError as j, size as k, InvalidAddressError as l, concat as m, readField as n, checksumAddress as o, createCursor as p, slice as r, getAddress as s, isRecord as t, format as u, hexToNumber as v, stringToHex as w, boolToHex as x, hexToBytes as y };
+
+//# sourceMappingURL=record-U7Yu4KQP.mjs.map