x402-proxy 0.10.7 → 0.10.9

package/dist/sendRawTransactionSync-DvSkhZtW.js

@@ -0,0 +1,3612 @@
+#!/usr/bin/env node
+import { $ as stringify, $t as parseAbiParameter, A as padRight, Bt as ContractFunctionExecutionError, C as concat, D as fromNumber, E as fromBytes$2, G as size$1, H as fromHex$3, Ht as ContractFunctionZeroDataError, J as toBoolean, Jt as encodeFunctionData, K as slice$1, Lt as RpcRequestError, M as size, N as slice, O as fromString$1, Q as validate$3, Qt as parseStructs, R as trimLeft$1, T as fromBoolean, U as fromString, Ut as RawContractError, V as from$5, Vt as ContractFunctionRevertedError, X as toString, Y as toNumber, Z as trimLeft, an as modifiers, at as formatTransactionRequest, b as IntegerOutOfRangeError, ct as getNodeError, et as BaseError, ht as InvalidInputRpcError, in as isStructSignature, k as padLeft, mt as InternalRpcError, n as call, nn as InvalidAbiParametersError, nt as assertRequest, ot as defineFormatter, q as toBigInt, rt as serializeStateOverride, sn as formatAbiParameters, st as extract$1, tn as splitParameters, tt as decodeFunctionResult, w as from$6, x as InvalidLengthError, z as validate$2 } from "./decodeFunctionData-DuFcwhC_.js";
+import { A as formatGwei, D as TransactionReceiptRevertedError, F as parseAccount, J as LruMap$1, Mt as BaseError$1, Nt as size$2, Pt as isHex, at as hexToBigInt, gt as AbiDecodingZeroDataError, j as formatEther, k as prettyPrint, rt as toHex$3, st as hexToNumber, tt as numberToHex, v as UnknownNodeError, w as TransactionExecutionError } from "./chain-CafcHffR.js";
+import { t as keccak_256 } from "./sha3-CYkWM8Xa.js";
+import { d as getTransactionType, f as toBlobSidecars, g as hashAuthorization, h as blobsToCommitments, m as blobsToProofs, p as commitmentsToVersionedHashes, v as publicKeyToAddress } from "./hashTypedData-CtEdfx4y.js";
+import { t as sha256$1 } from "./sha256-FAs0qeni.js";
+import { t as secp256k1 } from "./secp256k1-BjenrLl5.js";
+//#region node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.3.6/node_modules/abitype/dist/esm/human-readable/parseAbiParameters.js
+/**
+* Parses human-readable ABI parameters into {@link AbiParameter}s
+*
+* @param params - Human-readable ABI parameters
+* @returns Parsed {@link AbiParameter}s
+*
+* @example
+* const abiParameters = parseAbiParameters('address from, address to, uint256 amount')
+* //    ^? const abiParameters: [{ type: "address"; name: "from"; }, { type: "address";...
+*
+* @example
+* const abiParameters = parseAbiParameters([
+*   //  ^? const abiParameters: [{ type: "tuple"; components: [{ type: "string"; name:...
+*   'Baz bar',
+*   'struct Baz { string name; }',
+* ])
+*/
+function parseAbiParameters(params) {
+	const abiParameters = [];
+	if (typeof params === "string") {
+		const parameters = splitParameters(params);
+		const length = parameters.length;
+		for (let i = 0; i < length; i++) abiParameters.push(parseAbiParameter(parameters[i], { modifiers }));
+	} else {
+		const structs = parseStructs(params);
+		const length = params.length;
+		for (let i = 0; i < length; i++) {
+			const signature = params[i];
+			if (isStructSignature(signature)) continue;
+			const parameters = splitParameters(signature);
+			const length = parameters.length;
+			for (let k = 0; k < length; k++) abiParameters.push(parseAbiParameter(parameters[k], {
+				modifiers,
+				structs
+			}));
+		}
+	}
+	if (abiParameters.length === 0) throw new InvalidAbiParametersError({ params });
+	return abiParameters;
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/getAction.js
+/**
+* Retrieves and returns an action from the client (if exists), and falls
+* back to the tree-shakable action.
+*
+* Useful for extracting overridden actions from a client (ie. if a consumer
+* wants to override the `sendTransaction` implementation).
+*/
+function getAction(client, actionFn, name) {
+	const action_implicit = client[actionFn.name];
+	if (typeof action_implicit === "function") return action_implicit;
+	const action_explicit = client[name];
+	if (typeof action_explicit === "function") return action_explicit;
+	return (params) => actionFn(client, params);
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/errors/getContractError.js
+const EXECUTION_REVERTED_ERROR_CODE = 3;
+function getContractError(err, { abi, address, args, docsPath, functionName, sender }) {
+	const error = err instanceof RawContractError ? err : err instanceof BaseError$1 ? err.walk((err) => "data" in err) || err.walk() : {};
+	const { code, data, details, message, shortMessage } = error;
+	return new ContractFunctionExecutionError((() => {
+		if (err instanceof AbiDecodingZeroDataError) return new ContractFunctionZeroDataError({
+			functionName,
+			cause: err
+		});
+		if ([EXECUTION_REVERTED_ERROR_CODE, InternalRpcError.code].includes(code) && (data || details || message || shortMessage) || code === InvalidInputRpcError.code && details === "execution reverted" && data) return new ContractFunctionRevertedError({
+			abi,
+			data: typeof data === "object" ? data.data : data,
+			functionName,
+			message: error instanceof RpcRequestError ? details : shortMessage ?? message,
+			cause: err
+		});
+		return err;
+	})(), {
+		abi,
+		args,
+		contractAddress: address,
+		docsPath,
+		functionName,
+		sender
+	});
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/signature/recoverPublicKey.js
+async function recoverPublicKey$1({ hash, signature }) {
+	const hashHex = isHex(hash) ? hash : toHex$3(hash);
+	const { secp256k1 } = await import("./secp256k1-CLPUX17u.js");
+	return `0x${(() => {
+		if (typeof signature === "object" && "r" in signature && "s" in signature) {
+			const { r, s, v, yParity } = signature;
+			const recoveryBit = toRecoveryBit(Number(yParity ?? v));
+			return new secp256k1.Signature(hexToBigInt(r), hexToBigInt(s)).addRecoveryBit(recoveryBit);
+		}
+		const signatureHex = isHex(signature) ? signature : toHex$3(signature);
+		if (size$2(signatureHex) !== 65) throw new Error("invalid signature length");
+		const recoveryBit = toRecoveryBit(hexToNumber(`0x${signatureHex.slice(130)}`));
+		return secp256k1.Signature.fromCompact(signatureHex.substring(2, 130)).addRecoveryBit(recoveryBit);
+	})().recoverPublicKey(hashHex.substring(2)).toHex(false)}`;
+}
+function toRecoveryBit(yParityOrV) {
+	if (yParityOrV === 0 || yParityOrV === 1) return yParityOrV;
+	if (yParityOrV === 27) return 0;
+	if (yParityOrV === 28) return 1;
+	throw new Error("Invalid yParityOrV value");
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/signature/recoverAddress.js
+async function recoverAddress$1({ hash, signature }) {
+	return publicKeyToAddress(await recoverPublicKey$1({
+		hash,
+		signature
+	}));
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/authorization/recoverAuthorizationAddress.js
+async function recoverAuthorizationAddress(parameters) {
+	const { authorization, signature } = parameters;
+	return recoverAddress$1({
+		hash: hashAuthorization(authorization),
+		signature: signature ?? authorization
+	});
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/errors/estimateGas.js
+var EstimateGasExecutionError = class extends BaseError$1 {
+	constructor(cause, { account, docsPath, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value }) {
+		const prettyArgs = prettyPrint({
+			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, " "] : [],
+				"Estimate Gas Arguments:",
+				prettyArgs
+			].filter(Boolean),
+			name: "EstimateGasExecutionError"
+		});
+		Object.defineProperty(this, "cause", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: void 0
+		});
+		this.cause = cause;
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/errors/getEstimateGasError.js
+function getEstimateGasError(err, { docsPath, ...args }) {
+	return new EstimateGasExecutionError((() => {
+		const cause = getNodeError(err, args);
+		if (cause instanceof UnknownNodeError) return err;
+		return cause;
+	})(), {
+		docsPath,
+		...args
+	});
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/errors/fee.js
+var BaseFeeScalarError = class extends BaseError$1 {
+	constructor() {
+		super("`baseFeeMultiplier` must be greater than 1.", { name: "BaseFeeScalarError" });
+	}
+};
+var Eip1559FeesNotSupportedError = class extends BaseError$1 {
+	constructor() {
+		super("Chain does not support EIP-1559 fees.", { name: "Eip1559FeesNotSupportedError" });
+	}
+};
+var MaxFeePerGasTooLowError = class extends BaseError$1 {
+	constructor({ maxPriorityFeePerGas }) {
+		super(`\`maxFeePerGas\` cannot be less than the \`maxPriorityFeePerGas\` (${formatGwei(maxPriorityFeePerGas)} gwei).`, { name: "MaxFeePerGasTooLowError" });
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/errors/block.js
+var BlockNotFoundError = class extends BaseError$1 {
+	constructor({ blockHash, blockNumber }) {
+		let identifier = "Block";
+		if (blockHash) identifier = `Block at hash "${blockHash}"`;
+		if (blockNumber) identifier = `Block at number "${blockNumber}"`;
+		super(`${identifier} could not be found.`, { name: "BlockNotFoundError" });
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/formatters/transaction.js
+const transactionType = {
+	"0x0": "legacy",
+	"0x1": "eip2930",
+	"0x2": "eip1559",
+	"0x3": "eip4844",
+	"0x4": "eip7702"
+};
+function formatTransaction(transaction, _) {
+	const transaction_ = {
+		...transaction,
+		blockHash: transaction.blockHash ? transaction.blockHash : null,
+		blockNumber: transaction.blockNumber ? BigInt(transaction.blockNumber) : null,
+		chainId: transaction.chainId ? hexToNumber(transaction.chainId) : void 0,
+		gas: transaction.gas ? BigInt(transaction.gas) : void 0,
+		gasPrice: transaction.gasPrice ? BigInt(transaction.gasPrice) : void 0,
+		maxFeePerBlobGas: transaction.maxFeePerBlobGas ? BigInt(transaction.maxFeePerBlobGas) : void 0,
+		maxFeePerGas: transaction.maxFeePerGas ? BigInt(transaction.maxFeePerGas) : void 0,
+		maxPriorityFeePerGas: transaction.maxPriorityFeePerGas ? BigInt(transaction.maxPriorityFeePerGas) : void 0,
+		nonce: transaction.nonce ? hexToNumber(transaction.nonce) : void 0,
+		to: transaction.to ? transaction.to : null,
+		transactionIndex: transaction.transactionIndex ? Number(transaction.transactionIndex) : null,
+		type: transaction.type ? transactionType[transaction.type] : void 0,
+		typeHex: transaction.type ? transaction.type : void 0,
+		value: transaction.value ? BigInt(transaction.value) : void 0,
+		v: transaction.v ? BigInt(transaction.v) : void 0
+	};
+	if (transaction.authorizationList) transaction_.authorizationList = formatAuthorizationList(transaction.authorizationList);
+	transaction_.yParity = (() => {
+		if (transaction.yParity) return Number(transaction.yParity);
+		if (typeof transaction_.v === "bigint") {
+			if (transaction_.v === 0n || transaction_.v === 27n) return 0;
+			if (transaction_.v === 1n || transaction_.v === 28n) return 1;
+			if (transaction_.v >= 35n) return transaction_.v % 2n === 0n ? 1 : 0;
+		}
+	})();
+	if (transaction_.type === "legacy") {
+		delete transaction_.accessList;
+		delete transaction_.maxFeePerBlobGas;
+		delete transaction_.maxFeePerGas;
+		delete transaction_.maxPriorityFeePerGas;
+		delete transaction_.yParity;
+	}
+	if (transaction_.type === "eip2930") {
+		delete transaction_.maxFeePerBlobGas;
+		delete transaction_.maxFeePerGas;
+		delete transaction_.maxPriorityFeePerGas;
+	}
+	if (transaction_.type === "eip1559") delete transaction_.maxFeePerBlobGas;
+	return transaction_;
+}
+const defineTransaction = /* @__PURE__ */ defineFormatter("transaction", formatTransaction);
+function formatAuthorizationList(authorizationList) {
+	return authorizationList.map((authorization) => ({
+		address: authorization.address,
+		chainId: Number(authorization.chainId),
+		nonce: Number(authorization.nonce),
+		r: authorization.r,
+		s: authorization.s,
+		yParity: Number(authorization.yParity)
+	}));
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/formatters/block.js
+function formatBlock(block, _) {
+	const transactions = (block.transactions ?? []).map((transaction) => {
+		if (typeof transaction === "string") return transaction;
+		return formatTransaction(transaction);
+	});
+	return {
+		...block,
+		baseFeePerGas: block.baseFeePerGas ? BigInt(block.baseFeePerGas) : null,
+		blobGasUsed: block.blobGasUsed ? BigInt(block.blobGasUsed) : void 0,
+		difficulty: block.difficulty ? BigInt(block.difficulty) : void 0,
+		excessBlobGas: block.excessBlobGas ? BigInt(block.excessBlobGas) : void 0,
+		gasLimit: block.gasLimit ? BigInt(block.gasLimit) : void 0,
+		gasUsed: block.gasUsed ? BigInt(block.gasUsed) : void 0,
+		hash: block.hash ? block.hash : null,
+		logsBloom: block.logsBloom ? block.logsBloom : null,
+		nonce: block.nonce ? block.nonce : null,
+		number: block.number ? BigInt(block.number) : null,
+		size: block.size ? BigInt(block.size) : void 0,
+		timestamp: block.timestamp ? BigInt(block.timestamp) : void 0,
+		transactions,
+		totalDifficulty: block.totalDifficulty ? BigInt(block.totalDifficulty) : null
+	};
+}
+const defineBlock = /* @__PURE__ */ defineFormatter("block", formatBlock);
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/actions/public/getBlock.js
+/**
+* Returns information about a block at a block number, hash, or tag.
+*
+* - Docs: https://viem.sh/docs/actions/public/getBlock
+* - Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/blocks_fetching-blocks
+* - JSON-RPC Methods:
+*   - Calls [`eth_getBlockByNumber`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getblockbynumber) for `blockNumber` & `blockTag`.
+*   - Calls [`eth_getBlockByHash`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getblockbyhash) for `blockHash`.
+*
+* @param client - Client to use
+* @param parameters - {@link GetBlockParameters}
+* @returns Information about the block. {@link GetBlockReturnType}
+*
+* @example
+* import { createPublicClient, http } from 'viem'
+* import { mainnet } from 'viem/chains'
+* import { getBlock } from 'viem/public'
+*
+* const client = createPublicClient({
+*   chain: mainnet,
+*   transport: http(),
+* })
+* const block = await getBlock(client)
+*/
+async function getBlock(client, { blockHash, blockNumber, blockTag = client.experimental_blockTag ?? "latest", includeTransactions: includeTransactions_ } = {}) {
+	const includeTransactions = includeTransactions_ ?? false;
+	const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
+	let block = null;
+	if (blockHash) block = await client.request({
+		method: "eth_getBlockByHash",
+		params: [blockHash, includeTransactions]
+	}, { dedupe: true });
+	else block = await client.request({
+		method: "eth_getBlockByNumber",
+		params: [blockNumberHex || blockTag, includeTransactions]
+	}, { dedupe: Boolean(blockNumberHex) });
+	if (!block) throw new BlockNotFoundError({
+		blockHash,
+		blockNumber
+	});
+	return (client.chain?.formatters?.block?.format || formatBlock)(block, "getBlock");
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/actions/public/getGasPrice.js
+/**
+* Returns the current price of gas (in wei).
+*
+* - Docs: https://viem.sh/docs/actions/public/getGasPrice
+* - JSON-RPC Methods: [`eth_gasPrice`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_gasprice)
+*
+* @param client - Client to use
+* @returns The gas price (in wei). {@link GetGasPriceReturnType}
+*
+* @example
+* import { createPublicClient, http } from 'viem'
+* import { mainnet } from 'viem/chains'
+* import { getGasPrice } from 'viem/public'
+*
+* const client = createPublicClient({
+*   chain: mainnet,
+*   transport: http(),
+* })
+* const gasPrice = await getGasPrice(client)
+*/
+async function getGasPrice(client) {
+	const gasPrice = await client.request({ method: "eth_gasPrice" });
+	return BigInt(gasPrice);
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/actions/public/estimateMaxPriorityFeePerGas.js
+/**
+* Returns an estimate for the max priority fee per gas (in wei) for a
+* transaction to be likely included in the next block.
+* Defaults to [`chain.fees.defaultPriorityFee`](/docs/clients/chains#fees-defaultpriorityfee) if set.
+*
+* - Docs: https://viem.sh/docs/actions/public/estimateMaxPriorityFeePerGas
+*
+* @param client - Client to use
+* @returns An estimate (in wei) for the max priority fee per gas. {@link EstimateMaxPriorityFeePerGasReturnType}
+*
+* @example
+* import { createPublicClient, http } from 'viem'
+* import { mainnet } from 'viem/chains'
+* import { estimateMaxPriorityFeePerGas } from 'viem/actions'
+*
+* const client = createPublicClient({
+*   chain: mainnet,
+*   transport: http(),
+* })
+* const maxPriorityFeePerGas = await estimateMaxPriorityFeePerGas(client)
+* // 10000000n
+*/
+async function estimateMaxPriorityFeePerGas(client, args) {
+	return internal_estimateMaxPriorityFeePerGas(client, args);
+}
+async function internal_estimateMaxPriorityFeePerGas(client, args) {
+	const { block: block_, chain = client.chain, request } = args || {};
+	try {
+		const maxPriorityFeePerGas = chain?.fees?.maxPriorityFeePerGas ?? chain?.fees?.defaultPriorityFee;
+		if (typeof maxPriorityFeePerGas === "function") {
+			const maxPriorityFeePerGas_ = await maxPriorityFeePerGas({
+				block: block_ || await getAction(client, getBlock, "getBlock")({}),
+				client,
+				request
+			});
+			if (maxPriorityFeePerGas_ === null) throw new Error();
+			return maxPriorityFeePerGas_;
+		}
+		if (typeof maxPriorityFeePerGas !== "undefined") return maxPriorityFeePerGas;
+		return hexToBigInt(await client.request({ method: "eth_maxPriorityFeePerGas" }));
+	} catch {
+		const [block, gasPrice] = await Promise.all([block_ ? Promise.resolve(block_) : getAction(client, getBlock, "getBlock")({}), getAction(client, getGasPrice, "getGasPrice")({})]);
+		if (typeof block.baseFeePerGas !== "bigint") throw new Eip1559FeesNotSupportedError();
+		const maxPriorityFeePerGas = gasPrice - block.baseFeePerGas;
+		if (maxPriorityFeePerGas < 0n) return 0n;
+		return maxPriorityFeePerGas;
+	}
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/actions/public/estimateFeesPerGas.js
+/**
+* Returns an estimate for the fees per gas (in wei) for a
+* transaction to be likely included in the next block.
+* Defaults to [`chain.fees.estimateFeesPerGas`](/docs/clients/chains#fees-estimatefeespergas) if set.
+*
+* - Docs: https://viem.sh/docs/actions/public/estimateFeesPerGas
+*
+* @param client - Client to use
+* @param parameters - {@link EstimateFeesPerGasParameters}
+* @returns An estimate (in wei) for the fees per gas. {@link EstimateFeesPerGasReturnType}
+*
+* @example
+* import { createPublicClient, http } from 'viem'
+* import { mainnet } from 'viem/chains'
+* import { estimateFeesPerGas } from 'viem/actions'
+*
+* const client = createPublicClient({
+*   chain: mainnet,
+*   transport: http(),
+* })
+* const maxPriorityFeePerGas = await estimateFeesPerGas(client)
+* // { maxFeePerGas: ..., maxPriorityFeePerGas: ... }
+*/
+async function estimateFeesPerGas(client, args) {
+	return internal_estimateFeesPerGas(client, args);
+}
+async function internal_estimateFeesPerGas(client, args) {
+	const { block: block_, chain = client.chain, request, type = "eip1559" } = args || {};
+	const baseFeeMultiplier = await (async () => {
+		if (typeof chain?.fees?.baseFeeMultiplier === "function") return chain.fees.baseFeeMultiplier({
+			block: block_,
+			client,
+			request
+		});
+		return chain?.fees?.baseFeeMultiplier ?? 1.2;
+	})();
+	if (baseFeeMultiplier < 1) throw new BaseFeeScalarError();
+	const denominator = 10 ** (baseFeeMultiplier.toString().split(".")[1]?.length ?? 0);
+	const multiply = (base) => base * BigInt(Math.ceil(baseFeeMultiplier * denominator)) / BigInt(denominator);
+	const block = block_ ? block_ : await getAction(client, getBlock, "getBlock")({});
+	if (typeof chain?.fees?.estimateFeesPerGas === "function") {
+		const fees = await chain.fees.estimateFeesPerGas({
+			block: block_,
+			client,
+			multiply,
+			request,
+			type
+		});
+		if (fees !== null) return fees;
+	}
+	if (type === "eip1559") {
+		if (typeof block.baseFeePerGas !== "bigint") throw new Eip1559FeesNotSupportedError();
+		const maxPriorityFeePerGas = typeof request?.maxPriorityFeePerGas === "bigint" ? request.maxPriorityFeePerGas : await internal_estimateMaxPriorityFeePerGas(client, {
+			block,
+			chain,
+			request
+		});
+		const baseFeePerGas = multiply(block.baseFeePerGas);
+		return {
+			maxFeePerGas: request?.maxFeePerGas ?? baseFeePerGas + maxPriorityFeePerGas,
+			maxPriorityFeePerGas
+		};
+	}
+	return { gasPrice: request?.gasPrice ?? multiply(await getAction(client, getGasPrice, "getGasPrice")({})) };
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/actions/public/getTransactionCount.js
+/**
+* Returns the number of [Transactions](https://viem.sh/docs/glossary/terms#transaction) an Account has sent.
+*
+* - Docs: https://viem.sh/docs/actions/public/getTransactionCount
+* - JSON-RPC Methods: [`eth_getTransactionCount`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_gettransactioncount)
+*
+* @param client - Client to use
+* @param parameters - {@link GetTransactionCountParameters}
+* @returns The number of transactions an account has sent. {@link GetTransactionCountReturnType}
+*
+* @example
+* import { createPublicClient, http } from 'viem'
+* import { mainnet } from 'viem/chains'
+* import { getTransactionCount } from 'viem/public'
+*
+* const client = createPublicClient({
+*   chain: mainnet,
+*   transport: http(),
+* })
+* const transactionCount = await getTransactionCount(client, {
+*   address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+* })
+*/
+async function getTransactionCount(client, { address, blockTag = "latest", blockNumber }) {
+	return hexToNumber(await client.request({
+		method: "eth_getTransactionCount",
+		params: [address, typeof blockNumber === "bigint" ? numberToHex(blockNumber) : blockTag]
+	}, { dedupe: Boolean(blockNumber) }));
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/errors/getTransactionError.js
+function getTransactionError(err, { docsPath, ...args }) {
+	return new TransactionExecutionError((() => {
+		const cause = getNodeError(err, args);
+		if (cause instanceof UnknownNodeError) return err;
+		return cause;
+	})(), {
+		docsPath,
+		...args
+	});
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/actions/public/getChainId.js
+/**
+* Returns the chain ID associated with the current network.
+*
+* - Docs: https://viem.sh/docs/actions/public/getChainId
+* - JSON-RPC Methods: [`eth_chainId`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_chainid)
+*
+* @param client - Client to use
+* @returns The current chain ID. {@link GetChainIdReturnType}
+*
+* @example
+* import { createPublicClient, http } from 'viem'
+* import { mainnet } from 'viem/chains'
+* import { getChainId } from 'viem/public'
+*
+* const client = createPublicClient({
+*   chain: mainnet,
+*   transport: http(),
+* })
+* const chainId = await getChainId(client)
+* // 1
+*/
+async function getChainId(client) {
+	return hexToNumber(await client.request({ method: "eth_chainId" }, { dedupe: true }));
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/actions/public/fillTransaction.js
+/**
+* Fills a transaction request with the necessary fields to be signed over.
+*
+* - Docs: https://viem.sh/docs/actions/public/fillTransaction
+*
+* @param client - Client to use
+* @param parameters - {@link FillTransactionParameters}
+* @returns The filled transaction. {@link FillTransactionReturnType}
+*
+* @example
+* import { createPublicClient, http } from 'viem'
+* import { mainnet } from 'viem/chains'
+* import { fillTransaction } from 'viem/public'
+*
+* const client = createPublicClient({
+*   chain: mainnet,
+*   transport: http(),
+* })
+* const result = await fillTransaction(client, {
+*   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+*   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+*   value: parseEther('1'),
+* })
+*/
+async function fillTransaction(client, parameters) {
+	const { account = client.account, accessList, authorizationList, chain = client.chain, blobVersionedHashes, blobs, data, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce: nonce_, nonceManager, to, type, value, ...rest } = parameters;
+	const nonce = await (async () => {
+		if (!account) return nonce_;
+		if (!nonceManager) return nonce_;
+		if (typeof nonce_ !== "undefined") return nonce_;
+		const account_ = parseAccount(account);
+		const chainId = chain ? chain.id : await getAction(client, getChainId, "getChainId")({});
+		return await nonceManager.consume({
+			address: account_.address,
+			chainId,
+			client
+		});
+	})();
+	assertRequest(parameters);
+	const chainFormat = chain?.formatters?.transactionRequest?.format;
+	const request = (chainFormat || formatTransactionRequest)({
+		...extract$1(rest, { format: chainFormat }),
+		account: account ? parseAccount(account) : void 0,
+		accessList,
+		authorizationList,
+		blobs,
+		blobVersionedHashes,
+		data,
+		gas,
+		gasPrice,
+		maxFeePerBlobGas,
+		maxFeePerGas,
+		maxPriorityFeePerGas,
+		nonce,
+		to,
+		type,
+		value
+	}, "fillTransaction");
+	try {
+		const response = await client.request({
+			method: "eth_fillTransaction",
+			params: [request]
+		});
+		const transaction = (chain?.formatters?.transaction?.format || formatTransaction)(response.tx);
+		delete transaction.blockHash;
+		delete transaction.blockNumber;
+		delete transaction.r;
+		delete transaction.s;
+		delete transaction.transactionIndex;
+		delete transaction.v;
+		delete transaction.yParity;
+		transaction.data = transaction.input;
+		if (transaction.gas) transaction.gas = parameters.gas ?? transaction.gas;
+		if (transaction.gasPrice) transaction.gasPrice = parameters.gasPrice ?? transaction.gasPrice;
+		if (transaction.maxFeePerBlobGas) transaction.maxFeePerBlobGas = parameters.maxFeePerBlobGas ?? transaction.maxFeePerBlobGas;
+		if (transaction.maxFeePerGas) transaction.maxFeePerGas = parameters.maxFeePerGas ?? transaction.maxFeePerGas;
+		if (transaction.maxPriorityFeePerGas) transaction.maxPriorityFeePerGas = parameters.maxPriorityFeePerGas ?? transaction.maxPriorityFeePerGas;
+		if (transaction.nonce) transaction.nonce = parameters.nonce ?? transaction.nonce;
+		const feeMultiplier = await (async () => {
+			if (typeof chain?.fees?.baseFeeMultiplier === "function") {
+				const block = await getAction(client, getBlock, "getBlock")({});
+				return chain.fees.baseFeeMultiplier({
+					block,
+					client,
+					request: parameters
+				});
+			}
+			return chain?.fees?.baseFeeMultiplier ?? 1.2;
+		})();
+		if (feeMultiplier < 1) throw new BaseFeeScalarError();
+		const denominator = 10 ** (feeMultiplier.toString().split(".")[1]?.length ?? 0);
+		const multiplyFee = (base) => base * BigInt(Math.ceil(feeMultiplier * denominator)) / BigInt(denominator);
+		if (transaction.maxFeePerGas && !parameters.maxFeePerGas) transaction.maxFeePerGas = multiplyFee(transaction.maxFeePerGas);
+		if (transaction.gasPrice && !parameters.gasPrice) transaction.gasPrice = multiplyFee(transaction.gasPrice);
+		return {
+			raw: response.raw,
+			transaction: {
+				from: request.from,
+				...transaction
+			}
+		};
+	} catch (err) {
+		throw getTransactionError(err, {
+			...parameters,
+			chain: client.chain
+		});
+	}
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/actions/wallet/prepareTransactionRequest.js
+const defaultParameters = [
+	"blobVersionedHashes",
+	"chainId",
+	"fees",
+	"gas",
+	"nonce",
+	"type"
+];
+/** @internal */
+const eip1559NetworkCache = /* @__PURE__ */ new Map();
+/** @internal */
+const supportsFillTransaction = /* @__PURE__ */ new LruMap$1(128);
+/**
+* Prepares a transaction request for signing.
+*
+* - Docs: https://viem.sh/docs/actions/wallet/prepareTransactionRequest
+*
+* @param args - {@link PrepareTransactionRequestParameters}
+* @returns The transaction request. {@link PrepareTransactionRequestReturnType}
+*
+* @example
+* import { createWalletClient, custom } from 'viem'
+* import { mainnet } from 'viem/chains'
+* import { prepareTransactionRequest } from 'viem/actions'
+*
+* const client = createWalletClient({
+*   chain: mainnet,
+*   transport: custom(window.ethereum),
+* })
+* const request = await prepareTransactionRequest(client, {
+*   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+*   to: '0x0000000000000000000000000000000000000000',
+*   value: 1n,
+* })
+*
+* @example
+* // Account Hoisting
+* import { createWalletClient, http } from 'viem'
+* import { privateKeyToAccount } from 'viem/accounts'
+* import { mainnet } from 'viem/chains'
+* import { prepareTransactionRequest } from 'viem/actions'
+*
+* const client = createWalletClient({
+*   account: privateKeyToAccount('0x…'),
+*   chain: mainnet,
+*   transport: custom(window.ethereum),
+* })
+* const request = await prepareTransactionRequest(client, {
+*   to: '0x0000000000000000000000000000000000000000',
+*   value: 1n,
+* })
+*/
+async function prepareTransactionRequest(client, args) {
+	let request = args;
+	request.account ??= client.account;
+	request.parameters ??= defaultParameters;
+	const { account: account_, chain = client.chain, nonceManager, parameters } = request;
+	const prepareTransactionRequest = (() => {
+		if (typeof chain?.prepareTransactionRequest === "function") return {
+			fn: chain.prepareTransactionRequest,
+			runAt: ["beforeFillTransaction"]
+		};
+		if (Array.isArray(chain?.prepareTransactionRequest)) return {
+			fn: chain.prepareTransactionRequest[0],
+			runAt: chain.prepareTransactionRequest[1].runAt
+		};
+	})();
+	let chainId;
+	async function getChainId$1() {
+		if (chainId) return chainId;
+		if (typeof request.chainId !== "undefined") return request.chainId;
+		if (chain) return chain.id;
+		chainId = await getAction(client, getChainId, "getChainId")({});
+		return chainId;
+	}
+	const account = account_ ? parseAccount(account_) : account_;
+	let nonce = request.nonce;
+	if (parameters.includes("nonce") && typeof nonce === "undefined" && account && nonceManager) {
+		const chainId = await getChainId$1();
+		nonce = await nonceManager.consume({
+			address: account.address,
+			chainId,
+			client
+		});
+	}
+	if (prepareTransactionRequest?.fn && prepareTransactionRequest.runAt?.includes("beforeFillTransaction")) {
+		request = await prepareTransactionRequest.fn({
+			...request,
+			chain
+		}, { phase: "beforeFillTransaction" });
+		nonce ??= request.nonce;
+	}
+	const fillResult = (() => {
+		if ((parameters.includes("blobVersionedHashes") || parameters.includes("sidecars")) && request.kzg && request.blobs) return false;
+		if (supportsFillTransaction.get(client.uid) === false) return false;
+		if (!["fees", "gas"].some((parameter) => parameters.includes(parameter))) return false;
+		if (parameters.includes("chainId") && typeof request.chainId !== "number") return true;
+		if (parameters.includes("nonce") && typeof nonce !== "number") return true;
+		if (parameters.includes("fees") && typeof request.gasPrice !== "bigint" && (typeof request.maxFeePerGas !== "bigint" || typeof request.maxPriorityFeePerGas !== "bigint")) return true;
+		if (parameters.includes("gas") && typeof request.gas !== "bigint") return true;
+		return false;
+	})() ? await getAction(client, fillTransaction, "fillTransaction")({
+		...request,
+		nonce
+	}).then((result) => {
+		const { chainId, from, gas, gasPrice, nonce, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, type, ...rest } = result.transaction;
+		supportsFillTransaction.set(client.uid, true);
+		return {
+			...request,
+			...from ? { from } : {},
+			...type && !request.type ? { type } : {},
+			...typeof chainId !== "undefined" ? { chainId } : {},
+			...typeof gas !== "undefined" ? { gas } : {},
+			...typeof gasPrice !== "undefined" ? { gasPrice } : {},
+			...typeof nonce !== "undefined" ? { nonce } : {},
+			...typeof maxFeePerBlobGas !== "undefined" && request.type !== "legacy" && request.type !== "eip2930" ? { maxFeePerBlobGas } : {},
+			...typeof maxFeePerGas !== "undefined" && request.type !== "legacy" && request.type !== "eip2930" ? { maxFeePerGas } : {},
+			...typeof maxPriorityFeePerGas !== "undefined" && request.type !== "legacy" && request.type !== "eip2930" ? { maxPriorityFeePerGas } : {},
+			..."nonceKey" in rest && typeof rest.nonceKey !== "undefined" ? { nonceKey: rest.nonceKey } : {}
+		};
+	}).catch((e) => {
+		const error = e;
+		if (error.name !== "TransactionExecutionError") return request;
+		if (error.walk?.((e) => {
+			const error = e;
+			return error.name === "MethodNotFoundRpcError" || error.name === "MethodNotSupportedRpcError" || error.message?.includes("eth_fillTransaction is not available");
+		})) supportsFillTransaction.set(client.uid, false);
+		return request;
+	}) : request;
+	nonce ??= fillResult.nonce;
+	request = {
+		...fillResult,
+		...account ? { from: account?.address } : {},
+		...nonce ? { nonce } : {}
+	};
+	const { blobs, gas, kzg, type } = request;
+	if (prepareTransactionRequest?.fn && prepareTransactionRequest.runAt?.includes("beforeFillParameters")) request = await prepareTransactionRequest.fn({
+		...request,
+		chain
+	}, { phase: "beforeFillParameters" });
+	let block;
+	async function getBlock$1() {
+		if (block) return block;
+		block = await getAction(client, getBlock, "getBlock")({ blockTag: "latest" });
+		return block;
+	}
+	if (parameters.includes("nonce") && typeof nonce === "undefined" && account && !nonceManager) request.nonce = await getAction(client, getTransactionCount, "getTransactionCount")({
+		address: account.address,
+		blockTag: "pending"
+	});
+	if ((parameters.includes("blobVersionedHashes") || parameters.includes("sidecars")) && blobs && kzg) {
+		const commitments = blobsToCommitments({
+			blobs,
+			kzg
+		});
+		if (parameters.includes("blobVersionedHashes")) {
+			const versionedHashes = commitmentsToVersionedHashes({
+				commitments,
+				to: "hex"
+			});
+			request.blobVersionedHashes = versionedHashes;
+		}
+		if (parameters.includes("sidecars")) {
+			const sidecars = toBlobSidecars({
+				blobs,
+				commitments,
+				proofs: blobsToProofs({
+					blobs,
+					commitments,
+					kzg
+				}),
+				to: "hex"
+			});
+			request.sidecars = sidecars;
+		}
+	}
+	if (parameters.includes("chainId")) request.chainId = await getChainId$1();
+	if ((parameters.includes("fees") || parameters.includes("type")) && typeof type === "undefined") try {
+		request.type = getTransactionType(request);
+	} catch {
+		let isEip1559Network = eip1559NetworkCache.get(client.uid);
+		if (typeof isEip1559Network === "undefined") {
+			isEip1559Network = typeof (await getBlock$1())?.baseFeePerGas === "bigint";
+			eip1559NetworkCache.set(client.uid, isEip1559Network);
+		}
+		request.type = isEip1559Network ? "eip1559" : "legacy";
+	}
+	if (parameters.includes("fees")) if (request.type !== "legacy" && request.type !== "eip2930") {
+		if (typeof request.maxFeePerGas === "undefined" || typeof request.maxPriorityFeePerGas === "undefined") {
+			const { maxFeePerGas, maxPriorityFeePerGas } = await internal_estimateFeesPerGas(client, {
+				block: await getBlock$1(),
+				chain,
+				request
+			});
+			if (typeof request.maxPriorityFeePerGas === "undefined" && request.maxFeePerGas && request.maxFeePerGas < maxPriorityFeePerGas) throw new MaxFeePerGasTooLowError({ maxPriorityFeePerGas });
+			request.maxPriorityFeePerGas = maxPriorityFeePerGas;
+			request.maxFeePerGas = maxFeePerGas;
+		}
+	} else {
+		if (typeof request.maxFeePerGas !== "undefined" || typeof request.maxPriorityFeePerGas !== "undefined") throw new Eip1559FeesNotSupportedError();
+		if (typeof request.gasPrice === "undefined") {
+			const { gasPrice: gasPrice_ } = await internal_estimateFeesPerGas(client, {
+				block: await getBlock$1(),
+				chain,
+				request,
+				type: "legacy"
+			});
+			request.gasPrice = gasPrice_;
+		}
+	}
+	if (parameters.includes("gas") && typeof gas === "undefined") request.gas = await getAction(client, estimateGas, "estimateGas")({
+		...request,
+		account,
+		prepare: account?.type === "local" ? [] : ["blobVersionedHashes"]
+	});
+	if (prepareTransactionRequest?.fn && prepareTransactionRequest.runAt?.includes("afterFillParameters")) request = await prepareTransactionRequest.fn({
+		...request,
+		chain
+	}, { phase: "afterFillParameters" });
+	assertRequest(request);
+	delete request.parameters;
+	return request;
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/actions/public/estimateGas.js
+/**
+* Estimates the gas necessary to complete a transaction without submitting it to the network.
+*
+* - Docs: https://viem.sh/docs/actions/public/estimateGas
+* - JSON-RPC Methods: [`eth_estimateGas`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_estimategas)
+*
+* @param client - Client to use
+* @param parameters - {@link EstimateGasParameters}
+* @returns The gas estimate (in gas units). {@link EstimateGasReturnType}
+*
+* @example
+* import { createPublicClient, http, parseEther } from 'viem'
+* import { mainnet } from 'viem/chains'
+* import { estimateGas } from 'viem/public'
+*
+* const client = createPublicClient({
+*   chain: mainnet,
+*   transport: http(),
+* })
+* const gasEstimate = await estimateGas(client, {
+*   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+*   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+*   value: parseEther('1'),
+* })
+*/
+async function estimateGas(client, args) {
+	const { account: account_ = client.account, prepare = true } = args;
+	const account = account_ ? parseAccount(account_) : void 0;
+	const parameters = (() => {
+		if (Array.isArray(prepare)) return prepare;
+		if (account?.type !== "local") return ["blobVersionedHashes"];
+	})();
+	try {
+		const to = await (async () => {
+			if (args.to) return args.to;
+			if (args.authorizationList && args.authorizationList.length > 0) return await recoverAuthorizationAddress({ authorization: args.authorizationList[0] }).catch(() => {
+				throw new BaseError$1("`to` is required. Could not infer from `authorizationList`");
+			});
+		})();
+		const { accessList, authorizationList, blobs, blobVersionedHashes, blockNumber, blockTag, data, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, value, stateOverride, ...rest } = prepare ? await prepareTransactionRequest(client, {
+			...args,
+			parameters,
+			to
+		}) : args;
+		if (gas && args.gas !== gas) return gas;
+		const block = (typeof blockNumber === "bigint" ? numberToHex(blockNumber) : void 0) || blockTag;
+		const rpcStateOverride = serializeStateOverride(stateOverride);
+		assertRequest(args);
+		const chainFormat = client.chain?.formatters?.transactionRequest?.format;
+		const request = (chainFormat || formatTransactionRequest)({
+			...extract$1(rest, { format: chainFormat }),
+			account,
+			accessList,
+			authorizationList,
+			blobs,
+			blobVersionedHashes,
+			data,
+			gasPrice,
+			maxFeePerBlobGas,
+			maxFeePerGas,
+			maxPriorityFeePerGas,
+			nonce,
+			to,
+			value
+		}, "estimateGas");
+		return BigInt(await client.request({
+			method: "eth_estimateGas",
+			params: rpcStateOverride ? [
+				request,
+				block ?? client.experimental_blockTag ?? "latest",
+				rpcStateOverride
+			] : block ? [request, block] : [request]
+		}));
+	} catch (err) {
+		throw getEstimateGasError(err, {
+			...args,
+			account,
+			chain: client.chain
+		});
+	}
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/formatters/log.js
+function formatLog(log, { args, eventName } = {}) {
+	return {
+		...log,
+		blockHash: log.blockHash ? log.blockHash : null,
+		blockNumber: log.blockNumber ? BigInt(log.blockNumber) : null,
+		blockTimestamp: log.blockTimestamp ? BigInt(log.blockTimestamp) : log.blockTimestamp === null ? null : void 0,
+		logIndex: log.logIndex ? Number(log.logIndex) : null,
+		transactionHash: log.transactionHash ? log.transactionHash : null,
+		transactionIndex: log.transactionIndex ? Number(log.transactionIndex) : null,
+		...eventName ? {
+			args,
+			eventName
+		} : {}
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/actions/public/readContract.js
+/**
+* Calls a read-only function on a contract, and returns the response.
+*
+* - Docs: https://viem.sh/docs/contract/readContract
+* - Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/contracts_reading-contracts
+*
+* A "read-only" function (constant function) on a Solidity contract is denoted by a `view` or `pure` keyword. They can only read the state of the contract, and cannot make any changes to it. Since read-only methods do not change the state of the contract, they do not require any gas to be executed, and can be called by any user without the need to pay for gas.
+*
+* Internally, uses a [Public Client](https://viem.sh/docs/clients/public) to call the [`call` action](https://viem.sh/docs/actions/public/call) with [ABI-encoded `data`](https://viem.sh/docs/contract/encodeFunctionData).
+*
+* @param client - Client to use
+* @param parameters - {@link ReadContractParameters}
+* @returns The response from the contract. Type is inferred. {@link ReadContractReturnType}
+*
+* @example
+* import { createPublicClient, http, parseAbi } from 'viem'
+* import { mainnet } from 'viem/chains'
+* import { readContract } from 'viem/contract'
+*
+* const client = createPublicClient({
+*   chain: mainnet,
+*   transport: http(),
+* })
+* const result = await readContract(client, {
+*   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
+*   abi: parseAbi(['function balanceOf(address) view returns (uint256)']),
+*   functionName: 'balanceOf',
+*   args: ['0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'],
+* })
+* // 424122n
+*/
+async function readContract(client, parameters) {
+	const { abi, address, args, functionName, ...rest } = parameters;
+	const calldata = encodeFunctionData({
+		abi,
+		args,
+		functionName
+	});
+	try {
+		const { data } = await getAction(client, call, "call")({
+			...rest,
+			data: calldata,
+			to: address
+		});
+		return decodeFunctionResult({
+			abi,
+			args,
+			functionName,
+			data: data || "0x"
+		});
+	} catch (error) {
+		throw getContractError(error, {
+			abi,
+			address,
+			args,
+			docsPath: "/docs/contract/readContract",
+			functionName
+		});
+	}
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/actions/wallet/sendRawTransaction.js
+/**
+* Sends a **signed** transaction to the network
+*
+* - Docs: https://viem.sh/docs/actions/wallet/sendRawTransaction
+* - JSON-RPC Method: [`eth_sendRawTransaction`](https://ethereum.github.io/execution-apis/api-documentation/)
+*
+* @param client - Client to use
+* @param parameters - {@link SendRawTransactionParameters}
+* @returns The transaction hash. {@link SendRawTransactionReturnType}
+*
+* @example
+* import { createWalletClient, custom } from 'viem'
+* import { mainnet } from 'viem/chains'
+* import { sendRawTransaction } from 'viem/wallet'
+*
+* const client = createWalletClient({
+*   chain: mainnet,
+*   transport: custom(window.ethereum),
+* })
+*
+* const hash = await sendRawTransaction(client, {
+*   serializedTransaction: '0x02f850018203118080825208808080c080a04012522854168b27e5dc3d5839bab5e6b39e1a0ffd343901ce1622e3d64b48f1a04e00902ae0502c4728cbf12156290df99c3ed7de85b1dbfe20b5c36931733a33'
+* })
+*/
+async function sendRawTransaction(client, { serializedTransaction }) {
+	return client.request({
+		method: "eth_sendRawTransaction",
+		params: [serializedTransaction]
+	}, { retryCount: 0 });
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/formatters/transactionReceipt.js
+const receiptStatuses = {
+	"0x0": "reverted",
+	"0x1": "success"
+};
+function formatTransactionReceipt(transactionReceipt, _) {
+	const receipt = {
+		...transactionReceipt,
+		blockNumber: transactionReceipt.blockNumber ? BigInt(transactionReceipt.blockNumber) : null,
+		contractAddress: transactionReceipt.contractAddress ? transactionReceipt.contractAddress : null,
+		cumulativeGasUsed: transactionReceipt.cumulativeGasUsed ? BigInt(transactionReceipt.cumulativeGasUsed) : null,
+		effectiveGasPrice: transactionReceipt.effectiveGasPrice ? BigInt(transactionReceipt.effectiveGasPrice) : null,
+		gasUsed: transactionReceipt.gasUsed ? BigInt(transactionReceipt.gasUsed) : null,
+		logs: transactionReceipt.logs ? transactionReceipt.logs.map((log) => formatLog(log)) : null,
+		to: transactionReceipt.to ? transactionReceipt.to : null,
+		transactionIndex: transactionReceipt.transactionIndex ? hexToNumber(transactionReceipt.transactionIndex) : null,
+		status: transactionReceipt.status ? receiptStatuses[transactionReceipt.status] : null,
+		type: transactionReceipt.type ? transactionType[transactionReceipt.type] || transactionReceipt.type : null
+	};
+	if (transactionReceipt.blobGasPrice) receipt.blobGasPrice = BigInt(transactionReceipt.blobGasPrice);
+	if (transactionReceipt.blobGasUsed) receipt.blobGasUsed = BigInt(transactionReceipt.blobGasUsed);
+	return receipt;
+}
+const defineTransactionReceipt = /* @__PURE__ */ defineFormatter("transactionReceipt", formatTransactionReceipt);
+//#endregion
+//#region node_modules/.pnpm/ox@0.14.7_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/core/internal/lru.js
+/**
+* @internal
+*
+* Map with a LRU (Least recently used) policy.
+* @see 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) && value !== void 0) {
+			this.delete(key);
+			super.set(key, value);
+		}
+		return value;
+	}
+	set(key, value) {
+		super.set(key, value);
+		if (this.maxSize && this.size > this.maxSize) {
+			const firstKey = this.keys().next().value;
+			if (firstKey) this.delete(firstKey);
+		}
+		return this;
+	}
+};
+const checksum$1 = { checksum: /* @__PURE__ */ new LruMap(8192) }.checksum;
+//#endregion
+//#region node_modules/.pnpm/ox@0.14.7_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/core/Hash.js
+/**
+* Calculates the [Keccak256](https://en.wikipedia.org/wiki/SHA-3) hash of a {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} value.
+*
+* This function is a re-export of `keccak_256` from [`@noble/hashes`](https://github.com/paulmillr/noble-hashes), an audited & minimal JS hashing library.
+*
+* @example
+* ```ts twoslash
+* import { Hash } from 'ox'
+*
+* Hash.keccak256('0xdeadbeef')
+* // @log: '0xd4fd4e189132273036449fc9e11198c739161b4c0116a9a2dccdfa1c492006f1'
+* ```
+*
+* @example
+* ### Calculate Hash of a String
+*
+* ```ts twoslash
+* import { Hash, Hex } from 'ox'
+*
+* Hash.keccak256(Hex.fromString('hello world'))
+* // @log: '0x3ea2f1d0abf3fc66cf29eebb70cbd4e7fe762ef8a09bcc06c8edf641230afec0'
+* ```
+*
+* @example
+* ### Configure Return Type
+*
+* ```ts twoslash
+* import { Hash } from 'ox'
+*
+* Hash.keccak256('0xdeadbeef', { as: 'Bytes' })
+* // @log: Uint8Array [...]
+* ```
+*
+* @param value - {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} value.
+* @param options - Options.
+* @returns Keccak256 hash.
+*/
+function keccak256(value, options = {}) {
+	const { as = typeof value === "string" ? "Hex" : "Bytes" } = options;
+	const bytes = keccak_256(from$5(value));
+	if (as === "Bytes") return bytes;
+	return fromBytes$2(bytes);
+}
+/**
+* Calculates the [Sha256](https://en.wikipedia.org/wiki/SHA-256) hash of a {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} value.
+*
+* This function is a re-export of `sha256` from [`@noble/hashes`](https://github.com/paulmillr/noble-hashes), an audited & minimal JS hashing library.
+*
+* @example
+* ```ts twoslash
+* import { Hash } from 'ox'
+*
+* Hash.sha256('0xdeadbeef')
+* // '0x5f78c33274e43fa9de5659265c1d917e25c03722dcb0b8d27db8d5feaa813953'
+* ```
+*
+* @param value - {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} value.
+* @param options - Options.
+* @returns Sha256 hash.
+*/
+function sha256(value, options = {}) {
+	const { as = typeof value === "string" ? "Hex" : "Bytes" } = options;
+	const bytes = sha256$1(from$5(value));
+	if (as === "Bytes") return bytes;
+	return fromBytes$2(bytes);
+}
+/**
+* Checks if a string is a valid hash value.
+*
+* @example
+* ```ts twoslash
+* import { Hash } from 'ox'
+*
+* Hash.validate('0x')
+* // @log: false
+*
+* Hash.validate('0x3ea2f1d0abf3fc66cf29eebb70cbd4e7fe762ef8a09bcc06c8edf641230afec0')
+* // @log: true
+* ```
+*
+* @param value - Value to check.
+* @returns Whether the value is a valid hash.
+*/
+function validate$1(value) {
+	return validate$2(value) && size(value) === 32;
+}
+//#endregion
+//#region node_modules/.pnpm/ox@0.14.7_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/core/PublicKey.js
+/**
+* Asserts that a {@link ox#PublicKey.PublicKey} is valid.
+*
+* @example
+* ```ts twoslash
+* import { PublicKey } from 'ox'
+*
+* PublicKey.assert({
+*   prefix: 4,
+*   y: 49782753348462494199823712700004552394425719014458918871452329774910450607807n,
+* })
+* // @error: PublicKey.InvalidError: Value \`{"y":"1"}\` is not a valid public key.
+* // @error: Public key must contain:
+* // @error: - an `x` and `prefix` value (compressed)
+* // @error: - an `x`, `y`, and `prefix` value (uncompressed)
+* ```
+*
+* @param publicKey - The public key object to assert.
+*/
+function assert$2(publicKey, options = {}) {
+	const { compressed } = options;
+	const { prefix, x, y } = publicKey;
+	if (compressed === false || typeof x === "bigint" && typeof y === "bigint") {
+		if (prefix !== 4) throw new InvalidPrefixError({
+			prefix,
+			cause: new InvalidUncompressedPrefixError()
+		});
+		return;
+	}
+	if (compressed === true || typeof x === "bigint" && typeof y === "undefined") {
+		if (prefix !== 3 && prefix !== 2) throw new InvalidPrefixError({
+			prefix,
+			cause: new InvalidCompressedPrefixError()
+		});
+		return;
+	}
+	throw new InvalidError({ publicKey });
+}
+/**
+* Instantiates a typed {@link ox#PublicKey.PublicKey} object from a {@link ox#PublicKey.PublicKey}, {@link ox#Bytes.Bytes}, or {@link ox#Hex.Hex}.
+*
+* @example
+* ```ts twoslash
+* import { PublicKey } from 'ox'
+*
+* const publicKey = PublicKey.from({
+*   prefix: 4,
+*   x: 59295962801117472859457908919941473389380284132224861839820747729565200149877n,
+*   y: 24099691209996290925259367678540227198235484593389470330605641003500238088869n,
+* })
+* // @log: {
+* // @log:   prefix: 4,
+* // @log:   x: 59295962801117472859457908919941473389380284132224861839820747729565200149877n,
+* // @log:   y: 24099691209996290925259367678540227198235484593389470330605641003500238088869n,
+* // @log: }
+* ```
+*
+* @example
+* ### From Serialized
+*
+* ```ts twoslash
+* import { PublicKey } from 'ox'
+*
+* const publicKey = PublicKey.from('0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5')
+* // @log: {
+* // @log:   prefix: 4,
+* // @log:   x: 59295962801117472859457908919941473389380284132224861839820747729565200149877n,
+* // @log:   y: 24099691209996290925259367678540227198235484593389470330605641003500238088869n,
+* // @log: }
+* ```
+*
+* @param value - The public key value to instantiate.
+* @returns The instantiated {@link ox#PublicKey.PublicKey}.
+*/
+function from$4(value) {
+	const publicKey = (() => {
+		if (validate$2(value)) return fromHex$2(value);
+		if (validate$3(value)) return fromBytes$1(value);
+		const { prefix, x, y } = value;
+		if (typeof x === "bigint" && typeof y === "bigint") return {
+			prefix: prefix ?? 4,
+			x,
+			y
+		};
+		return {
+			prefix,
+			x
+		};
+	})();
+	assert$2(publicKey);
+	return publicKey;
+}
+/**
+* Deserializes a {@link ox#PublicKey.PublicKey} from a {@link ox#Bytes.Bytes} value.
+*
+* @example
+* ```ts twoslash
+* // @noErrors
+* import { PublicKey } from 'ox'
+*
+* const publicKey = PublicKey.fromBytes(new Uint8Array([128, 3, 131, ...]))
+* // @log: {
+* // @log:   prefix: 4,
+* // @log:   x: 59295962801117472859457908919941473389380284132224861839820747729565200149877n,
+* // @log:   y: 24099691209996290925259367678540227198235484593389470330605641003500238088869n,
+* // @log: }
+* ```
+*
+* @param publicKey - The serialized public key.
+* @returns The deserialized public key.
+*/
+function fromBytes$1(publicKey) {
+	return fromHex$2(fromBytes$2(publicKey));
+}
+/**
+* Deserializes a {@link ox#PublicKey.PublicKey} from a {@link ox#Hex.Hex} value.
+*
+* @example
+* ```ts twoslash
+* import { PublicKey } from 'ox'
+*
+* const publicKey = PublicKey.fromHex('0x8318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5')
+* // @log: {
+* // @log:   prefix: 4,
+* // @log:   x: 59295962801117472859457908919941473389380284132224861839820747729565200149877n,
+* // @log:   y: 24099691209996290925259367678540227198235484593389470330605641003500238088869n,
+* // @log: }
+* ```
+*
+* @example
+* ### Deserializing a Compressed Public Key
+*
+* ```ts twoslash
+* import { PublicKey } from 'ox'
+*
+* const publicKey = PublicKey.fromHex('0x038318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed75')
+* // @log: {
+* // @log:   prefix: 3,
+* // @log:   x: 59295962801117472859457908919941473389380284132224861839820747729565200149877n,
+* // @log: }
+* ```
+*
+* @param publicKey - The serialized public key.
+* @returns The deserialized public key.
+*/
+function fromHex$2(publicKey) {
+	if (publicKey.length !== 132 && publicKey.length !== 130 && publicKey.length !== 68) throw new InvalidSerializedSizeError$1({ publicKey });
+	if (publicKey.length === 130) return {
+		prefix: 4,
+		x: BigInt(slice(publicKey, 0, 32)),
+		y: BigInt(slice(publicKey, 32, 64))
+	};
+	if (publicKey.length === 132) return {
+		prefix: Number(slice(publicKey, 0, 1)),
+		x: BigInt(slice(publicKey, 1, 33)),
+		y: BigInt(slice(publicKey, 33, 65))
+	};
+	return {
+		prefix: Number(slice(publicKey, 0, 1)),
+		x: BigInt(slice(publicKey, 1, 33))
+	};
+}
+/**
+* Serializes a {@link ox#PublicKey.PublicKey} to {@link ox#Bytes.Bytes}.
+*
+* @example
+* ```ts twoslash
+* import { PublicKey } from 'ox'
+*
+* const publicKey = PublicKey.from({
+*   prefix: 4,
+*   x: 59295962801117472859457908919941473389380284132224861839820747729565200149877n,
+*   y: 24099691209996290925259367678540227198235484593389470330605641003500238088869n,
+* })
+*
+* const bytes = PublicKey.toBytes(publicKey) // [!code focus]
+* // @log: Uint8Array [128, 3, 131, ...]
+* ```
+*
+* @param publicKey - The public key to serialize.
+* @returns The serialized public key.
+*/
+function toBytes(publicKey, options = {}) {
+	return fromHex$3(toHex$2(publicKey, options));
+}
+/**
+* Serializes a {@link ox#PublicKey.PublicKey} to {@link ox#Hex.Hex}.
+*
+* @example
+* ```ts twoslash
+* import { PublicKey } from 'ox'
+*
+* const publicKey = PublicKey.from({
+*   prefix: 4,
+*   x: 59295962801117472859457908919941473389380284132224861839820747729565200149877n,
+*   y: 24099691209996290925259367678540227198235484593389470330605641003500238088869n,
+* })
+*
+* const hex = PublicKey.toHex(publicKey) // [!code focus]
+* // @log: '0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5'
+* ```
+*
+* @param publicKey - The public key to serialize.
+* @returns The serialized public key.
+*/
+function toHex$2(publicKey, options = {}) {
+	assert$2(publicKey);
+	const { prefix, x, y } = publicKey;
+	const { includePrefix = true } = options;
+	return concat(includePrefix ? fromNumber(prefix, { size: 1 }) : "0x", fromNumber(x, { size: 32 }), typeof y === "bigint" ? fromNumber(y, { size: 32 }) : "0x");
+}
+/**
+* Thrown when a public key is invalid.
+*
+* @example
+* ```ts twoslash
+* import { PublicKey } from 'ox'
+*
+* PublicKey.assert({ y: 1n })
+* // @error: PublicKey.InvalidError: Value `{"y":1n}` is not a valid public key.
+* // @error: Public key must contain:
+* // @error: - an `x` and `prefix` value (compressed)
+* // @error: - an `x`, `y`, and `prefix` value (uncompressed)
+* ```
+*/
+var InvalidError = class extends BaseError {
+	constructor({ publicKey }) {
+		super(`Value \`${stringify(publicKey)}\` is not a valid public key.`, { metaMessages: [
+			"Public key must contain:",
+			"- an `x` and `prefix` value (compressed)",
+			"- an `x`, `y`, and `prefix` value (uncompressed)"
+		] });
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "PublicKey.InvalidError"
+		});
+	}
+};
+/** Thrown when a public key has an invalid prefix. */
+var InvalidPrefixError = class extends BaseError {
+	constructor({ prefix, cause }) {
+		super(`Prefix "${prefix}" is invalid.`, { cause });
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "PublicKey.InvalidPrefixError"
+		});
+	}
+};
+/** Thrown when the public key has an invalid prefix for a compressed public key. */
+var InvalidCompressedPrefixError = class extends BaseError {
+	constructor() {
+		super("Prefix must be 2 or 3 for compressed public keys.");
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "PublicKey.InvalidCompressedPrefixError"
+		});
+	}
+};
+/** Thrown when the public key has an invalid prefix for an uncompressed public key. */
+var InvalidUncompressedPrefixError = class extends BaseError {
+	constructor() {
+		super("Prefix must be 4 for uncompressed public keys.");
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "PublicKey.InvalidUncompressedPrefixError"
+		});
+	}
+};
+/** Thrown when the public key has an invalid serialized size. */
+var InvalidSerializedSizeError$1 = class extends BaseError {
+	constructor({ publicKey }) {
+		super(`Value \`${publicKey}\` is an invalid public key size.`, { metaMessages: ["Expected: 33 bytes (compressed + prefix), 64 bytes (uncompressed) or 65 bytes (uncompressed + prefix).", `Received ${size(from$6(publicKey))} bytes.`] });
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "PublicKey.InvalidSerializedSizeError"
+		});
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/ox@0.14.7_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/core/Address.js
+const addressRegex = /^0x[a-fA-F0-9]{40}$/;
+/**
+* Asserts that the given value is a valid {@link ox#Address.Address}.
+*
+* @example
+* ```ts twoslash
+* import { Address } from 'ox'
+*
+* Address.assert('0xA0Cf798816D4b9b9866b5330EEa46a18382f251e')
+* ```
+*
+* @example
+* ```ts twoslash
+* import { Address } from 'ox'
+*
+* Address.assert('0xdeadbeef')
+* // @error: InvalidAddressError: Address "0xdeadbeef" is invalid.
+* ```
+*
+* @param value - Value to assert if it is a valid address.
+* @param options - Assertion options.
+*/
+function assert$1(value, options = {}) {
+	const { strict = true } = options;
+	if (!addressRegex.test(value)) throw new InvalidAddressError({
+		address: value,
+		cause: new InvalidInputError()
+	});
+	if (strict) {
+		if (value.toLowerCase() === value) return;
+		if (checksum(value) !== value) throw new InvalidAddressError({
+			address: value,
+			cause: new InvalidChecksumError()
+		});
+	}
+}
+/**
+* Computes the checksum address for the given {@link ox#Address.Address}.
+*
+* @example
+* ```ts twoslash
+* import { Address } from 'ox'
+*
+* Address.checksum('0xa0cf798816d4b9b9866b5330eea46a18382f251e')
+* // @log: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'
+* ```
+*
+* @param address - The address to compute the checksum for.
+* @returns The checksummed address.
+*/
+function checksum(address) {
+	if (checksum$1.has(address)) return checksum$1.get(address);
+	assert$1(address, { strict: false });
+	const hexAddress = address.substring(2).toLowerCase();
+	const hash = keccak256(fromString(hexAddress), { as: "Bytes" });
+	const characters = hexAddress.split("");
+	for (let i = 0; i < 40; i += 2) {
+		if (hash[i >> 1] >> 4 >= 8 && characters[i]) characters[i] = characters[i].toUpperCase();
+		if ((hash[i >> 1] & 15) >= 8 && characters[i + 1]) characters[i + 1] = characters[i + 1].toUpperCase();
+	}
+	const result = `0x${characters.join("")}`;
+	checksum$1.set(address, result);
+	return result;
+}
+/**
+* Converts a stringified address to a typed (optionally checksummed) {@link ox#Address.Address}.
+*
+* @example
+* ```ts twoslash
+* import { Address } from 'ox'
+*
+* Address.from('0xa0cf798816d4b9b9866b5330eea46a18382f251e')
+* // @log: '0xa0cf798816d4b9b9866b5330eea46a18382f251e'
+* ```
+*
+* @example
+* ```ts twoslash
+* import { Address } from 'ox'
+*
+* Address.from('0xa0cf798816d4b9b9866b5330eea46a18382f251e', {
+*   checksum: true
+* })
+* // @log: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'
+* ```
+*
+* @example
+* ```ts twoslash
+* import { Address } from 'ox'
+*
+* Address.from('hello')
+* // @error: InvalidAddressError: Address "0xa" is invalid.
+* ```
+*
+* @param address - An address string to convert to a typed Address.
+* @param options - Conversion options.
+* @returns The typed Address.
+*/
+function from$3(address, options = {}) {
+	const { checksum: checksumVal = false } = options;
+	assert$1(address);
+	if (checksumVal) return checksum(address);
+	return address;
+}
+/**
+* Converts an ECDSA public key to an {@link ox#Address.Address}.
+*
+* @example
+* ```ts twoslash
+* import { Address, PublicKey } from 'ox'
+*
+* const publicKey = PublicKey.from(
+*   '0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5',
+* )
+* const address = Address.fromPublicKey(publicKey)
+* // @log: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266'
+* ```
+*
+* @param publicKey - The ECDSA public key to convert to an {@link ox#Address.Address}.
+* @param options - Conversion options.
+* @returns The {@link ox#Address.Address} corresponding to the public key.
+*/
+function fromPublicKey(publicKey, options = {}) {
+	return from$3(`0x${keccak256(`0x${toHex$2(publicKey).slice(4)}`).substring(26)}`, options);
+}
+/**
+* Checks if two {@link ox#Address.Address} are equal.
+*
+* @example
+* ```ts twoslash
+* import { Address } from 'ox'
+*
+* Address.isEqual(
+*   '0xa0cf798816d4b9b9866b5330eea46a18382f251e',
+*   '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'
+* )
+* // @log: true
+* ```
+*
+* @example
+* ```ts twoslash
+* import { Address } from 'ox'
+*
+* Address.isEqual(
+*   '0xa0cf798816d4b9b9866b5330eea46a18382f251e',
+*   '0xA0Cf798816D4b9b9866b5330EEa46a18382f251f'
+* )
+* // @log: false
+* ```
+*
+* @param addressA - The first address to compare.
+* @param addressB - The second address to compare.
+* @returns Whether the addresses are equal.
+*/
+function isEqual(addressA, addressB) {
+	assert$1(addressA, { strict: false });
+	assert$1(addressB, { strict: false });
+	return addressA.toLowerCase() === addressB.toLowerCase();
+}
+/**
+* Checks if the given address is a valid {@link ox#Address.Address}.
+*
+* @example
+* ```ts twoslash
+* import { Address } from 'ox'
+*
+* Address.validate('0xA0Cf798816D4b9b9866b5330EEa46a18382f251e')
+* // @log: true
+* ```
+*
+* @example
+* ```ts twoslash
+* import { Address } from 'ox'
+*
+* Address.validate('0xdeadbeef')
+* // @log: false
+* ```
+*
+* @param address - Value to check if it is a valid address.
+* @param options - Check options.
+* @returns Whether the address is a valid address.
+*/
+function validate(address, options = {}) {
+	const { strict = true } = options ?? {};
+	try {
+		assert$1(address, { strict });
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Thrown when an address is invalid.
+*
+* @example
+* ```ts twoslash
+* import { Address } from 'ox'
+*
+* Address.from('0x123')
+* // @error: Address.InvalidAddressError: Address `0x123` is invalid.
+* ```
+*/
+var InvalidAddressError = class extends BaseError {
+	constructor({ address, cause }) {
+		super(`Address "${address}" is invalid.`, { cause });
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Address.InvalidAddressError"
+		});
+	}
+};
+/** Thrown when an address is not a 20 byte (40 hexadecimal character) value. */
+var InvalidInputError = class extends BaseError {
+	constructor() {
+		super("Address is not a 20 byte (40 hexadecimal character) value.");
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Address.InvalidInputError"
+		});
+	}
+};
+/** Thrown when an address does not match its checksum counterpart. */
+var InvalidChecksumError = class extends BaseError {
+	constructor() {
+		super("Address does not match its checksum counterpart.");
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Address.InvalidChecksumError"
+		});
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/ox@0.14.7_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/core/Solidity.js
+const arrayRegex = /^(.*)\[([0-9]*)\]$/;
+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)?$/;
+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/ox@0.14.7_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/core/internal/abiParameters.js
+/** @internal */
+function decodeParameter(cursor, param, options) {
+	const { checksumAddress, staticPosition } = options;
+	const arrayComponents = getArrayComponents(param.type);
+	if (arrayComponents) {
+		const [length, type] = arrayComponents;
+		return decodeArray(cursor, {
+			...param,
+			type
+		}, {
+			checksumAddress,
+			length,
+			staticPosition
+		});
+	}
+	if (param.type === "tuple") return decodeTuple(cursor, param, {
+		checksumAddress,
+		staticPosition
+	});
+	if (param.type === "address") return decodeAddress(cursor, { checksum: checksumAddress });
+	if (param.type === "bool") return decodeBool(cursor);
+	if (param.type.startsWith("bytes")) return decodeBytes(cursor, param, { staticPosition });
+	if (param.type.startsWith("uint") || param.type.startsWith("int")) return decodeNumber(cursor, param);
+	if (param.type === "string") return decodeString(cursor, { staticPosition });
+	throw new InvalidTypeError(param.type);
+}
+const sizeOfLength = 32;
+const sizeOfOffset = 32;
+/** @internal */
+function decodeAddress(cursor, options = {}) {
+	const { checksum: checksum$2 = false } = options;
+	const value = cursor.readBytes(32);
+	const wrap = (address) => checksum$2 ? checksum(address) : address;
+	return [wrap(fromBytes$2(slice$1(value, -20))), 32];
+}
+/** @internal */
+function decodeArray(cursor, param, options) {
+	const { checksumAddress, length, staticPosition } = options;
+	if (!length) {
+		const start = staticPosition + toNumber(cursor.readBytes(sizeOfOffset));
+		const startOfData = start + sizeOfLength;
+		cursor.setPosition(start);
+		const length = toNumber(cursor.readBytes(sizeOfLength));
+		const dynamicChild = hasDynamicChild(param);
+		let consumed = 0;
+		const value = [];
+		for (let i = 0; i < length; ++i) {
+			cursor.setPosition(startOfData + (dynamicChild ? i * 32 : consumed));
+			const [data, consumed_] = decodeParameter(cursor, param, {
+				checksumAddress,
+				staticPosition: startOfData
+			});
+			consumed += consumed_;
+			value.push(data);
+		}
+		cursor.setPosition(staticPosition + 32);
+		return [value, 32];
+	}
+	if (hasDynamicChild(param)) {
+		const start = staticPosition + toNumber(cursor.readBytes(sizeOfOffset));
+		const value = [];
+		for (let i = 0; i < length; ++i) {
+			cursor.setPosition(start + i * 32);
+			const [data] = decodeParameter(cursor, param, {
+				checksumAddress,
+				staticPosition: start
+			});
+			value.push(data);
+		}
+		cursor.setPosition(staticPosition + 32);
+		return [value, 32];
+	}
+	let consumed = 0;
+	const value = [];
+	for (let i = 0; i < length; ++i) {
+		const [data, consumed_] = decodeParameter(cursor, param, {
+			checksumAddress,
+			staticPosition: staticPosition + consumed
+		});
+		consumed += consumed_;
+		value.push(data);
+	}
+	return [value, consumed];
+}
+/** @internal */
+function decodeBool(cursor) {
+	return [toBoolean(cursor.readBytes(32), { size: 32 }), 32];
+}
+/** @internal */
+function decodeBytes(cursor, param, { staticPosition }) {
+	const [_, size] = param.type.split("bytes");
+	if (!size) {
+		const offset = toNumber(cursor.readBytes(32));
+		cursor.setPosition(staticPosition + offset);
+		const length = toNumber(cursor.readBytes(32));
+		if (length === 0) {
+			cursor.setPosition(staticPosition + 32);
+			return ["0x", 32];
+		}
+		const data = cursor.readBytes(length);
+		cursor.setPosition(staticPosition + 32);
+		return [fromBytes$2(data), 32];
+	}
+	return [fromBytes$2(cursor.readBytes(Number.parseInt(size, 10), 32)), 32];
+}
+/** @internal */
+function decodeNumber(cursor, param) {
+	const signed = param.type.startsWith("int");
+	const size = Number.parseInt(param.type.split("int")[1] || "256", 10);
+	const value = cursor.readBytes(32);
+	return [size > 48 ? toBigInt(value, { signed }) : toNumber(value, { signed }), 32];
+}
+/** @internal */
+function decodeTuple(cursor, param, options) {
+	const { checksumAddress, staticPosition } = options;
+	const hasUnnamedChild = param.components.length === 0 || param.components.some(({ name }) => !name);
+	const value = hasUnnamedChild ? [] : {};
+	let consumed = 0;
+	if (hasDynamicChild(param)) {
+		const start = staticPosition + toNumber(cursor.readBytes(sizeOfOffset));
+		for (let i = 0; i < param.components.length; ++i) {
+			const component = param.components[i];
+			cursor.setPosition(start + consumed);
+			const [data, consumed_] = decodeParameter(cursor, component, {
+				checksumAddress,
+				staticPosition: start
+			});
+			consumed += consumed_;
+			value[hasUnnamedChild ? i : component?.name] = data;
+		}
+		cursor.setPosition(staticPosition + 32);
+		return [value, 32];
+	}
+	for (let i = 0; i < param.components.length; ++i) {
+		const component = param.components[i];
+		const [data, consumed_] = decodeParameter(cursor, component, {
+			checksumAddress,
+			staticPosition
+		});
+		value[hasUnnamedChild ? i : component?.name] = data;
+		consumed += consumed_;
+	}
+	return [value, consumed];
+}
+/** @internal */
+function decodeString(cursor, { staticPosition }) {
+	const start = staticPosition + toNumber(cursor.readBytes(32));
+	cursor.setPosition(start);
+	const length = toNumber(cursor.readBytes(32));
+	if (length === 0) {
+		cursor.setPosition(staticPosition + 32);
+		return ["", 32];
+	}
+	const value = toString(trimLeft(cursor.readBytes(length, 32)));
+	cursor.setPosition(staticPosition + 32);
+	return [value, 32];
+}
+/** @internal */
+function prepareParameters({ checksumAddress, parameters, values }) {
+	const preparedParameters = [];
+	for (let i = 0; i < parameters.length; i++) preparedParameters.push(prepareParameter({
+		checksumAddress,
+		parameter: parameters[i],
+		value: values[i]
+	}));
+	return preparedParameters;
+}
+/** @internal */
+function prepareParameter({ checksumAddress = false, parameter: parameter_, value }) {
+	const parameter = parameter_;
+	const arrayComponents = getArrayComponents(parameter.type);
+	if (arrayComponents) {
+		const [length, type] = arrayComponents;
+		return encodeArray(value, {
+			checksumAddress,
+			length,
+			parameter: {
+				...parameter,
+				type
+			}
+		});
+	}
+	if (parameter.type === "tuple") return encodeTuple(value, {
+		checksumAddress,
+		parameter
+	});
+	if (parameter.type === "address") return encodeAddress(value, { checksum: checksumAddress });
+	if (parameter.type === "bool") return encodeBoolean(value);
+	if (parameter.type.startsWith("uint") || parameter.type.startsWith("int")) {
+		const signed = parameter.type.startsWith("int");
+		const [, , size = "256"] = integerRegex.exec(parameter.type) ?? [];
+		return encodeNumber(value, {
+			signed,
+			size: Number(size)
+		});
+	}
+	if (parameter.type.startsWith("bytes")) return encodeBytes(value, { type: parameter.type });
+	if (parameter.type === "string") return encodeString(value);
+	throw new InvalidTypeError(parameter.type);
+}
+/** @internal */
+function encode$1(preparedParameters) {
+	let staticSize = 0;
+	for (let i = 0; i < preparedParameters.length; i++) {
+		const { dynamic, encoded } = preparedParameters[i];
+		if (dynamic) staticSize += 32;
+		else staticSize += size(encoded);
+	}
+	const staticParameters = [];
+	const dynamicParameters = [];
+	let dynamicSize = 0;
+	for (let i = 0; i < preparedParameters.length; i++) {
+		const { dynamic, encoded } = preparedParameters[i];
+		if (dynamic) {
+			staticParameters.push(fromNumber(staticSize + dynamicSize, { size: 32 }));
+			dynamicParameters.push(encoded);
+			dynamicSize += size(encoded);
+		} else staticParameters.push(encoded);
+	}
+	return concat(...staticParameters, ...dynamicParameters);
+}
+/** @internal */
+function encodeAddress(value, options) {
+	const { checksum = false } = options;
+	assert$1(value, { strict: checksum });
+	return {
+		dynamic: false,
+		encoded: padLeft(value.toLowerCase())
+	};
+}
+/** @internal */
+function encodeArray(value, options) {
+	const { checksumAddress, length, parameter } = options;
+	const dynamic = length === null;
+	if (!Array.isArray(value)) throw new InvalidArrayError(value);
+	if (!dynamic && value.length !== length) throw new ArrayLengthMismatchError({
+		expectedLength: length,
+		givenLength: value.length,
+		type: `${parameter.type}[${length}]`
+	});
+	let dynamicChild = false;
+	const preparedParameters = [];
+	for (let i = 0; i < value.length; i++) {
+		const preparedParam = prepareParameter({
+			checksumAddress,
+			parameter,
+			value: value[i]
+		});
+		if (preparedParam.dynamic) dynamicChild = true;
+		preparedParameters.push(preparedParam);
+	}
+	if (dynamic || dynamicChild) {
+		const data = encode$1(preparedParameters);
+		if (dynamic) {
+			const length = fromNumber(preparedParameters.length, { size: 32 });
+			return {
+				dynamic: true,
+				encoded: preparedParameters.length > 0 ? concat(length, data) : length
+			};
+		}
+		if (dynamicChild) return {
+			dynamic: true,
+			encoded: data
+		};
+	}
+	return {
+		dynamic: false,
+		encoded: concat(...preparedParameters.map(({ encoded }) => encoded))
+	};
+}
+/** @internal */
+function encodeBytes(value, { type }) {
+	const [, parametersize] = type.split("bytes");
+	const bytesSize = size(value);
+	if (!parametersize) {
+		let value_ = value;
+		if (bytesSize % 32 !== 0) value_ = padRight(value_, Math.ceil((value.length - 2) / 2 / 32) * 32);
+		return {
+			dynamic: true,
+			encoded: concat(padLeft(fromNumber(bytesSize, { size: 32 })), value_)
+		};
+	}
+	if (bytesSize !== Number.parseInt(parametersize, 10)) throw new BytesSizeMismatchError({
+		expectedSize: Number.parseInt(parametersize, 10),
+		value
+	});
+	return {
+		dynamic: false,
+		encoded: padRight(value)
+	};
+}
+/** @internal */
+function encodeBoolean(value) {
+	if (typeof value !== "boolean") throw new BaseError(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
+	return {
+		dynamic: false,
+		encoded: padLeft(fromBoolean(value))
+	};
+}
+/** @internal */
+function encodeNumber(value, { signed, size }) {
+	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: fromNumber(value, {
+			size: 32,
+			signed
+		})
+	};
+}
+/** @internal */
+function encodeString(value) {
+	const hexValue = fromString$1(value);
+	const partsLength = Math.ceil(size(hexValue) / 32);
+	const parts = [];
+	for (let i = 0; i < partsLength; i++) parts.push(padRight(slice(hexValue, i * 32, (i + 1) * 32)));
+	return {
+		dynamic: true,
+		encoded: concat(padRight(fromNumber(size(hexValue), { size: 32 })), ...parts)
+	};
+}
+/** @internal */
+function encodeTuple(value, options) {
+	const { checksumAddress, parameter } = options;
+	let dynamic = false;
+	const preparedParameters = [];
+	for (let i = 0; i < parameter.components.length; i++) {
+		const param_ = parameter.components[i];
+		const preparedParam = prepareParameter({
+			checksumAddress,
+			parameter: param_,
+			value: value[Array.isArray(value) ? i : param_.name]
+		});
+		preparedParameters.push(preparedParam);
+		if (preparedParam.dynamic) dynamic = true;
+	}
+	return {
+		dynamic,
+		encoded: dynamic ? encode$1(preparedParameters) : concat(...preparedParameters.map(({ encoded }) => encoded))
+	};
+}
+/** @internal */
+function getArrayComponents(type) {
+	const matches = type.match(/^(.*)\[(\d+)?\]$/);
+	return matches ? [matches[2] ? Number(matches[2]) : null, matches[1]] : void 0;
+}
+/** @internal */
+function hasDynamicChild(param) {
+	const { type } = param;
+	if (type === "string") return true;
+	if (type === "bytes") return true;
+	if (type.endsWith("[]")) return true;
+	if (type === "tuple") return param.components?.some(hasDynamicChild);
+	const arrayComponents = getArrayComponents(param.type);
+	if (arrayComponents && hasDynamicChild({
+		...param,
+		type: arrayComponents[1]
+	})) return true;
+	return false;
+}
+//#endregion
+//#region node_modules/.pnpm/ox@0.14.7_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/core/internal/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++;
+	}
+};
+/** @internal */
+function create(bytes, { recursiveReadLimit = 8192 } = {}) {
+	const cursor = Object.create(staticCursor);
+	cursor.bytes = bytes;
+	cursor.dataView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	cursor.positionReadCount = /* @__PURE__ */ new Map();
+	cursor.recursiveReadLimit = recursiveReadLimit;
+	return cursor;
+}
+/** @internal */
+var NegativeOffsetError = class extends BaseError {
+	constructor({ offset }) {
+		super(`Offset \`${offset}\` cannot be negative.`);
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Cursor.NegativeOffsetError"
+		});
+	}
+};
+/** @internal */
+var PositionOutOfBoundsError = class extends BaseError {
+	constructor({ length, position }) {
+		super(`Position \`${position}\` is out of bounds (\`0 < position < ${length}\`).`);
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Cursor.PositionOutOfBoundsError"
+		});
+	}
+};
+/** @internal */
+var RecursiveReadLimitExceededError = class extends BaseError {
+	constructor({ count, limit }) {
+		super(`Recursive read limit of \`${limit}\` exceeded (recursive read count: \`${count}\`).`);
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Cursor.RecursiveReadLimitExceededError"
+		});
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/ox@0.14.7_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/core/AbiParameters.js
+function decode(parameters, data, options = {}) {
+	const { as = "Array", checksumAddress = false } = options;
+	const bytes = typeof data === "string" ? fromHex$3(data) : data;
+	const cursor = create(bytes);
+	if (size$1(bytes) === 0 && parameters.length > 0) throw new ZeroDataError();
+	if (size$1(bytes) && size$1(bytes) < 32) throw new DataSizeTooSmallError({
+		data: typeof data === "string" ? data : fromBytes$2(data),
+		parameters,
+		size: size$1(bytes)
+	});
+	let consumed = 0;
+	const values = as === "Array" ? [] : {};
+	for (let i = 0; i < parameters.length; ++i) {
+		const param = parameters[i];
+		cursor.setPosition(consumed);
+		const [data, consumed_] = decodeParameter(cursor, param, {
+			checksumAddress,
+			staticPosition: 0
+		});
+		consumed += consumed_;
+		if (as === "Array") values.push(data);
+		else values[param.name ?? i] = data;
+	}
+	return values;
+}
+/**
+* Encodes primitive values into ABI encoded data as per the [Application Binary Interface (ABI) Specification](https://docs.soliditylang.org/en/latest/abi-spec).
+*
+* @example
+* ```ts twoslash
+* import { AbiParameters } from 'ox'
+*
+* const data = AbiParameters.encode(
+*   AbiParameters.from(['string', 'uint', 'bool']),
+*   ['wagmi', 420n, true],
+* )
+* ```
+*
+* @example
+* ### JSON Parameters
+*
+* Specify **JSON ABI** Parameters as schema:
+*
+* ```ts twoslash
+* import { AbiParameters } from 'ox'
+*
+* const data = AbiParameters.encode(
+*   [
+*     { type: 'string', name: 'name' },
+*     { type: 'uint', name: 'age' },
+*     { type: 'bool', name: 'isOwner' },
+*   ],
+*   ['wagmi', 420n, true],
+* )
+* ```
+*
+* @param parameters - The set of ABI parameters to encode, in the shape of the `inputs` or `outputs` attribute of an ABI Item. These parameters must include valid [ABI types](https://docs.soliditylang.org/en/latest/types.html).
+* @param values - The set of primitive values that correspond to the ABI types defined in `parameters`.
+* @returns ABI encoded data.
+*/
+function encode(parameters, values, options) {
+	const { checksumAddress = false } = options ?? {};
+	if (parameters.length !== values.length) throw new LengthMismatchError({
+		expectedLength: parameters.length,
+		givenLength: values.length
+	});
+	const data = encode$1(prepareParameters({
+		checksumAddress,
+		parameters,
+		values
+	}));
+	if (data.length === 0) return "0x";
+	return data;
+}
+/**
+* Encodes an array of primitive values to a [packed ABI encoding](https://docs.soliditylang.org/en/latest/abi-spec.html#non-standard-packed-mode).
+*
+* @example
+* ```ts twoslash
+* import { AbiParameters } from 'ox'
+*
+* const encoded = AbiParameters.encodePacked(
+*   ['address', 'string'],
+*   ['0xd8da6bf26964af9d7eed9e03e53415d37aa96045', 'hello world'],
+* )
+* // @log: '0xd8da6bf26964af9d7eed9e03e53415d37aa9604568656c6c6f20776f726c64'
+* ```
+*
+* @param types - Set of ABI types to pack encode.
+* @param values - The set of primitive values that correspond to the ABI types defined in `types`.
+* @returns The encoded packed data.
+*/
+function encodePacked(types, values) {
+	if (types.length !== values.length) throw new LengthMismatchError({
+		expectedLength: types.length,
+		givenLength: values.length
+	});
+	const data = [];
+	for (let i = 0; i < types.length; i++) {
+		const type = types[i];
+		const value = values[i];
+		data.push(encodePacked.encode(type, value));
+	}
+	return concat(...data);
+}
+(function(encodePacked) {
+	function encode(type, value, isArray = false) {
+		if (type === "address") {
+			const address = value;
+			assert$1(address);
+			return padLeft(address.toLowerCase(), isArray ? 32 : 0);
+		}
+		if (type === "string") return fromString$1(value);
+		if (type === "bytes") return value;
+		if (type === "bool") return padLeft(fromBoolean(value), isArray ? 32 : 1);
+		const intMatch = type.match(integerRegex);
+		if (intMatch) {
+			const [_type, baseType, bits = "256"] = intMatch;
+			const size = Number.parseInt(bits, 10) / 8;
+			return fromNumber(value, {
+				size: isArray ? 32 : size,
+				signed: baseType === "int"
+			});
+		}
+		const bytesMatch = type.match(bytesRegex);
+		if (bytesMatch) {
+			const [_type, size] = bytesMatch;
+			if (Number.parseInt(size, 10) !== (value.length - 2) / 2) throw new BytesSizeMismatchError({
+				expectedSize: Number.parseInt(size, 10),
+				value
+			});
+			return padRight(value, isArray ? 32 : 0);
+		}
+		const arrayMatch = type.match(arrayRegex);
+		if (arrayMatch && Array.isArray(value)) {
+			const [_type, childType] = arrayMatch;
+			const data = [];
+			for (let i = 0; i < value.length; i++) data.push(encode(childType, value[i], true));
+			if (data.length === 0) return "0x";
+			return concat(...data);
+		}
+		throw new InvalidTypeError(type);
+	}
+	encodePacked.encode = encode;
+})(encodePacked || (encodePacked = {}));
+/**
+* Parses arbitrary **JSON ABI Parameters** or **Human Readable ABI Parameters** into typed {@link ox#AbiParameters.AbiParameters}.
+*
+* @example
+* ### JSON Parameters
+*
+* ```ts twoslash
+* import { AbiParameters } from 'ox'
+*
+* const parameters = AbiParameters.from([
+*   {
+*     name: 'spender',
+*     type: 'address',
+*   },
+*   {
+*     name: 'amount',
+*     type: 'uint256',
+*   },
+* ])
+*
+* parameters
+* //^?
+*
+*
+*
+*
+*
+*
+*
+* ```
+*
+* @example
+* ### Human Readable Parameters
+*
+* Human Readable ABI Parameters can be parsed into a typed {@link ox#AbiParameters.AbiParameters}:
+*
+* ```ts twoslash
+* import { AbiParameters } from 'ox'
+*
+* const parameters = AbiParameters.from('address spender, uint256 amount')
+*
+* parameters
+* //^?
+*
+*
+*
+*
+*
+*
+*
+* ```
+*
+* @example
+* It is possible to specify `struct`s along with your definitions:
+*
+* ```ts twoslash
+* import { AbiParameters } from 'ox'
+*
+* const parameters = AbiParameters.from([
+*   'struct Foo { address spender; uint256 amount; }', // [!code hl]
+*   'Foo foo, address bar',
+* ])
+*
+* parameters
+* //^?
+*
+*
+*
+*
+*
+*
+*
+*
+*
+*
+*
+*
+* ```
+*
+*
+*
+* @param parameters - The ABI Parameters to parse.
+* @returns The typed ABI Parameters.
+*/
+function from$2(parameters) {
+	if (Array.isArray(parameters) && typeof parameters[0] === "string") return parseAbiParameters(parameters);
+	if (typeof parameters === "string") return parseAbiParameters(parameters);
+	return parameters;
+}
+/**
+* Throws when the data size is too small for the given parameters.
+*
+* @example
+* ```ts twoslash
+* import { AbiParameters } from 'ox'
+*
+* AbiParameters.decode([{ type: 'uint256' }], '0x010f')
+* //                                             ↑ ❌ 2 bytes
+* // @error: AbiParameters.DataSizeTooSmallError: Data size of 2 bytes is too small for given parameters.
+* // @error: Params: (uint256)
+* // @error: Data:   0x010f (2 bytes)
+* ```
+*
+* ### Solution
+*
+* Pass a valid data size.
+*
+* ```ts twoslash
+* import { AbiParameters } from 'ox'
+*
+* AbiParameters.decode([{ type: 'uint256' }], '0x00000000000000000000000000000000000000000000000000000000000010f')
+* //                                             ↑ ✅ 32 bytes
+* ```
+*/
+var DataSizeTooSmallError = class extends BaseError {
+	constructor({ data, parameters, size }) {
+		super(`Data size of ${size} bytes is too small for given parameters.`, { metaMessages: [`Params: (${formatAbiParameters(parameters)})`, `Data:   ${data} (${size} bytes)`] });
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "AbiParameters.DataSizeTooSmallError"
+		});
+	}
+};
+/**
+* Throws when zero data is provided, but data is expected.
+*
+* @example
+* ```ts twoslash
+* import { AbiParameters } from 'ox'
+*
+* AbiParameters.decode([{ type: 'uint256' }], '0x')
+* //                                           ↑ ❌ zero data
+* // @error: AbiParameters.DataSizeTooSmallError: Data size of 2 bytes is too small for given parameters.
+* // @error: Params: (uint256)
+* // @error: Data:   0x010f (2 bytes)
+* ```
+*
+* ### Solution
+*
+* Pass valid data.
+*
+* ```ts twoslash
+* import { AbiParameters } from 'ox'
+*
+* AbiParameters.decode([{ type: 'uint256' }], '0x00000000000000000000000000000000000000000000000000000000000010f')
+* //                                             ↑ ✅ 32 bytes
+* ```
+*/
+var ZeroDataError = class extends BaseError {
+	constructor() {
+		super("Cannot decode zero data (\"0x\") with ABI parameters.");
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "AbiParameters.ZeroDataError"
+		});
+	}
+};
+/**
+* The length of the array value does not match the length specified in the corresponding ABI parameter.
+*
+* ### Example
+*
+* ```ts twoslash
+* // @noErrors
+* import { AbiParameters } from 'ox'
+* // ---cut---
+* AbiParameters.encode(AbiParameters.from('uint256[3]'), [[69n, 420n]])
+* //                                               ↑ expected: 3  ↑ ❌ length: 2
+* // @error: AbiParameters.ArrayLengthMismatchError: ABI encoding array length mismatch
+* // @error: for type `uint256[3]`. Expected: `3`. Given: `2`.
+* ```
+*
+* ### Solution
+*
+* Pass an array of the correct length.
+*
+* ```ts twoslash
+* import { AbiParameters } from 'ox'
+* // ---cut---
+* AbiParameters.encode(AbiParameters.from(['uint256[3]']), [[69n, 420n, 69n]])
+* //                                                         ↑ ✅ length: 3
+* ```
+*/
+var ArrayLengthMismatchError = class extends BaseError {
+	constructor({ expectedLength, givenLength, type }) {
+		super(`Array length mismatch for type \`${type}\`. Expected: \`${expectedLength}\`. Given: \`${givenLength}\`.`);
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "AbiParameters.ArrayLengthMismatchError"
+		});
+	}
+};
+/**
+* The size of the bytes value does not match the size specified in the corresponding ABI parameter.
+*
+* ### Example
+*
+* ```ts twoslash
+* // @noErrors
+* import { AbiParameters } from 'ox'
+* // ---cut---
+* AbiParameters.encode(AbiParameters.from('bytes8'), [['0xdeadbeefdeadbeefdeadbeef']])
+* //                                            ↑ expected: 8 bytes  ↑ ❌ size: 12 bytes
+* // @error: BytesSizeMismatchError: Size of bytes "0xdeadbeefdeadbeefdeadbeef"
+* // @error: (bytes12) does not match expected size (bytes8).
+* ```
+*
+* ### Solution
+*
+* Pass a bytes value of the correct size.
+*
+* ```ts twoslash
+* import { AbiParameters } from 'ox'
+* // ---cut---
+* AbiParameters.encode(AbiParameters.from(['bytes8']), ['0xdeadbeefdeadbeef'])
+* //                                                       ↑ ✅ size: 8 bytes
+* ```
+*/
+var BytesSizeMismatchError = class extends BaseError {
+	constructor({ expectedSize, value }) {
+		super(`Size of bytes "${value}" (bytes${size(value)}) does not match expected size (bytes${expectedSize}).`);
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "AbiParameters.BytesSizeMismatchError"
+		});
+	}
+};
+/**
+* The length of the values to encode does not match the length of the ABI parameters.
+*
+* ### Example
+*
+* ```ts twoslash
+* // @noErrors
+* import { AbiParameters } from 'ox'
+* // ---cut---
+* AbiParameters.encode(AbiParameters.from(['string', 'uint256']), ['hello'])
+* // @error: LengthMismatchError: ABI encoding params/values length mismatch.
+* // @error: Expected length (params): 2
+* // @error: Given length (values): 1
+* ```
+*
+* ### Solution
+*
+* Pass the correct number of values to encode.
+*
+* ### Solution
+*
+* Pass a [valid ABI type](https://docs.soliditylang.org/en/develop/abi-spec.html#types).
+*/
+var LengthMismatchError = class extends BaseError {
+	constructor({ expectedLength, givenLength }) {
+		super([
+			"ABI encoding parameters/values length mismatch.",
+			`Expected length (parameters): ${expectedLength}`,
+			`Given length (values): ${givenLength}`
+		].join("\n"));
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "AbiParameters.LengthMismatchError"
+		});
+	}
+};
+/**
+* The value provided is not a valid array as specified in the corresponding ABI parameter.
+*
+* ### Example
+*
+* ```ts twoslash
+* // @noErrors
+* import { AbiParameters } from 'ox'
+* // ---cut---
+* AbiParameters.encode(AbiParameters.from(['uint256[3]']), [69])
+* ```
+*
+* ### Solution
+*
+* Pass an array value.
+*/
+var InvalidArrayError = class extends BaseError {
+	constructor(value) {
+		super(`Value \`${value}\` is not a valid array.`);
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "AbiParameters.InvalidArrayError"
+		});
+	}
+};
+/**
+* Throws when the ABI parameter type is invalid.
+*
+* @example
+* ```ts twoslash
+* import { AbiParameters } from 'ox'
+*
+* AbiParameters.decode([{ type: 'lol' }], '0x00000000000000000000000000000000000000000000000000000000000010f')
+* //                             ↑ ❌ invalid type
+* // @error: AbiParameters.InvalidTypeError: Type `lol` is not a valid ABI Type.
+* ```
+*/
+var InvalidTypeError = class extends BaseError {
+	constructor(type) {
+		super(`Type \`${type}\` is not a valid ABI Type.`);
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "AbiParameters.InvalidTypeError"
+		});
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/ox@0.14.7_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/core/Rlp.js
+/**
+* Decodes a Recursive-Length Prefix (RLP) value into a {@link ox#Hex.Hex} value.
+*
+* @example
+* ```ts twoslash
+* import { Rlp } from 'ox'
+* Rlp.toHex('0x8b68656c6c6f20776f726c64')
+* // 0x68656c6c6f20776f726c64
+* ```
+*
+* @param value - The value to decode.
+* @returns The decoded {@link ox#Hex.Hex} value.
+*/
+function toHex$1(value) {
+	return to(value, "Hex");
+}
+/** @internal */
+function to(value, to) {
+	const to_ = to ?? (typeof value === "string" ? "Hex" : "Bytes");
+	return decodeRlpCursor(create((() => {
+		if (typeof value === "string") {
+			if (value.length > 3 && value.length % 2 !== 0) throw new InvalidLengthError(value);
+			return fromHex$3(value);
+		}
+		return value;
+	})(), { recursiveReadLimit: Number.POSITIVE_INFINITY }), to_);
+}
+/** @internal */
+/** @internal */
+function decodeRlpCursor(cursor, to = "Hex") {
+	if (cursor.bytes.length === 0) return to === "Hex" ? fromBytes$2(cursor.bytes) : cursor.bytes;
+	const prefix = cursor.readByte();
+	if (prefix < 128) cursor.decrementPosition(1);
+	if (prefix < 192) {
+		const length = readLength(cursor, prefix, 128);
+		const bytes = cursor.readBytes(length);
+		return to === "Hex" ? fromBytes$2(bytes) : bytes;
+	}
+	return readList(cursor, readLength(cursor, prefix, 192), to);
+}
+/** @internal */
+function readLength(cursor, prefix, offset) {
+	if (offset === 128 && prefix < 128) return 1;
+	if (prefix <= offset + 55) return prefix - offset;
+	if (prefix === offset + 55 + 1) return cursor.readUint8();
+	if (prefix === offset + 55 + 2) return cursor.readUint16();
+	if (prefix === offset + 55 + 3) return cursor.readUint24();
+	if (prefix === offset + 55 + 4) return cursor.readUint32();
+	throw new BaseError("Invalid RLP prefix");
+}
+/** @internal */
+function readList(cursor, length, to) {
+	const position = cursor.position;
+	const value = [];
+	while (cursor.position - position < length) value.push(decodeRlpCursor(cursor, to));
+	return value;
+}
+/**
+* Encodes a {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} value into a Recursive-Length Prefix (RLP) value.
+*
+* @example
+* ```ts twoslash
+* import { Bytes, Rlp } from 'ox'
+*
+* Rlp.from('0x68656c6c6f20776f726c64', { as: 'Hex' })
+* // @log: 0x8b68656c6c6f20776f726c64
+*
+* Rlp.from(Bytes.from([139, 104, 101, 108, 108, 111,  32, 119, 111, 114, 108, 100]), { as: 'Bytes' })
+* // @log: Uint8Array([104, 101, 108, 108, 111,  32, 119, 111, 114, 108, 100])
+* ```
+*
+* @param value - The {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} value to encode.
+* @param options - Options.
+* @returns The RLP value.
+*/
+function from$1(value, options) {
+	const { as } = options;
+	const encodable = getEncodable(value);
+	const cursor = create(new Uint8Array(encodable.length));
+	encodable.encode(cursor);
+	if (as === "Hex") return fromBytes$2(cursor.bytes);
+	return cursor.bytes;
+}
+/**
+* Encodes a {@link ox#Hex.Hex} value into a Recursive-Length Prefix (RLP) value.
+*
+* @example
+* ```ts twoslash
+* import { Rlp } from 'ox'
+*
+* Rlp.fromHex('0x68656c6c6f20776f726c64')
+* // @log: 0x8b68656c6c6f20776f726c64
+* ```
+*
+* @param hex - The {@link ox#Hex.Hex} value to encode.
+* @param options - Options.
+* @returns The RLP value.
+*/
+function fromHex$1(hex, options = {}) {
+	const { as = "Hex" } = options;
+	return from$1(hex, { as });
+}
+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" ? fromHex$3(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 <= 255) return 1;
+	if (length <= 65535) return 2;
+	if (length <= 16777215) return 3;
+	if (length <= 4294967295) return 4;
+	throw new BaseError("Length is too large.");
+}
+//#endregion
+//#region node_modules/.pnpm/ox@0.14.7_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/core/Signature.js
+/**
+* Asserts that a Signature is valid.
+*
+* @example
+* ```ts twoslash
+* import { Signature } from 'ox'
+*
+* Signature.assert({
+*   r: -49782753348462494199823712700004552394425719014458918871452329774910450607807n,
+*   s: 33726695977844476214676913201140481102225469284307016937915595756355928419768n,
+*   yParity: 1,
+* })
+* // @error: InvalidSignatureRError:
+* // @error: Value `-549...n` is an invalid r value.
+* // @error: r must be a positive integer less than 2^256.
+* ```
+*
+* @param signature - The signature object to assert.
+*/
+function assert(signature, options = {}) {
+	const { recovered } = options;
+	if (typeof signature.r === "undefined") throw new MissingPropertiesError({ signature });
+	if (typeof signature.s === "undefined") throw new MissingPropertiesError({ signature });
+	if (recovered && typeof signature.yParity === "undefined") throw new MissingPropertiesError({ signature });
+	if (signature.r < 0n || signature.r > maxUint256) throw new InvalidRError({ value: signature.r });
+	if (signature.s < 0n || signature.s > maxUint256) throw new InvalidSError({ value: signature.s });
+	if (typeof signature.yParity === "number" && signature.yParity !== 0 && signature.yParity !== 1) throw new InvalidYParityError({ value: signature.yParity });
+}
+/**
+* Deserializes a {@link ox#Bytes.Bytes} signature into a structured {@link ox#Signature.Signature}.
+*
+* @example
+* ```ts twoslash
+* // @noErrors
+* import { Signature } from 'ox'
+*
+* Signature.fromBytes(new Uint8Array([128, 3, 131, ...]))
+* // @log: { r: 5231...n, s: 3522...n, yParity: 0 }
+* ```
+*
+* @param signature - The serialized signature.
+* @returns The deserialized {@link ox#Signature.Signature}.
+*/
+function fromBytes(signature) {
+	return fromHex(fromBytes$2(signature));
+}
+/**
+* Deserializes a {@link ox#Hex.Hex} signature into a structured {@link ox#Signature.Signature}.
+*
+* @example
+* ```ts twoslash
+* import { Signature } from 'ox'
+*
+* Signature.fromHex('0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db81c')
+* // @log: { r: 5231...n, s: 3522...n, yParity: 0 }
+* ```
+*
+* @param serialized - The serialized signature.
+* @returns The deserialized {@link ox#Signature.Signature}.
+*/
+function fromHex(signature) {
+	if (signature.length !== 130 && signature.length !== 132) throw new InvalidSerializedSizeError({ signature });
+	const r = BigInt(slice(signature, 0, 32));
+	const s = BigInt(slice(signature, 32, 64));
+	const yParity = (() => {
+		const yParity = Number(`0x${signature.slice(130)}`);
+		if (Number.isNaN(yParity)) return void 0;
+		try {
+			return vToYParity(yParity);
+		} catch {
+			throw new InvalidYParityError({ value: yParity });
+		}
+	})();
+	if (typeof yParity === "undefined") return {
+		r,
+		s
+	};
+	return {
+		r,
+		s,
+		yParity
+	};
+}
+/**
+* Extracts a {@link ox#Signature.Signature} from an arbitrary object that may include signature properties.
+*
+* @example
+* ```ts twoslash
+* // @noErrors
+* import { Signature } from 'ox'
+*
+* Signature.extract({
+*   baz: 'barry',
+*   foo: 'bar',
+*   r: 49782753348462494199823712700004552394425719014458918871452329774910450607807n,
+*   s: 33726695977844476214676913201140481102225469284307016937915595756355928419768n,
+*   yParity: 1,
+*   zebra: 'stripes',
+* })
+* // @log: {
+* // @log:   r: 49782753348462494199823712700004552394425719014458918871452329774910450607807n,
+* // @log:   s: 33726695977844476214676913201140481102225469284307016937915595756355928419768n,
+* // @log:   yParity: 1
+* // @log: }
+* ```
+*
+* @param value - The arbitrary object to extract the signature from.
+* @returns The extracted {@link ox#Signature.Signature}.
+*/
+function extract(value) {
+	if (typeof value.r === "undefined") return void 0;
+	if (typeof value.s === "undefined") return void 0;
+	return from(value);
+}
+/**
+* Instantiates a typed {@link ox#Signature.Signature} object from a {@link ox#Signature.Signature}, {@link ox#Signature.Legacy}, {@link ox#Bytes.Bytes}, or {@link ox#Hex.Hex}.
+*
+* @example
+* ```ts twoslash
+* import { Signature } from 'ox'
+*
+* Signature.from({
+*   r: 49782753348462494199823712700004552394425719014458918871452329774910450607807n,
+*   s: 33726695977844476214676913201140481102225469284307016937915595756355928419768n,
+*   yParity: 1,
+* })
+* // @log: {
+* // @log:   r: 49782753348462494199823712700004552394425719014458918871452329774910450607807n,
+* // @log:   s: 33726695977844476214676913201140481102225469284307016937915595756355928419768n,
+* // @log:   yParity: 1
+* // @log: }
+* ```
+*
+* @example
+* ### From Serialized
+*
+* ```ts twoslash
+* import { Signature } from 'ox'
+*
+* Signature.from('0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db801')
+* // @log: {
+* // @log:   r: 49782753348462494199823712700004552394425719014458918871452329774910450607807n,
+* // @log:   s: 33726695977844476214676913201140481102225469284307016937915595756355928419768n,
+* // @log:   yParity: 1,
+* // @log: }
+* ```
+*
+* @example
+* ### From Legacy
+*
+* ```ts twoslash
+* import { Signature } from 'ox'
+*
+* Signature.from({
+*   r: 47323457007453657207889730243826965761922296599680473886588287015755652701072n,
+*   s: 57228803202727131502949358313456071280488184270258293674242124340113824882788n,
+*   v: 27,
+* })
+* // @log: {
+* // @log:   r: 47323457007453657207889730243826965761922296599680473886588287015755652701072n,
+* // @log:   s: 57228803202727131502949358313456071280488184270258293674242124340113824882788n,
+* // @log:   yParity: 0
+* // @log: }
+* ```
+*
+* @param signature - The signature value to instantiate.
+* @returns The instantiated {@link ox#Signature.Signature}.
+*/
+function from(signature) {
+	const signature_ = (() => {
+		if (typeof signature === "string") return fromHex(signature);
+		if (signature instanceof Uint8Array) return fromBytes(signature);
+		if (typeof signature.r === "string") return fromRpc(signature);
+		if (signature.v) return fromLegacy(signature);
+		return {
+			r: signature.r,
+			s: signature.s,
+			...typeof signature.yParity !== "undefined" ? { yParity: signature.yParity } : {}
+		};
+	})();
+	assert(signature_);
+	return signature_;
+}
+/**
+* Converts a {@link ox#Signature.Legacy} into a {@link ox#Signature.Signature}.
+*
+* @example
+* ```ts twoslash
+* import { Signature } from 'ox'
+*
+* const legacy = Signature.fromLegacy({ r: 1n, s: 2n, v: 28 })
+* // @log: { r: 1n, s: 2n, yParity: 1 }
+* ```
+*
+* @param signature - The {@link ox#Signature.Legacy} to convert.
+* @returns The converted {@link ox#Signature.Signature}.
+*/
+function fromLegacy(signature) {
+	return {
+		r: signature.r,
+		s: signature.s,
+		yParity: vToYParity(signature.v)
+	};
+}
+/**
+* Converts a {@link ox#Signature.Rpc} into a {@link ox#Signature.Signature}.
+*
+* @example
+* ```ts twoslash
+* import { Signature } from 'ox'
+*
+* const signature = Signature.fromRpc({
+*   r: '0x635dc2033e60185bb36709c29c75d64ea51dfbd91c32ef4be198e4ceb169fb4d',
+*   s: '0x50c2667ac4c771072746acfdcf1f1483336dcca8bd2df47cd83175dbe60f0540',
+*   yParity: '0x0',
+* })
+* ```
+*
+* @param signature - The {@link ox#Signature.Rpc} to convert.
+* @returns The converted {@link ox#Signature.Signature}.
+*/
+function fromRpc(signature) {
+	const yParity = (() => {
+		const v = signature.v ? Number(signature.v) : void 0;
+		let yParity = signature.yParity ? Number(signature.yParity) : void 0;
+		if (typeof v === "number" && typeof yParity !== "number") yParity = vToYParity(v);
+		if (typeof yParity !== "number") throw new InvalidYParityError({ value: signature.yParity });
+		return yParity;
+	})();
+	return {
+		r: BigInt(signature.r),
+		s: BigInt(signature.s),
+		yParity
+	};
+}
+/**
+* Converts a {@link ox#Signature.Tuple} to a {@link ox#Signature.Signature}.
+*
+* @example
+* ```ts twoslash
+* import { Signature } from 'ox'
+*
+* const signature = Signature.fromTuple(['0x01', '0x7b', '0x1c8'])
+* // @log: {
+* // @log:   r: 123n,
+* // @log:   s: 456n,
+* // @log:   yParity: 1,
+* // @log: }
+* ```
+*
+* @param tuple - The {@link ox#Signature.Tuple} to convert.
+* @returns The {@link ox#Signature.Signature}.
+*/
+function fromTuple(tuple) {
+	const [yParity, r, s] = tuple;
+	return from({
+		r: r === "0x" ? 0n : BigInt(r),
+		s: s === "0x" ? 0n : BigInt(s),
+		yParity: yParity === "0x" ? 0 : Number(yParity)
+	});
+}
+/**
+* Serializes a {@link ox#Signature.Signature} to {@link ox#Hex.Hex}.
+*
+* @example
+* ```ts twoslash
+* import { Signature } from 'ox'
+*
+* const signature = Signature.toHex({
+*   r: 49782753348462494199823712700004552394425719014458918871452329774910450607807n,
+*   s: 33726695977844476214676913201140481102225469284307016937915595756355928419768n,
+*   yParity: 1
+* })
+* // @log: '0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db81c'
+* ```
+*
+* @param signature - The signature to serialize.
+* @returns The serialized signature.
+*/
+function toHex(signature) {
+	assert(signature);
+	const r = signature.r;
+	const s = signature.s;
+	return concat(fromNumber(r, { size: 32 }), fromNumber(s, { size: 32 }), typeof signature.yParity === "number" ? fromNumber(yParityToV(signature.yParity), { size: 1 }) : "0x");
+}
+/**
+* Converts a {@link ox#Signature.Signature} into a {@link ox#Signature.Rpc}.
+*
+* @example
+* ```ts twoslash
+* import { Signature } from 'ox'
+*
+* const signature = Signature.toRpc({
+*   r: 49782753348462494199823712700004552394425719014458918871452329774910450607807n,
+*   s: 33726695977844476214676913201140481102225469284307016937915595756355928419768n,
+*   yParity: 1
+* })
+* ```
+*
+* @param signature - The {@link ox#Signature.Signature} to convert.
+* @returns The converted {@link ox#Signature.Rpc}.
+*/
+function toRpc(signature) {
+	const { r, s, yParity } = signature;
+	return {
+		r: fromNumber(r, { size: 32 }),
+		s: fromNumber(s, { size: 32 }),
+		yParity: yParity === 0 ? "0x0" : "0x1"
+	};
+}
+/**
+* Converts a {@link ox#Signature.Signature} to a serialized {@link ox#Signature.Tuple} to be used for signatures in Transaction Envelopes, EIP-7702 Authorization Lists, etc.
+*
+* @example
+* ```ts twoslash
+* import { Signature } from 'ox'
+*
+* const signatureTuple = Signature.toTuple({
+*   r: 123n,
+*   s: 456n,
+*   yParity: 1,
+* })
+* // @log: [yParity: '0x01', r: '0x7b', s: '0x1c8']
+* ```
+*
+* @param signature - The {@link ox#Signature.Signature} to convert.
+* @returns The {@link ox#Signature.Tuple}.
+*/
+function toTuple(signature) {
+	const { r, s, yParity } = signature;
+	return [
+		yParity ? "0x01" : "0x",
+		r === 0n ? "0x" : trimLeft$1(fromNumber(r)),
+		s === 0n ? "0x" : trimLeft$1(fromNumber(s))
+	];
+}
+/**
+* Converts a ECDSA `v` value to a `yParity` value.
+*
+* @example
+* ```ts twoslash
+* import { Signature } from 'ox'
+*
+* const yParity = Signature.vToYParity(28)
+* // @log: 1
+* ```
+*
+* @param v - The ECDSA `v` value to convert.
+* @returns The `yParity` value.
+*/
+function vToYParity(v) {
+	if (v === 0 || v === 27) return 0;
+	if (v === 1 || v === 28) return 1;
+	if (v >= 35) return v % 2 === 0 ? 1 : 0;
+	throw new InvalidVError({ value: v });
+}
+/**
+* Converts a ECDSA `v` value to a `yParity` value.
+*
+* @example
+* ```ts twoslash
+* import { Signature } from 'ox'
+*
+* const v = Signature.yParityToV(1)
+* // @log: 28
+* ```
+*
+* @param yParity - The ECDSA `yParity` value to convert.
+* @returns The `v` value.
+*/
+function yParityToV(yParity) {
+	if (yParity === 0) return 27;
+	if (yParity === 1) return 28;
+	throw new InvalidYParityError({ value: yParity });
+}
+/** Thrown when the serialized signature is of an invalid size. */
+var InvalidSerializedSizeError = class extends BaseError {
+	constructor({ signature }) {
+		super(`Value \`${signature}\` is an invalid signature size.`, { metaMessages: ["Expected: 64 bytes or 65 bytes.", `Received ${size(from$6(signature))} bytes.`] });
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Signature.InvalidSerializedSizeError"
+		});
+	}
+};
+/** Thrown when the signature is missing either an `r`, `s`, or `yParity` property. */
+var MissingPropertiesError = class extends BaseError {
+	constructor({ signature }) {
+		super(`Signature \`${stringify(signature)}\` is missing either an \`r\`, \`s\`, or \`yParity\` property.`);
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Signature.MissingPropertiesError"
+		});
+	}
+};
+/** Thrown when the signature has an invalid `r` value. */
+var InvalidRError = class extends BaseError {
+	constructor({ value }) {
+		super(`Value \`${value}\` is an invalid r value. r must be a positive integer less than 2^256.`);
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Signature.InvalidRError"
+		});
+	}
+};
+/** Thrown when the signature has an invalid `s` value. */
+var InvalidSError = class extends BaseError {
+	constructor({ value }) {
+		super(`Value \`${value}\` is an invalid s value. s must be a positive integer less than 2^256.`);
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Signature.InvalidSError"
+		});
+	}
+};
+/** Thrown when the signature has an invalid `yParity` value. */
+var InvalidYParityError = class extends BaseError {
+	constructor({ value }) {
+		super(`Value \`${value}\` is an invalid y-parity value. Y-parity must be 0 or 1.`);
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Signature.InvalidYParityError"
+		});
+	}
+};
+/** Thrown when the signature has an invalid `v` value. */
+var InvalidVError = class extends BaseError {
+	constructor({ value }) {
+		super(`Value \`${value}\` is an invalid v value. v must be 27, 28 or >=35.`);
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "Signature.InvalidVError"
+		});
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/ox@0.14.7_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/core/Secp256k1.js
+/**
+* Recovers the signing address from the signed payload and signature.
+*
+* @example
+* ```ts twoslash
+* import { Secp256k1 } from 'ox'
+*
+* const signature = Secp256k1.sign({ payload: '0xdeadbeef', privateKey: '0x...' })
+*
+* const address = Secp256k1.recoverAddress({ // [!code focus]
+*   payload: '0xdeadbeef', // [!code focus]
+*   signature, // [!code focus]
+* }) // [!code focus]
+* ```
+*
+* @param options - The recovery options.
+* @returns The recovered address.
+*/
+function recoverAddress(options) {
+	return fromPublicKey(recoverPublicKey(options));
+}
+/**
+* Recovers the signing public key from the signed payload and signature.
+*
+* @example
+* ```ts twoslash
+* import { Secp256k1 } from 'ox'
+*
+* const signature = Secp256k1.sign({ payload: '0xdeadbeef', privateKey: '0x...' })
+*
+* const publicKey = Secp256k1.recoverPublicKey({ // [!code focus]
+*   payload: '0xdeadbeef', // [!code focus]
+*   signature, // [!code focus]
+* }) // [!code focus]
+* ```
+*
+* @param options - The recovery options.
+* @returns The recovered public key.
+*/
+function recoverPublicKey(options) {
+	const { payload, signature } = options;
+	const { r, s, yParity } = signature;
+	return from$4(new secp256k1.Signature(BigInt(r), BigInt(s)).addRecoveryBit(yParity).recoverPublicKey(from$6(payload).substring(2)));
+}
+/**
+* Verifies a payload was signed by the provided address.
+*
+* @example
+* ### Verify with Ethereum Address
+*
+* ```ts twoslash
+* import { Secp256k1 } from 'ox'
+*
+* const signature = Secp256k1.sign({ payload: '0xdeadbeef', privateKey: '0x...' })
+*
+* const verified = Secp256k1.verify({ // [!code focus]
+*   address: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266', // [!code focus]
+*   payload: '0xdeadbeef', // [!code focus]
+*   signature, // [!code focus]
+* }) // [!code focus]
+* ```
+*
+* @example
+* ### Verify with Public Key
+*
+* ```ts twoslash
+* import { Secp256k1 } from 'ox'
+*
+* const privateKey = '0x...'
+* const publicKey = Secp256k1.getPublicKey({ privateKey })
+* const signature = Secp256k1.sign({ payload: '0xdeadbeef', privateKey })
+*
+* const verified = Secp256k1.verify({ // [!code focus]
+*   publicKey, // [!code focus]
+*   payload: '0xdeadbeef', // [!code focus]
+*   signature, // [!code focus]
+* }) // [!code focus]
+* ```
+*
+* @param options - The verification options.
+* @returns Whether the payload was signed by the provided address.
+*/
+function verify(options) {
+	const { address, hash, payload, publicKey, signature } = options;
+	if (address) return isEqual(address, recoverAddress({
+		payload,
+		signature
+	}));
+	return secp256k1.verify(signature, from$5(payload), toBytes(publicKey), ...hash ? [{
+		prehash: true,
+		lowS: true
+	}] : []);
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/actions/wallet/sendRawTransactionSync.js
+/**
+* Sends a **signed** transaction to the network synchronously,
+* and waits for the transaction to be included in a block.
+*
+* - Docs: https://viem.sh/docs/actions/wallet/sendRawTransactionSync
+* - JSON-RPC Method: [`eth_sendRawTransactionSync`](https://eips.ethereum.org/EIPS/eip-7966)
+*
+* @param client - Client to use
+* @param parameters - {@link SendRawTransactionParameters}
+* @returns The transaction receipt. {@link SendRawTransactionSyncReturnType}
+*
+* @example
+* import { createWalletClient, custom } from 'viem'
+* import { mainnet } from 'viem/chains'
+* import { sendRawTransactionSync } from 'viem/wallet'
+*
+* const client = createWalletClient({
+*   chain: mainnet,
+*   transport: custom(window.ethereum),
+* })
+*
+* const receipt = await sendRawTransactionSync(client, {
+*   serializedTransaction: '0x02f850018203118080825208808080c080a04012522854168b27e5dc3d5839bab5e6b39e1a0ffd343901ce1622e3d64b48f1a04e00902ae0502c4728cbf12156290df99c3ed7de85b1dbfe20b5c36931733a33'
+* })
+*/
+async function sendRawTransactionSync(client, { serializedTransaction, throwOnReceiptRevert, timeout }) {
+	const receipt = await client.request({
+		method: "eth_sendRawTransactionSync",
+		params: timeout ? [serializedTransaction, timeout] : [serializedTransaction]
+	}, { retryCount: 0 });
+	const formatted = (client.chain?.formatters?.transactionReceipt?.format || formatTransactionReceipt)(receipt);
+	if (formatted.status === "reverted" && throwOnReceiptRevert) throw new TransactionReceiptRevertedError({ receipt: formatted });
+	return formatted;
+}
+//#endregion
+export { recoverAuthorizationAddress as $, validate$1 as A, fillTransaction as B, fromPublicKey as C, toHex$2 as D, toBytes as E, readContract as F, estimateMaxPriorityFeePerGas as G, getTransactionError as H, formatLog as I, defineBlock as J, getGasPrice as K, estimateGas as L, formatTransactionReceipt as M, receiptStatuses as N, keccak256 as O, sendRawTransaction as P, BlockNotFoundError as Q, defaultParameters as R, checksum as S, validate as T, getTransactionCount as U, getChainId as V, estimateFeesPerGas as W, defineTransaction as X, formatBlock as Y, formatTransaction as Z, decode as _, assert as a, create as b, fromHex as c, toHex as d, recoverAddress$1 as et, toRpc as f, toHex$1 as g, fromHex$1 as h, verify as i, defineTransactionReceipt as j, sha256 as k, fromRpc as l, yParityToV as m, recoverAddress as n, getAction as nt, extract as o, toTuple as p, getBlock as q, recoverPublicKey as r, parseAbiParameters as rt, from as s, sendRawTransactionSync as t, getContractError as tt, fromTuple as u, encode as v, isEqual as w, assert$1 as x, from$2 as y, prepareTransactionRequest as z };