x402-proxy 0.10.12 → 0.11.0

package/dist/{sendRawTransactionSync-DvSkhZtW.js → http-J0KYM-2Y.js}

@@ -1,10 +1,10 @@
 #!/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";
+import { $ as BaseError, $t as parseAbiParameter, At as UnknownRpcError, B as from$6, Bt as ContractFunctionExecutionError, C as from$7, Ct as ProviderDisconnectedError, D as fromString$1, Dt as TransactionRejectedRpcError, E as fromNumber, Et as SwitchChainError, F as toNumber$1, Ft as WalletConnectSessionSettlementError, G as slice$1, H as fromString, Ht as ContractFunctionZeroDataError, It as HttpRequestError, J as toNumber, Jt as encodeFunctionData, K as toBigInt, Kt as decodeAbiParameters, L as trimLeft$1, Lt as RpcRequestError, M as slice, Mt as UnsupportedNonOptionalCapabilityError, Nt as UnsupportedProviderMethodError, O as padLeft, Ot as UnauthorizedProviderError, Pt as UserRejectedRequestError, Q as stringify, Qt as parseStructs, R as validate$4, Rt as TimeoutError, S as concat, St as ParseRpcError, T as fromBytes$2, Tt as ResourceUnavailableRpcError, Ut as RawContractError, V as fromHex$3, Vt as ContractFunctionRevertedError, W as size$2, X as trimLeft, Y as toString, Yt as getAbiItem, Z as validate$5, Zt as toEventSelector, _t as InvalidRequestRpcError, a as getChainContractAddress, an as modifiers, at as formatTransactionRequest, b as InvalidLengthError, bt as MethodNotFoundRpcError, c as erc6492SignatureValidatorByteCode, ct as getNodeError, dt as BundleTooLargeError, et as decodeFunctionResult, f as erc1271Abi, ft as ChainDisconnectedError, gt as InvalidParamsRpcError, ht as InvalidInputRpcError, in as isStructSignature, j as size$1, jt as UnsupportedChainIdError, k as padRight, kt as UnknownBundleIdError, l as multicall3Bytecode, lt as AtomicReadyWalletRejectedUpgradeError, m as multicall3Abi, mt as InternalRpcError, n as createBatchScheduler, nn as InvalidAbiParametersError, nt as assertRequest, o as encodeDeployData, ot as defineFormatter, p as erc6492SignatureValidatorAbi, pt as DuplicateIdError, q as toBoolean, rt as serializeStateOverride, sn as formatAbiParameters, st as extract$1, t as call, tn as splitParameters, tt as isAddressEqual, ut as AtomicityNotSupportedError, vt as JsonRpcVersionUnsupportedError, w as fromBoolean, wt as ResourceNotFoundRpcError, xt as MethodNotSupportedRpcError, y as IntegerOutOfRangeError, yt as LimitExceededRpcError, zt as CallExecutionError } from "./call-DdUUzMfg.js";
+import { t as keccak_256 } from "./sha3-VSia5eGE.js";
+import { t as sha256$1 } from "./sha256-DCLdwsRU.js";
+import { t as secp256k1 } from "./secp256k1-BwSAYyif.js";
+import { $ as toBytes$1, A as formatGwei, E as TransactionReceiptNotFoundError, F as parseAccount, Ft as formatAbiItem, I as encodeAbiParameters, J as LruMap$1, M as stringify$1, Mt as BaseError$1, Nt as size$3, Ot as DecodeLogDataMismatch, P as PositionOutOfBoundsError$1, Pt as isHex, St as AbiEventSignatureNotFoundError, W as concatHex, X as keccak256$1, at as hexToBigInt, bt as AbiEventNotFoundError, et as bytesToHex, gt as AbiDecodingZeroDataError, ht as AbiDecodingDataSizeTooSmallError, j as formatEther, k as prettyPrint, kt as DecodeLogTopicsMismatch, nt as stringToHex, ot as hexToBool, q as getAddress, rt as toHex$3, st as hexToNumber, tt as numberToHex, v as UnknownNodeError, w as TransactionExecutionError, xt as AbiEventSignatureEmptyTopicsError } from "./chain-C_3Km9Dx.js";
+import { C as blobsToProofs, D as publicKeyToAddress, S as commitmentsToVersionedHashes, T as hashAuthorization, b as getTransactionType, c as serializeSignature, w as blobsToCommitments, x as toBlobSidecars } from "./accounts-D9KsVVpJ.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
@@ -63,6 +63,116 @@ function getAction(client, actionFn, name) {
 	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/errors/log.js
+var FilterTypeNotSupportedError = class extends BaseError$1 {
+	constructor(type) {
+		super(`Filter type "${type}" is not supported.`, { name: "FilterTypeNotSupportedError" });
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/abi/encodeEventTopics.js
+const docsPath$1 = "/docs/contract/encodeEventTopics";
+function encodeEventTopics(parameters) {
+	const { abi, eventName, args } = parameters;
+	let abiItem = abi[0];
+	if (eventName) {
+		const item = getAbiItem({
+			abi,
+			name: eventName
+		});
+		if (!item) throw new AbiEventNotFoundError(eventName, { docsPath: docsPath$1 });
+		abiItem = item;
+	}
+	if (abiItem.type !== "event") throw new AbiEventNotFoundError(void 0, { docsPath: docsPath$1 });
+	const signature = toEventSelector(formatAbiItem(abiItem));
+	let topics = [];
+	if (args && "inputs" in abiItem) {
+		const indexedInputs = abiItem.inputs?.filter((param) => "indexed" in param && param.indexed);
+		const args_ = Array.isArray(args) ? args : Object.values(args).length > 0 ? indexedInputs?.map((x) => args[x.name]) ?? [] : [];
+		if (args_.length > 0) topics = indexedInputs?.map((param, i) => {
+			if (Array.isArray(args_[i])) return args_[i].map((_, j) => encodeArg({
+				param,
+				value: args_[i][j]
+			}));
+			return typeof args_[i] !== "undefined" && args_[i] !== null ? encodeArg({
+				param,
+				value: args_[i]
+			}) : null;
+		}) ?? [];
+	}
+	return [signature, ...topics];
+}
+function encodeArg({ param, value }) {
+	if (param.type === "string" || param.type === "bytes") return keccak256$1(toBytes$1(value));
+	if (param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/)) throw new FilterTypeNotSupportedError(param.type);
+	return encodeAbiParameters([param], [value]);
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/filters/createFilterRequestScope.js
+/**
+* Scopes `request` to the filter ID. If the client is a fallback, it will
+* listen for responses and scope the child transport `request` function
+* to the successful filter ID.
+*/
+function createFilterRequestScope(client, { method }) {
+	const requestMap = {};
+	if (client.transport.type === "fallback") client.transport.onResponse?.(({ method: method_, response: id, status, transport }) => {
+		if (status === "success" && method === method_) requestMap[id] = transport.request;
+	});
+	return ((id) => requestMap[id] || client.request);
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/actions/public/createContractEventFilter.js
+/**
+* Creates a Filter to retrieve event logs that can be used with [`getFilterChanges`](https://viem.sh/docs/actions/public/getFilterChanges) or [`getFilterLogs`](https://viem.sh/docs/actions/public/getFilterLogs).
+*
+* - Docs: https://viem.sh/docs/contract/createContractEventFilter
+*
+* @param client - Client to use
+* @param parameters - {@link CreateContractEventFilterParameters}
+* @returns [`Filter`](https://viem.sh/docs/glossary/types#filter). {@link CreateContractEventFilterReturnType}
+*
+* @example
+* import { createPublicClient, http, parseAbi } from 'viem'
+* import { mainnet } from 'viem/chains'
+* import { createContractEventFilter } from 'viem/contract'
+*
+* const client = createPublicClient({
+*   chain: mainnet,
+*   transport: http(),
+* })
+* const filter = await createContractEventFilter(client, {
+*   abi: parseAbi(['event Transfer(address indexed, address indexed, uint256)']),
+* })
+*/
+async function createContractEventFilter(client, parameters) {
+	const { address, abi, args, eventName, fromBlock, strict, toBlock } = parameters;
+	const getRequest = createFilterRequestScope(client, { method: "eth_newFilter" });
+	const topics = eventName ? encodeEventTopics({
+		abi,
+		args,
+		eventName
+	}) : void 0;
+	const id = await client.request({
+		method: "eth_newFilter",
+		params: [{
+			address,
+			fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
+			toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock,
+			topics
+		}]
+	});
+	return {
+		abi,
+		args,
+		eventName,
+		id,
+		request: getRequest(id),
+		strict: Boolean(strict),
+		type: "event"
+	};
+}
+//#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 }) {
@@ -94,7 +204,7 @@ function getContractError(err, { abi, address, args, docsPath, functionName, sen
 //#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");
+	const { secp256k1 } = await import("./secp256k1-CHAXu2gP.js");
 	return `0x${(() => {
 		if (typeof signature === "object" && "r" in signature && "s" in signature) {
 			const { r, s, v, yParity } = signature;
@@ -102,7 +212,7 @@ async function recoverPublicKey$1({ hash, signature }) {
 			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");
+		if (size$3(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)}`;
@@ -984,6 +1094,295 @@ function formatLog(log, { args, eventName } = {}) {
 	};
 }
 //#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/abi/decodeEventLog.js
+const docsPath = "/docs/contract/decodeEventLog";
+function decodeEventLog(parameters) {
+	const { abi, data, strict: strict_, topics } = parameters;
+	const strict = strict_ ?? true;
+	const [signature, ...argTopics] = topics;
+	if (!signature) throw new AbiEventSignatureEmptyTopicsError({ docsPath });
+	const abiItem = abi.find((x) => x.type === "event" && signature === toEventSelector(formatAbiItem(x)));
+	if (!(abiItem && "name" in abiItem) || abiItem.type !== "event") throw new AbiEventSignatureNotFoundError(signature, { docsPath });
+	const { name, inputs } = abiItem;
+	const isUnnamed = inputs?.some((x) => !("name" in x && x.name));
+	const args = isUnnamed ? [] : {};
+	const indexedInputs = inputs.map((x, i) => [x, i]).filter(([x]) => "indexed" in x && x.indexed);
+	const missingIndexedInputs = [];
+	for (let i = 0; i < indexedInputs.length; i++) {
+		const [param, argIndex] = indexedInputs[i];
+		const topic = argTopics[i];
+		if (!topic) {
+			if (strict) throw new DecodeLogTopicsMismatch({
+				abiItem,
+				param
+			});
+			missingIndexedInputs.push([param, argIndex]);
+			continue;
+		}
+		args[isUnnamed ? argIndex : param.name || argIndex] = decodeTopic({
+			param,
+			value: topic
+		});
+	}
+	const nonIndexedInputs = inputs.filter((x) => !("indexed" in x && x.indexed));
+	const inputsToDecode = strict ? nonIndexedInputs : [...missingIndexedInputs.map(([param]) => param), ...nonIndexedInputs];
+	if (inputsToDecode.length > 0) {
+		if (data && data !== "0x") try {
+			const decodedData = decodeAbiParameters(inputsToDecode, data);
+			if (decodedData) {
+				let dataIndex = 0;
+				if (!strict) for (const [param, argIndex] of missingIndexedInputs) args[isUnnamed ? argIndex : param.name || argIndex] = decodedData[dataIndex++];
+				if (isUnnamed) {
+					for (let i = 0; i < inputs.length; i++) if (args[i] === void 0 && dataIndex < decodedData.length) args[i] = decodedData[dataIndex++];
+				} else for (let i = 0; i < nonIndexedInputs.length; i++) args[nonIndexedInputs[i].name] = decodedData[dataIndex++];
+			}
+		} catch (err) {
+			if (strict) {
+				if (err instanceof AbiDecodingDataSizeTooSmallError || err instanceof PositionOutOfBoundsError$1) throw new DecodeLogDataMismatch({
+					abiItem,
+					data,
+					params: inputsToDecode,
+					size: size$3(data)
+				});
+				throw err;
+			}
+		}
+		else if (strict) throw new DecodeLogDataMismatch({
+			abiItem,
+			data: "0x",
+			params: inputsToDecode,
+			size: 0
+		});
+	}
+	return {
+		eventName: name,
+		args: Object.values(args).length > 0 ? args : void 0
+	};
+}
+function decodeTopic({ param, value }) {
+	if (param.type === "string" || param.type === "bytes" || param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/)) return value;
+	return (decodeAbiParameters([param], value) || [])[0];
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/abi/parseEventLogs.js
+/**
+* Extracts & decodes logs matching the provided signature(s) (`abi` + optional `eventName`)
+* from a set of opaque logs.
+*
+* @param parameters - {@link ParseEventLogsParameters}
+* @returns The logs. {@link ParseEventLogsReturnType}
+*
+* @example
+* import { createClient, http } from 'viem'
+* import { mainnet } from 'viem/chains'
+* import { parseEventLogs } from 'viem/op-stack'
+*
+* const client = createClient({
+*   chain: mainnet,
+*   transport: http(),
+* })
+*
+* const receipt = await getTransactionReceipt(client, {
+*   hash: '0xec23b2ba4bc59ba61554507c1b1bc91649e6586eb2dd00c728e8ed0db8bb37ea',
+* })
+*
+* const logs = parseEventLogs({ logs: receipt.logs })
+* // [{ args: { ... }, eventName: 'TransactionDeposited', ... }, ...]
+*/
+function parseEventLogs(parameters) {
+	const { abi, args, logs, strict = true } = parameters;
+	const eventName = (() => {
+		if (!parameters.eventName) return void 0;
+		if (Array.isArray(parameters.eventName)) return parameters.eventName;
+		return [parameters.eventName];
+	})();
+	const abiTopics = abi.filter((abiItem) => abiItem.type === "event").map((abiItem) => ({
+		abi: abiItem,
+		selector: toEventSelector(abiItem)
+	}));
+	return logs.map((log) => {
+		const formattedLog = typeof log.blockNumber === "string" ? formatLog(log) : log;
+		const abiItems = abiTopics.filter((abiTopic) => formattedLog.topics[0] === abiTopic.selector);
+		if (abiItems.length === 0) return null;
+		let event;
+		let abiItem;
+		for (const item of abiItems) try {
+			event = decodeEventLog({
+				...formattedLog,
+				abi: [item.abi],
+				strict: true
+			});
+			abiItem = item;
+			break;
+		} catch {}
+		if (!event && !strict) {
+			abiItem = abiItems[0];
+			try {
+				event = decodeEventLog({
+					data: formattedLog.data,
+					topics: formattedLog.topics,
+					abi: [abiItem.abi],
+					strict: false
+				});
+			} catch {
+				const isUnnamed = abiItem.abi.inputs?.some((x) => !("name" in x && x.name));
+				return {
+					...formattedLog,
+					args: isUnnamed ? [] : {},
+					eventName: abiItem.abi.name
+				};
+			}
+		}
+		if (!event || !abiItem) return null;
+		if (eventName && !eventName.includes(event.eventName)) return null;
+		if (!includesArgs({
+			args: event.args,
+			inputs: abiItem.abi.inputs,
+			matchArgs: args
+		})) return null;
+		return {
+			...event,
+			...formattedLog
+		};
+	}).filter(Boolean);
+}
+function includesArgs(parameters) {
+	const { args, inputs, matchArgs } = parameters;
+	if (!matchArgs) return true;
+	if (!args) return false;
+	function isEqual(input, value, arg) {
+		try {
+			if (input.type === "address") return isAddressEqual(value, arg);
+			if (input.type === "string" || input.type === "bytes") return keccak256$1(toBytes$1(value)) === arg;
+			return value === arg;
+		} catch {
+			return false;
+		}
+	}
+	if (Array.isArray(args) && Array.isArray(matchArgs)) return matchArgs.every((value, index) => {
+		if (value === null || value === void 0) return true;
+		const input = inputs[index];
+		if (!input) return false;
+		return (Array.isArray(value) ? value : [value]).some((value) => isEqual(input, value, args[index]));
+	});
+	if (typeof args === "object" && !Array.isArray(args) && typeof matchArgs === "object" && !Array.isArray(matchArgs)) return Object.entries(matchArgs).every(([key, value]) => {
+		if (value === null || value === void 0) return true;
+		const input = inputs.find((input) => input.name === key);
+		if (!input) return false;
+		return (Array.isArray(value) ? value : [value]).some((value) => isEqual(input, value, args[key]));
+	});
+	return false;
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/actions/public/getLogs.js
+/**
+* Returns a list of event logs matching the provided parameters.
+*
+* - Docs: https://viem.sh/docs/actions/public/getLogs
+* - Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/logs_event-logs
+* - JSON-RPC Methods: [`eth_getLogs`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getlogs)
+*
+* @param client - Client to use
+* @param parameters - {@link GetLogsParameters}
+* @returns A list of event logs. {@link GetLogsReturnType}
+*
+* @example
+* import { createPublicClient, http, parseAbiItem } from 'viem'
+* import { mainnet } from 'viem/chains'
+* import { getLogs } from 'viem/public'
+*
+* const client = createPublicClient({
+*   chain: mainnet,
+*   transport: http(),
+* })
+* const logs = await getLogs(client)
+*/
+async function getLogs(client, { address, blockHash, fromBlock, toBlock, event, events: events_, args, strict: strict_ } = {}) {
+	const strict = strict_ ?? false;
+	const events = events_ ?? (event ? [event] : void 0);
+	let topics = [];
+	if (events) {
+		topics = [events.flatMap((event) => encodeEventTopics({
+			abi: [event],
+			eventName: event.name,
+			args: events_ ? void 0 : args
+		}))];
+		if (event) topics = topics[0];
+	}
+	let logs;
+	if (blockHash) logs = await client.request({
+		method: "eth_getLogs",
+		params: [{
+			address,
+			topics,
+			blockHash
+		}]
+	});
+	else logs = await client.request({
+		method: "eth_getLogs",
+		params: [{
+			address,
+			topics,
+			fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
+			toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock
+		}]
+	});
+	const formattedLogs = logs.map((log) => formatLog(log));
+	if (!events) return formattedLogs;
+	return parseEventLogs({
+		abi: events,
+		args,
+		logs: formattedLogs,
+		strict
+	});
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/actions/public/getContractEvents.js
+/**
+* Returns a list of event logs emitted by a contract.
+*
+* - Docs: https://viem.sh/docs/contract/getContractEvents#getcontractevents
+* - JSON-RPC Methods: [`eth_getLogs`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getlogs)
+*
+* @param client - Client to use
+* @param parameters - {@link GetContractEventsParameters}
+* @returns A list of event logs. {@link GetContractEventsReturnType}
+*
+* @example
+* import { createClient, http } from 'viem'
+* import { mainnet } from 'viem/chains'
+* import { getContractEvents } from 'viem/public'
+* import { wagmiAbi } from './abi'
+*
+* const client = createClient({
+*   chain: mainnet,
+*   transport: http(),
+* })
+* const logs = await getContractEvents(client, {
+*  address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
+*  abi: wagmiAbi,
+*  eventName: 'Transfer'
+* })
+*/
+async function getContractEvents(client, parameters) {
+	const { abi, address, args, blockHash, eventName, fromBlock, toBlock, strict } = parameters;
+	const event = eventName ? getAbiItem({
+		abi,
+		name: eventName
+	}) : void 0;
+	const events = !event ? abi.filter((x) => x.type === "event") : void 0;
+	return getAction(client, getLogs, "getLogs")({
+		address,
+		args,
+		blockHash,
+		event,
+		events,
+		fromBlock,
+		toBlock,
+		strict
+	});
+}
+//#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.
@@ -1046,119 +1445,995 @@ async function readContract(client, parameters) {
 	}
 }
 //#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
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/observe.js
+/** @internal */
+const listenersCache = /* @__PURE__ */ new Map();
+/** @internal */
+const cleanupCache = /* @__PURE__ */ new Map();
+let callbackCount = 0;
 /**
-* 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'
-* })
+* @description Sets up an observer for a given function. If another function
+* is set up under the same observer id, the function will only be called once
+* for both instances of the observer.
 */
-async function sendRawTransaction(client, { serializedTransaction }) {
-	return client.request({
-		method: "eth_sendRawTransaction",
-		params: [serializedTransaction]
-	}, { retryCount: 0 });
+function observe(observerId, callbacks, fn) {
+	const callbackId = ++callbackCount;
+	const getListeners = () => listenersCache.get(observerId) || [];
+	const unsubscribe = () => {
+		const listeners = getListeners();
+		listenersCache.set(observerId, listeners.filter((cb) => cb.id !== callbackId));
+	};
+	const unwatch = () => {
+		const listeners = getListeners();
+		if (!listeners.some((cb) => cb.id === callbackId)) return;
+		const cleanup = cleanupCache.get(observerId);
+		if (listeners.length === 1 && cleanup) {
+			const p = cleanup();
+			if (p instanceof Promise) p.catch(() => {});
+		}
+		unsubscribe();
+	};
+	const listeners = getListeners();
+	listenersCache.set(observerId, [...listeners, {
+		id: callbackId,
+		fns: callbacks
+	}]);
+	if (listeners && listeners.length > 0) return unwatch;
+	const emit = {};
+	for (const key in callbacks) emit[key] = ((...args) => {
+		const listeners = getListeners();
+		if (listeners.length === 0) return;
+		for (const listener of listeners) listener.fns[key]?.(...args);
+	});
+	const cleanup = fn(emit);
+	if (typeof cleanup === "function") cleanupCache.set(observerId, cleanup);
+	return unwatch;
 }
 //#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
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/wait.js
+async function wait(time) {
+	return new Promise((res) => setTimeout(res, time));
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/poll.js
+/**
+* @description Polls a function at a specified interval.
+*/
+function poll(fn, { emitOnBegin, initialWaitTime, interval }) {
+	let active = true;
+	const unwatch = () => active = false;
+	const watch = async () => {
+		let data;
+		if (emitOnBegin) data = await fn({ unpoll: unwatch });
+		await wait(await initialWaitTime?.(data) ?? interval);
+		const poll = async () => {
+			if (!active) return;
+			await fn({ unpoll: unwatch });
+			await wait(interval);
+			poll();
+		};
+		poll();
 	};
-	if (transactionReceipt.blobGasPrice) receipt.blobGasPrice = BigInt(transactionReceipt.blobGasPrice);
-	if (transactionReceipt.blobGasUsed) receipt.blobGasUsed = BigInt(transactionReceipt.blobGasUsed);
-	return receipt;
+	watch();
+	return unwatch;
 }
-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
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/promise/withCache.js
+/** @internal */
+const promiseCache$1 = /* @__PURE__ */ new Map();
+/** @internal */
+const responseCache = /* @__PURE__ */ new Map();
+function getCache(cacheKey) {
+	const buildCache = (cacheKey, cache) => ({
+		clear: () => cache.delete(cacheKey),
+		get: () => cache.get(cacheKey),
+		set: (data) => cache.set(cacheKey, data)
+	});
+	const promise = buildCache(cacheKey, promiseCache$1);
+	const response = buildCache(cacheKey, responseCache);
+	return {
+		clear: () => {
+			promise.clear();
+			response.clear();
+		},
+		promise,
+		response
+	};
+}
 /**
-* @internal
-*
-* Map with a LRU (Least recently used) policy.
-* @see https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU
+* @description Returns the result of a given promise, and caches the result for
+* subsequent invocations against a provided cache key.
 */
-var LruMap = class extends Map {
-	constructor(size) {
-		super();
-		Object.defineProperty(this, "maxSize", {
-			enumerable: true,
-			configurable: true,
-			writable: true,
-			value: void 0
-		});
-		this.maxSize = size;
+async function withCache(fn, { cacheKey, cacheTime = Number.POSITIVE_INFINITY }) {
+	const cache = getCache(cacheKey);
+	const response = cache.response.get();
+	if (response && cacheTime > 0) {
+		if (Date.now() - response.created.getTime() < cacheTime) return response.data;
 	}
-	get(key) {
-		const value = super.get(key);
-		if (super.has(key) && value !== void 0) {
-			this.delete(key);
-			super.set(key, value);
-		}
-		return value;
+	let promise = cache.promise.get();
+	if (!promise) {
+		promise = fn();
+		cache.promise.set(promise);
 	}
-	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;
+	try {
+		const data = await promise;
+		cache.response.set({
+			created: /* @__PURE__ */ new Date(),
+			data
+		});
+		return data;
+	} finally {
+		cache.promise.clear();
 	}
-};
-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
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/actions/public/getBlockNumber.js
+const cacheKey = (id) => `blockNumber.${id}`;
 /**
-* Calculates the [Keccak256](https://en.wikipedia.org/wiki/SHA-3) hash of a {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} value.
+* Returns the number of the most recent block seen.
 *
-* This function is a re-export of `keccak_256` from [`@noble/hashes`](https://github.com/paulmillr/noble-hashes), an audited & minimal JS hashing library.
+* - Docs: https://viem.sh/docs/actions/public/getBlockNumber
+* - Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/blocks_fetching-blocks
+* - JSON-RPC Methods: [`eth_blockNumber`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_blocknumber)
+*
+* @param client - Client to use
+* @param parameters - {@link GetBlockNumberParameters}
+* @returns The number of the block. {@link GetBlockNumberReturnType}
 *
 * @example
-* ```ts twoslash
-* import { Hash } from 'ox'
+* import { createPublicClient, http } from 'viem'
+* import { mainnet } from 'viem/chains'
+* import { getBlockNumber } from 'viem/public'
 *
-* Hash.keccak256('0xdeadbeef')
-* // @log: '0xd4fd4e189132273036449fc9e11198c739161b4c0116a9a2dccdfa1c492006f1'
-* ```
+* const client = createPublicClient({
+*   chain: mainnet,
+*   transport: http(),
+* })
+* const blockNumber = await getBlockNumber(client)
+* // 69420n
+*/
+async function getBlockNumber(client, { cacheTime = client.cacheTime } = {}) {
+	const blockNumberHex = await withCache(() => client.request({ method: "eth_blockNumber" }), {
+		cacheKey: cacheKey(client.uid),
+		cacheTime
+	});
+	return BigInt(blockNumberHex);
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/actions/public/getFilterChanges.js
+/**
+* Returns a list of logs or hashes based on a [Filter](/docs/glossary/terms#filter) since the last time it was called.
 *
-* @example
-* ### Calculate Hash of a String
+* - Docs: https://viem.sh/docs/actions/public/getFilterChanges
+* - JSON-RPC Methods: [`eth_getFilterChanges`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getfilterchanges)
 *
-* ```ts twoslash
-* import { Hash, Hex } from 'ox'
+* A Filter can be created from the following actions:
+*
+* - [`createBlockFilter`](https://viem.sh/docs/actions/public/createBlockFilter)
+* - [`createContractEventFilter`](https://viem.sh/docs/contract/createContractEventFilter)
+* - [`createEventFilter`](https://viem.sh/docs/actions/public/createEventFilter)
+* - [`createPendingTransactionFilter`](https://viem.sh/docs/actions/public/createPendingTransactionFilter)
+*
+* Depending on the type of filter, the return value will be different:
+*
+* - If the filter was created with `createContractEventFilter` or `createEventFilter`, it returns a list of logs.
+* - If the filter was created with `createPendingTransactionFilter`, it returns a list of transaction hashes.
+* - If the filter was created with `createBlockFilter`, it returns a list of block hashes.
+*
+* @param client - Client to use
+* @param parameters - {@link GetFilterChangesParameters}
+* @returns Logs or hashes. {@link GetFilterChangesReturnType}
+*
+* @example
+* // Blocks
+* import { createPublicClient, http } from 'viem'
+* import { mainnet } from 'viem/chains'
+* import { createBlockFilter, getFilterChanges } from 'viem/public'
+*
+* const client = createPublicClient({
+*   chain: mainnet,
+*   transport: http(),
+* })
+* const filter = await createBlockFilter(client)
+* const hashes = await getFilterChanges(client, { filter })
+*
+* @example
+* // Contract Events
+* import { createPublicClient, http, parseAbi } from 'viem'
+* import { mainnet } from 'viem/chains'
+* import { createContractEventFilter, getFilterChanges } from 'viem/public'
+*
+* const client = createPublicClient({
+*   chain: mainnet,
+*   transport: http(),
+* })
+* const filter = await createContractEventFilter(client, {
+*   address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+*   abi: parseAbi(['event Transfer(address indexed, address indexed, uint256)']),
+*   eventName: 'Transfer',
+* })
+* const logs = await getFilterChanges(client, { filter })
+*
+* @example
+* // Raw Events
+* import { createPublicClient, http, parseAbiItem } from 'viem'
+* import { mainnet } from 'viem/chains'
+* import { createEventFilter, getFilterChanges } from 'viem/public'
+*
+* const client = createPublicClient({
+*   chain: mainnet,
+*   transport: http(),
+* })
+* const filter = await createEventFilter(client, {
+*   address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+*   event: parseAbiItem('event Transfer(address indexed, address indexed, uint256)'),
+* })
+* const logs = await getFilterChanges(client, { filter })
+*
+* @example
+* // Transactions
+* import { createPublicClient, http } from 'viem'
+* import { mainnet } from 'viem/chains'
+* import { createPendingTransactionFilter, getFilterChanges } from 'viem/public'
+*
+* const client = createPublicClient({
+*   chain: mainnet,
+*   transport: http(),
+* })
+* const filter = await createPendingTransactionFilter(client)
+* const hashes = await getFilterChanges(client, { filter })
+*/
+async function getFilterChanges(_client, { filter }) {
+	const strict = "strict" in filter && filter.strict;
+	const logs = await filter.request({
+		method: "eth_getFilterChanges",
+		params: [filter.id]
+	});
+	if (typeof logs[0] === "string") return logs;
+	const formattedLogs = logs.map((log) => formatLog(log));
+	if (!("abi" in filter) || !filter.abi) return formattedLogs;
+	return parseEventLogs({
+		abi: filter.abi,
+		logs: formattedLogs,
+		strict
+	});
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/actions/public/uninstallFilter.js
+/**
+* Destroys a [`Filter`](https://viem.sh/docs/glossary/types#filter).
+*
+* - Docs: https://viem.sh/docs/actions/public/uninstallFilter
+* - JSON-RPC Methods: [`eth_uninstallFilter`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_uninstallFilter)
+*
+* Destroys a Filter that was created from one of the following Actions:
+* - [`createBlockFilter`](https://viem.sh/docs/actions/public/createBlockFilter)
+* - [`createEventFilter`](https://viem.sh/docs/actions/public/createEventFilter)
+* - [`createPendingTransactionFilter`](https://viem.sh/docs/actions/public/createPendingTransactionFilter)
+*
+* @param client - Client to use
+* @param parameters - {@link UninstallFilterParameters}
+* @returns A boolean indicating if the Filter was successfully uninstalled. {@link UninstallFilterReturnType}
+*
+* @example
+* import { createPublicClient, http } from 'viem'
+* import { mainnet } from 'viem/chains'
+* import { createPendingTransactionFilter, uninstallFilter } from 'viem/public'
+*
+* const filter = await createPendingTransactionFilter(client)
+* const uninstalled = await uninstallFilter(client, { filter })
+* // true
+*/
+async function uninstallFilter(_client, { filter }) {
+	return filter.request({
+		method: "eth_uninstallFilter",
+		params: [filter.id]
+	});
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/actions/public/watchContractEvent.js
+/**
+* Watches and returns emitted contract event logs.
+*
+* - Docs: https://viem.sh/docs/contract/watchContractEvent
+*
+* This Action will batch up all the event logs found within the [`pollingInterval`](https://viem.sh/docs/contract/watchContractEvent#pollinginterval-optional), and invoke them via [`onLogs`](https://viem.sh/docs/contract/watchContractEvent#onLogs).
+*
+* `watchContractEvent` will attempt to create an [Event Filter](https://viem.sh/docs/contract/createContractEventFilter) and listen to changes to the Filter per polling interval, however, if the RPC Provider does not support Filters (e.g. `eth_newFilter`), then `watchContractEvent` will fall back to using [`getLogs`](https://viem.sh/docs/actions/public/getLogs) instead.
+*
+* @param client - Client to use
+* @param parameters - {@link WatchContractEventParameters}
+* @returns A function that can be invoked to stop watching for new event logs. {@link WatchContractEventReturnType}
+*
+* @example
+* import { createPublicClient, http, parseAbi } from 'viem'
+* import { mainnet } from 'viem/chains'
+* import { watchContractEvent } from 'viem/contract'
+*
+* const client = createPublicClient({
+*   chain: mainnet,
+*   transport: http(),
+* })
+* const unwatch = watchContractEvent(client, {
+*   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
+*   abi: parseAbi(['event Transfer(address indexed from, address indexed to, uint256 value)']),
+*   eventName: 'Transfer',
+*   args: { from: '0xc961145a54C96E3aE9bAA048c4F4D6b04C13916b' },
+*   onLogs: (logs) => console.log(logs),
+* })
+*/
+function watchContractEvent(client, parameters) {
+	const { abi, address, args, batch = true, eventName, fromBlock, onError, onLogs, poll: poll_, pollingInterval = client.pollingInterval, strict: strict_ } = parameters;
+	const enablePolling = (() => {
+		if (typeof poll_ !== "undefined") return poll_;
+		if (typeof fromBlock === "bigint") return true;
+		if (client.transport.type === "webSocket" || client.transport.type === "ipc") return false;
+		if (client.transport.type === "fallback" && (client.transport.transports[0].config.type === "webSocket" || client.transport.transports[0].config.type === "ipc")) return false;
+		return true;
+	})();
+	const pollContractEvent = () => {
+		const strict = strict_ ?? false;
+		return observe(stringify$1([
+			"watchContractEvent",
+			address,
+			args,
+			batch,
+			client.uid,
+			eventName,
+			pollingInterval,
+			strict,
+			fromBlock
+		]), {
+			onLogs,
+			onError
+		}, (emit) => {
+			let previousBlockNumber;
+			if (fromBlock !== void 0) previousBlockNumber = fromBlock - 1n;
+			let filter;
+			let initialized = false;
+			const unwatch = poll(async () => {
+				if (!initialized) {
+					try {
+						filter = await getAction(client, createContractEventFilter, "createContractEventFilter")({
+							abi,
+							address,
+							args,
+							eventName,
+							strict,
+							fromBlock
+						});
+					} catch {}
+					initialized = true;
+					return;
+				}
+				try {
+					let logs;
+					if (filter) logs = await getAction(client, getFilterChanges, "getFilterChanges")({ filter });
+					else {
+						const blockNumber = await getAction(client, getBlockNumber, "getBlockNumber")({});
+						if (previousBlockNumber && previousBlockNumber < blockNumber) logs = await getAction(client, getContractEvents, "getContractEvents")({
+							abi,
+							address,
+							args,
+							eventName,
+							fromBlock: previousBlockNumber + 1n,
+							toBlock: blockNumber,
+							strict
+						});
+						else logs = [];
+						previousBlockNumber = blockNumber;
+					}
+					if (logs.length === 0) return;
+					if (batch) emit.onLogs(logs);
+					else for (const log of logs) emit.onLogs([log]);
+				} catch (err) {
+					if (filter && err instanceof InvalidInputRpcError) initialized = false;
+					emit.onError?.(err);
+				}
+			}, {
+				emitOnBegin: true,
+				interval: pollingInterval
+			});
+			return async () => {
+				if (filter) await getAction(client, uninstallFilter, "uninstallFilter")({ filter });
+				unwatch();
+			};
+		});
+	};
+	const subscribeContractEvent = () => {
+		const strict = strict_ ?? false;
+		const observerId = stringify$1([
+			"watchContractEvent",
+			address,
+			args,
+			batch,
+			client.uid,
+			eventName,
+			pollingInterval,
+			strict
+		]);
+		let active = true;
+		let unsubscribe = () => active = false;
+		return observe(observerId, {
+			onLogs,
+			onError
+		}, (emit) => {
+			(async () => {
+				try {
+					const transport = (() => {
+						if (client.transport.type === "fallback") {
+							const transport = client.transport.transports.find((transport) => transport.config.type === "webSocket" || transport.config.type === "ipc");
+							if (!transport) return client.transport;
+							return transport.value;
+						}
+						return client.transport;
+					})();
+					const topics = eventName ? encodeEventTopics({
+						abi,
+						eventName,
+						args
+					}) : [];
+					const { unsubscribe: unsubscribe_ } = await transport.subscribe({
+						params: ["logs", {
+							address,
+							topics
+						}],
+						onData(data) {
+							if (!active) return;
+							const log = data.result;
+							try {
+								const { eventName, args } = decodeEventLog({
+									abi,
+									data: log.data,
+									topics: log.topics,
+									strict: strict_
+								});
+								const formatted = formatLog(log, {
+									args,
+									eventName
+								});
+								emit.onLogs([formatted]);
+							} catch (err) {
+								let eventName;
+								let isUnnamed;
+								if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
+									if (strict_) return;
+									eventName = err.abiItem.name;
+									isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
+								}
+								const formatted = formatLog(log, {
+									args: isUnnamed ? [] : {},
+									eventName
+								});
+								emit.onLogs([formatted]);
+							}
+						},
+						onError(error) {
+							emit.onError?.(error);
+						}
+					});
+					unsubscribe = unsubscribe_;
+					if (!active) unsubscribe();
+				} catch (err) {
+					onError?.(err);
+				}
+			})();
+			return () => unsubscribe();
+		});
+	};
+	return enablePolling ? pollContractEvent() : subscribeContractEvent();
+}
+//#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/promise/withRetry.js
+function withRetry(fn, { delay: delay_ = 100, retryCount = 2, shouldRetry = () => true } = {}) {
+	return new Promise((resolve, reject) => {
+		const attemptRetry = async ({ count = 0 } = {}) => {
+			const retry = async ({ error }) => {
+				const delay = typeof delay_ === "function" ? delay_({
+					count,
+					error
+				}) : delay_;
+				if (delay) await wait(delay);
+				attemptRetry({ count: count + 1 });
+			};
+			try {
+				resolve(await fn());
+			} catch (err) {
+				if (count < retryCount && await shouldRetry({
+					count,
+					error: err
+				})) return retry({ error: err });
+				reject(err);
+			}
+		};
+		attemptRetry();
+	});
+}
+//#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/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/uid.js
+const size = 256;
+let index = size;
+let buffer;
+function uid(length = 11) {
+	if (!buffer || index + length > size * 2) {
+		buffer = "";
+		index = 0;
+		for (let i = 0; i < size; i++) buffer += (256 + Math.random() * 256 | 0).toString(16).substring(1);
+	}
+	return buffer.substring(index, index++ + length);
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/clients/createClient.js
+function createClient(parameters) {
+	const { batch, chain, ccipRead, dataSuffix, key = "base", name = "Base Client", type = "base" } = parameters;
+	const experimental_blockTag = parameters.experimental_blockTag ?? (typeof chain?.experimental_preconfirmationTime === "number" ? "pending" : void 0);
+	const blockTime = chain?.blockTime ?? 12e3;
+	const defaultPollingInterval = Math.min(Math.max(Math.floor(blockTime / 2), 500), 4e3);
+	const pollingInterval = parameters.pollingInterval ?? defaultPollingInterval;
+	const cacheTime = parameters.cacheTime ?? pollingInterval;
+	const account = parameters.account ? parseAccount(parameters.account) : void 0;
+	const { config, request, value } = parameters.transport({
+		account,
+		chain,
+		pollingInterval
+	});
+	const client = {
+		account,
+		batch,
+		cacheTime,
+		ccipRead,
+		chain,
+		dataSuffix,
+		key,
+		name,
+		pollingInterval,
+		request,
+		transport: {
+			...config,
+			...value
+		},
+		type,
+		uid: uid(),
+		...experimental_blockTag ? { experimental_blockTag } : {}
+	};
+	function extend(base) {
+		return (extendFn) => {
+			const extended = extendFn(base);
+			for (const key in client) delete extended[key];
+			const combined = {
+				...base,
+				...extended
+			};
+			return Object.assign(combined, { extend: extend(combined) });
+		};
+	}
+	return Object.assign(client, { extend: extend(client) });
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/actions/public/getCode.js
+/**
+* Retrieves the bytecode at an address.
+*
+* - Docs: https://viem.sh/docs/contract/getCode
+* - JSON-RPC Methods: [`eth_getCode`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getcode)
+*
+* @param client - Client to use
+* @param parameters - {@link GetCodeParameters}
+* @returns The contract's bytecode. {@link GetCodeReturnType}
+*
+* @example
+* import { createPublicClient, http } from 'viem'
+* import { mainnet } from 'viem/chains'
+* import { getCode } from 'viem/contract'
+*
+* const client = createPublicClient({
+*   chain: mainnet,
+*   transport: http(),
+* })
+* const code = await getCode(client, {
+*   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
+* })
+*/
+async function getCode(client, { address, blockNumber, blockTag = "latest" }) {
+	const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
+	const hex = await client.request({
+		method: "eth_getCode",
+		params: [address, blockNumberHex || blockTag]
+	}, { dedupe: Boolean(blockNumberHex) });
+	if (hex === "0x") return void 0;
+	return hex;
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/authorization/verifyAuthorization.js
+/**
+* Verify that an Authorization object was signed by the provided address.
+*
+* - Docs {@link https://viem.sh/docs/utilities/verifyAuthorization}
+*
+* @param parameters - {@link VerifyAuthorizationParameters}
+* @returns Whether or not the signature is valid. {@link VerifyAuthorizationReturnType}
+*/
+async function verifyAuthorization({ address, authorization, signature }) {
+	return isAddressEqual(getAddress(address), await recoverAuthorizationAddress({
+		authorization,
+		signature
+	}));
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/promise/withDedupe.js
+/** @internal */
+const promiseCache = /* @__PURE__ */ new LruMap$1(8192);
+/** Deduplicates in-flight promises. */
+function withDedupe(fn, { enabled = true, id }) {
+	if (!enabled || !id) return fn();
+	if (promiseCache.get(id)) return promiseCache.get(id);
+	const promise = fn().finally(() => promiseCache.delete(id));
+	promiseCache.set(id, promise);
+	return promise;
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/buildRequest.js
+function buildRequest(request, options = {}) {
+	return async (args, overrideOptions = {}) => {
+		const { dedupe = false, methods, retryDelay = 150, retryCount = 3, uid } = {
+			...options,
+			...overrideOptions
+		};
+		const { method } = args;
+		if (methods?.exclude?.includes(method)) throw new MethodNotSupportedRpcError(/* @__PURE__ */ new Error("method not supported"), { method });
+		if (methods?.include && !methods.include.includes(method)) throw new MethodNotSupportedRpcError(/* @__PURE__ */ new Error("method not supported"), { method });
+		return withDedupe(() => withRetry(async () => {
+			try {
+				return await request(args);
+			} catch (err_) {
+				const err = err_;
+				switch (err.code) {
+					case ParseRpcError.code: throw new ParseRpcError(err);
+					case InvalidRequestRpcError.code: throw new InvalidRequestRpcError(err);
+					case MethodNotFoundRpcError.code: throw new MethodNotFoundRpcError(err, { method: args.method });
+					case InvalidParamsRpcError.code: throw new InvalidParamsRpcError(err);
+					case InternalRpcError.code: throw new InternalRpcError(err);
+					case InvalidInputRpcError.code: throw new InvalidInputRpcError(err);
+					case ResourceNotFoundRpcError.code: throw new ResourceNotFoundRpcError(err);
+					case ResourceUnavailableRpcError.code: throw new ResourceUnavailableRpcError(err);
+					case TransactionRejectedRpcError.code: throw new TransactionRejectedRpcError(err);
+					case MethodNotSupportedRpcError.code: throw new MethodNotSupportedRpcError(err, { method: args.method });
+					case LimitExceededRpcError.code: throw new LimitExceededRpcError(err);
+					case JsonRpcVersionUnsupportedError.code: throw new JsonRpcVersionUnsupportedError(err);
+					case UserRejectedRequestError.code: throw new UserRejectedRequestError(err);
+					case UnauthorizedProviderError.code: throw new UnauthorizedProviderError(err);
+					case UnsupportedProviderMethodError.code: throw new UnsupportedProviderMethodError(err);
+					case ProviderDisconnectedError.code: throw new ProviderDisconnectedError(err);
+					case ChainDisconnectedError.code: throw new ChainDisconnectedError(err);
+					case SwitchChainError.code: throw new SwitchChainError(err);
+					case UnsupportedNonOptionalCapabilityError.code: throw new UnsupportedNonOptionalCapabilityError(err);
+					case UnsupportedChainIdError.code: throw new UnsupportedChainIdError(err);
+					case DuplicateIdError.code: throw new DuplicateIdError(err);
+					case UnknownBundleIdError.code: throw new UnknownBundleIdError(err);
+					case BundleTooLargeError.code: throw new BundleTooLargeError(err);
+					case AtomicReadyWalletRejectedUpgradeError.code: throw new AtomicReadyWalletRejectedUpgradeError(err);
+					case AtomicityNotSupportedError.code: throw new AtomicityNotSupportedError(err);
+					case 5e3: throw new UserRejectedRequestError(err);
+					case WalletConnectSessionSettlementError.code: throw new WalletConnectSessionSettlementError(err);
+					default:
+						if (err_ instanceof BaseError$1) throw err_;
+						throw new UnknownRpcError(err);
+				}
+			}
+		}, {
+			delay: ({ count, error }) => {
+				if (error && error instanceof HttpRequestError) {
+					const retryAfter = error?.headers?.get("Retry-After");
+					if (retryAfter?.match(/\d/)) return Number.parseInt(retryAfter, 10) * 1e3;
+				}
+				return ~~(1 << count) * retryDelay;
+			},
+			retryCount,
+			shouldRetry: ({ error }) => shouldRetry(error)
+		}), {
+			enabled: dedupe,
+			id: dedupe ? stringToHex(`${uid}.${stringify$1(args)}`) : void 0
+		});
+	};
+}
+/** @internal */
+function shouldRetry(error) {
+	if ("code" in error && typeof error.code === "number") {
+		if (error.code === -1) return true;
+		if (error.code === LimitExceededRpcError.code) return true;
+		if (error.code === InternalRpcError.code) return true;
+		return false;
+	}
+	if (error instanceof HttpRequestError && error.status) {
+		if (error.status === 403) return true;
+		if (error.status === 408) return true;
+		if (error.status === 413) return true;
+		if (error.status === 429) return true;
+		if (error.status === 500) return true;
+		if (error.status === 502) return true;
+		if (error.status === 503) return true;
+		if (error.status === 504) return true;
+		return false;
+	}
+	return true;
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/chain/defineChain.js
+function defineChain(chain) {
+	const chainInstance = {
+		formatters: void 0,
+		fees: void 0,
+		serializers: void 0,
+		...chain
+	};
+	function extend(base) {
+		return (fnOrExtended) => {
+			const properties = typeof fnOrExtended === "function" ? fnOrExtended(base) : fnOrExtended;
+			const combined = {
+				...base,
+				...properties
+			};
+			return Object.assign(combined, { extend: extend(combined) });
+		};
+	}
+	return Object.assign(chainInstance, { extend: extend(chainInstance) });
+}
+function extendSchema() {
+	return {};
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/promise/withTimeout.js
+function withTimeout(fn, { errorInstance = /* @__PURE__ */ new Error("timed out"), timeout, signal }) {
+	return new Promise((resolve, reject) => {
+		(async () => {
+			let timeoutId;
+			try {
+				const controller = new AbortController();
+				if (timeout > 0) timeoutId = setTimeout(() => {
+					if (signal) controller.abort();
+					else reject(errorInstance);
+				}, timeout);
+				resolve(await fn({ signal: controller?.signal || null }));
+			} catch (err) {
+				if (err?.name === "AbortError") reject(errorInstance);
+				reject(err);
+			} finally {
+				clearTimeout(timeoutId);
+			}
+		})();
+	});
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/rpc/id.js
+function createIdStore() {
+	return {
+		current: 0,
+		take() {
+			return this.current++;
+		},
+		reset() {
+			this.current = 0;
+		}
+	};
+}
+const idCache = /* @__PURE__ */ createIdStore();
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/utils/rpc/http.js
+function getHttpRpcClient(url_, options = {}) {
+	const { url, headers: headers_url } = parseUrl(url_);
+	return { async request(params) {
+		const { body, fetchFn = options.fetchFn ?? fetch, onRequest = options.onRequest, onResponse = options.onResponse, timeout = options.timeout ?? 1e4 } = params;
+		const fetchOptions = {
+			...options.fetchOptions ?? {},
+			...params.fetchOptions ?? {}
+		};
+		const { headers, method, signal: signal_ } = fetchOptions;
+		try {
+			const response = await withTimeout(async ({ signal }) => {
+				const init = {
+					...fetchOptions,
+					body: Array.isArray(body) ? stringify$1(body.map((body) => ({
+						jsonrpc: "2.0",
+						id: body.id ?? idCache.take(),
+						...body
+					}))) : stringify$1({
+						jsonrpc: "2.0",
+						id: body.id ?? idCache.take(),
+						...body
+					}),
+					headers: {
+						...headers_url,
+						"Content-Type": "application/json",
+						...headers
+					},
+					method: method || "POST",
+					signal: signal_ || (timeout > 0 ? signal : null)
+				};
+				const request = new Request(url, init);
+				const args = await onRequest?.(request, init) ?? {
+					...init,
+					url
+				};
+				return await fetchFn(args.url ?? url, args);
+			}, {
+				errorInstance: new TimeoutError({
+					body,
+					url
+				}),
+				timeout,
+				signal: true
+			});
+			if (onResponse) await onResponse(response);
+			let data;
+			if (response.headers.get("Content-Type")?.startsWith("application/json")) data = await response.json();
+			else {
+				data = await response.text();
+				try {
+					data = JSON.parse(data || "{}");
+				} catch (err) {
+					if (response.ok) throw err;
+					data = { error: data };
+				}
+			}
+			if (!response.ok) {
+				if (typeof data.error?.code === "number" && typeof data.error?.message === "string") return data;
+				throw new HttpRequestError({
+					body,
+					details: stringify$1(data.error) || response.statusText,
+					headers: response.headers,
+					status: response.status,
+					url
+				});
+			}
+			return data;
+		} catch (err) {
+			if (err instanceof HttpRequestError) throw err;
+			if (err instanceof TimeoutError) throw err;
+			throw new HttpRequestError({
+				body,
+				cause: err,
+				url
+			});
+		}
+	} };
+}
+/** @internal */
+function parseUrl(url_) {
+	try {
+		const url = new URL(url_);
+		const result = (() => {
+			if (url.username) {
+				const credentials = `${decodeURIComponent(url.username)}:${decodeURIComponent(url.password)}`;
+				url.username = "";
+				url.password = "";
+				return {
+					url: url.toString(),
+					headers: { Authorization: `Basic ${btoa(credentials)}` }
+				};
+			}
+		})();
+		return {
+			url: url.toString(),
+			...result
+		};
+	} catch {
+		return { url: url_ };
+	}
+}
+//#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'
@@ -1180,7 +2455,7 @@ const checksum$1 = { checksum: /* @__PURE__ */ new LruMap(8192) }.checksum;
 */
 function keccak256(value, options = {}) {
 	const { as = typeof value === "string" ? "Hex" : "Bytes" } = options;
-	const bytes = keccak_256(from$5(value));
+	const bytes = keccak_256(from$6(value));
 	if (as === "Bytes") return bytes;
 	return fromBytes$2(bytes);
 }
@@ -1203,7 +2478,7 @@ function keccak256(value, options = {}) {
 */
 function sha256(value, options = {}) {
 	const { as = typeof value === "string" ? "Hex" : "Bytes" } = options;
-	const bytes = sha256$1(from$5(value));
+	const bytes = sha256$1(from$6(value));
 	if (as === "Bytes") return bytes;
 	return fromBytes$2(bytes);
 }
@@ -1224,8 +2499,8 @@ function sha256(value, options = {}) {
 * @param value - Value to check.
 * @returns Whether the value is a valid hash.
 */
-function validate$1(value) {
-	return validate$2(value) && size(value) === 32;
+function validate$3(value) {
+	return validate$4(value) && size$1(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
@@ -1248,7 +2523,7 @@ function validate$1(value) {
 *
 * @param publicKey - The public key object to assert.
 */
-function assert$2(publicKey, options = {}) {
+function assert$4(publicKey, options = {}) {
 	const { compressed } = options;
 	const { prefix, x, y } = publicKey;
 	if (compressed === false || typeof x === "bigint" && typeof y === "bigint") {
@@ -1303,10 +2578,10 @@ function assert$2(publicKey, options = {}) {
 * @param value - The public key value to instantiate.
 * @returns The instantiated {@link ox#PublicKey.PublicKey}.
 */
-function from$4(value) {
+function from$5(value) {
 	const publicKey = (() => {
-		if (validate$2(value)) return fromHex$2(value);
-		if (validate$3(value)) return fromBytes$1(value);
+		if (validate$4(value)) return fromHex$2(value);
+		if (validate$5(value)) return fromBytes$1(value);
 		const { prefix, x, y } = value;
 		if (typeof x === "bigint" && typeof y === "bigint") return {
 			prefix: prefix ?? 4,
@@ -1318,7 +2593,7 @@ function from$4(value) {
 			x
 		};
 	})();
-	assert$2(publicKey);
+	assert$4(publicKey);
 	return publicKey;
 }
 /**
@@ -1435,7 +2710,7 @@ function toBytes(publicKey, options = {}) {
 * @returns The serialized public key.
 */
 function toHex$2(publicKey, options = {}) {
-	assert$2(publicKey);
+	assert$4(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");
@@ -1508,7 +2783,7 @@ var InvalidUncompressedPrefixError = class extends BaseError {
 /** 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.`] });
+		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$1(from$7(publicKey))} bytes.`] });
 		Object.defineProperty(this, "name", {
 			enumerable: true,
 			configurable: true,
@@ -1541,7 +2816,7 @@ const addressRegex = /^0x[a-fA-F0-9]{40}$/;
 * @param value - Value to assert if it is a valid address.
 * @param options - Assertion options.
 */
-function assert$1(value, options = {}) {
+function assert$3(value, options = {}) {
 	const { strict = true } = options;
 	if (!addressRegex.test(value)) throw new InvalidAddressError({
 		address: value,
@@ -1571,7 +2846,7 @@ function assert$1(value, options = {}) {
 */
 function checksum(address) {
 	if (checksum$1.has(address)) return checksum$1.get(address);
-	assert$1(address, { strict: false });
+	assert$3(address, { strict: false });
 	const hexAddress = address.substring(2).toLowerCase();
 	const hash = keccak256(fromString(hexAddress), { as: "Bytes" });
 	const characters = hexAddress.split("");
@@ -1616,9 +2891,9 @@ function checksum(address) {
 * @param options - Conversion options.
 * @returns The typed Address.
 */
-function from$3(address, options = {}) {
+function from$4(address, options = {}) {
 	const { checksum: checksumVal = false } = options;
-	assert$1(address);
+	assert$3(address);
 	if (checksumVal) return checksum(address);
 	return address;
 }
@@ -1641,7 +2916,7 @@ function from$3(address, 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);
+	return from$4(`0x${keccak256(`0x${toHex$2(publicKey).slice(4)}`).substring(26)}`, options);
 }
 /**
 * Checks if two {@link ox#Address.Address} are equal.
@@ -1673,8 +2948,8 @@ function fromPublicKey(publicKey, options = {}) {
 * @returns Whether the addresses are equal.
 */
 function isEqual(addressA, addressB) {
-	assert$1(addressA, { strict: false });
-	assert$1(addressB, { strict: false });
+	assert$3(addressA, { strict: false });
+	assert$3(addressB, { strict: false });
 	return addressA.toLowerCase() === addressB.toLowerCase();
 }
 /**
@@ -1700,10 +2975,10 @@ function isEqual(addressA, addressB) {
 * @param options - Check options.
 * @returns Whether the address is a valid address.
 */
-function validate(address, options = {}) {
+function validate$2(address, options = {}) {
 	const { strict = true } = options ?? {};
 	try {
-		assert$1(address, { strict });
+		assert$3(address, { strict });
 		return true;
 	} catch {
 		return false;
@@ -2033,7 +3308,7 @@ function encode$1(preparedParameters) {
 	for (let i = 0; i < preparedParameters.length; i++) {
 		const { dynamic, encoded } = preparedParameters[i];
 		if (dynamic) staticSize += 32;
-		else staticSize += size(encoded);
+		else staticSize += size$1(encoded);
 	}
 	const staticParameters = [];
 	const dynamicParameters = [];
@@ -2043,7 +3318,7 @@ function encode$1(preparedParameters) {
 		if (dynamic) {
 			staticParameters.push(fromNumber(staticSize + dynamicSize, { size: 32 }));
 			dynamicParameters.push(encoded);
-			dynamicSize += size(encoded);
+			dynamicSize += size$1(encoded);
 		} else staticParameters.push(encoded);
 	}
 	return concat(...staticParameters, ...dynamicParameters);
@@ -2051,7 +3326,7 @@ function encode$1(preparedParameters) {
 /** @internal */
 function encodeAddress(value, options) {
 	const { checksum = false } = options;
-	assert$1(value, { strict: checksum });
+	assert$3(value, { strict: checksum });
 	return {
 		dynamic: false,
 		encoded: padLeft(value.toLowerCase())
@@ -2100,7 +3375,7 @@ function encodeArray(value, options) {
 /** @internal */
 function encodeBytes(value, { type }) {
 	const [, parametersize] = type.split("bytes");
-	const bytesSize = size(value);
+	const bytesSize = size$1(value);
 	if (!parametersize) {
 		let value_ = value;
 		if (bytesSize % 32 !== 0) value_ = padRight(value_, Math.ceil((value.length - 2) / 2 / 32) * 32);
@@ -2150,12 +3425,12 @@ function encodeNumber(value, { signed, size }) {
 /** @internal */
 function encodeString(value) {
 	const hexValue = fromString$1(value);
-	const partsLength = Math.ceil(size(hexValue) / 32);
+	const partsLength = Math.ceil(size$1(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)
+		encoded: concat(padRight(fromNumber(size$1(hexValue), { size: 32 })), ...parts)
 	};
 }
 /** @internal */
@@ -2403,11 +3678,11 @@ 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({
+	if (size$2(bytes) === 0 && parameters.length > 0) throw new ZeroDataError();
+	if (size$2(bytes) && size$2(bytes) < 32) throw new DataSizeTooSmallError({
 		data: typeof data === "string" ? data : fromBytes$2(data),
 		parameters,
-		size: size$1(bytes)
+		size: size$2(bytes)
 	});
 	let consumed = 0;
 	const values = as === "Array" ? [] : {};
@@ -2508,7 +3783,7 @@ function encodePacked(types, values) {
 	function encode(type, value, isArray = false) {
 		if (type === "address") {
 			const address = value;
-			assert$1(address);
+			assert$3(address);
 			return padLeft(address.toLowerCase(), isArray ? 32 : 0);
 		}
 		if (type === "string") return fromString$1(value);
@@ -2628,7 +3903,7 @@ function encodePacked(types, values) {
 * @param parameters - The ABI Parameters to parse.
 * @returns The typed ABI Parameters.
 */
-function from$2(parameters) {
+function from$3(parameters) {
 	if (Array.isArray(parameters) && typeof parameters[0] === "string") return parseAbiParameters(parameters);
 	if (typeof parameters === "string") return parseAbiParameters(parameters);
 	return parameters;
@@ -2770,7 +4045,7 @@ var ArrayLengthMismatchError = class extends BaseError {
 */
 var BytesSizeMismatchError = class extends BaseError {
 	constructor({ expectedSize, value }) {
-		super(`Size of bytes "${value}" (bytes${size(value)}) does not match expected size (bytes${expectedSize}).`);
+		super(`Size of bytes "${value}" (bytes${size$1(value)}) does not match expected size (bytes${expectedSize}).`);
 		Object.defineProperty(this, "name", {
 			enumerable: true,
 			configurable: true,
@@ -2944,7 +4219,7 @@ function readList(cursor, length, to) {
 * @param options - Options.
 * @returns The RLP value.
 */
-function from$1(value, options) {
+function from$2(value, options) {
 	const { as } = options;
 	const encodable = getEncodable(value);
 	const cursor = create(new Uint8Array(encodable.length));
@@ -2969,7 +4244,7 @@ function from$1(value, options) {
 */
 function fromHex$1(hex, options = {}) {
 	const { as = "Hex" } = options;
-	return from$1(hex, { as });
+	return from$2(hex, { as });
 }
 function getEncodable(bytes) {
 	if (Array.isArray(bytes)) return getEncodableList(bytes.map((x) => getEncodable(x)));
@@ -3049,7 +4324,7 @@ function getSizeOfLength(length) {
 *
 * @param signature - The signature object to assert.
 */
-function assert(signature, options = {}) {
+function assert$2(signature, options = {}) {
 	const { recovered } = options;
 	if (typeof signature.r === "undefined") throw new MissingPropertiesError({ signature });
 	if (typeof signature.s === "undefined") throw new MissingPropertiesError({ signature });
@@ -3142,7 +4417,7 @@ function fromHex(signature) {
 function extract(value) {
 	if (typeof value.r === "undefined") return void 0;
 	if (typeof value.s === "undefined") return void 0;
-	return from(value);
+	return from$1(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}.
@@ -3198,11 +4473,11 @@ function extract(value) {
 * @param signature - The signature value to instantiate.
 * @returns The instantiated {@link ox#Signature.Signature}.
 */
-function from(signature) {
+function from$1(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 (typeof signature.r === "string") return fromRpc$1(signature);
 		if (signature.v) return fromLegacy(signature);
 		return {
 			r: signature.r,
@@ -3210,7 +4485,7 @@ function from(signature) {
 			...typeof signature.yParity !== "undefined" ? { yParity: signature.yParity } : {}
 		};
 	})();
-	assert(signature_);
+	assert$2(signature_);
 	return signature_;
 }
 /**
@@ -3251,7 +4526,7 @@ function fromLegacy(signature) {
 * @param signature - The {@link ox#Signature.Rpc} to convert.
 * @returns The converted {@link ox#Signature.Signature}.
 */
-function fromRpc(signature) {
+function fromRpc$1(signature) {
 	const yParity = (() => {
 		const v = signature.v ? Number(signature.v) : void 0;
 		let yParity = signature.yParity ? Number(signature.yParity) : void 0;
@@ -3285,7 +4560,7 @@ function fromRpc(signature) {
 */
 function fromTuple(tuple) {
 	const [yParity, r, s] = tuple;
-	return from({
+	return from$1({
 		r: r === "0x" ? 0n : BigInt(r),
 		s: s === "0x" ? 0n : BigInt(s),
 		yParity: yParity === "0x" ? 0 : Number(yParity)
@@ -3310,7 +4585,7 @@ function fromTuple(tuple) {
 * @returns The serialized signature.
 */
 function toHex(signature) {
-	assert(signature);
+	assert$2(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");
@@ -3332,7 +4607,7 @@ function toHex(signature) {
 * @param signature - The {@link ox#Signature.Signature} to convert.
 * @returns The converted {@link ox#Signature.Rpc}.
 */
-function toRpc(signature) {
+function toRpc$1(signature) {
 	const { r, s, yParity } = signature;
 	return {
 		r: fromNumber(r, { size: 32 }),
@@ -3408,7 +4683,7 @@ function yParityToV(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.`] });
+		super(`Value \`${signature}\` is an invalid signature size.`, { metaMessages: ["Expected: 64 bytes or 65 bytes.", `Received ${size$1(from$7(signature))} bytes.`] });
 		Object.defineProperty(this, "name", {
 			enumerable: true,
 			configurable: true,
@@ -3478,6 +4753,163 @@ var InvalidVError = class extends BaseError {
 	}
 };
 //#endregion
+//#region node_modules/.pnpm/ox@0.14.7_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/core/Authorization.js
+/**
+* Converts an [EIP-7702](https://eips.ethereum.org/EIPS/eip-7702) Authorization object into a typed {@link ox#Authorization.Authorization}.
+*
+* @example
+* An Authorization can be instantiated from an [EIP-7702](https://eips.ethereum.org/EIPS/eip-7702) Authorization tuple in object format.
+*
+* ```ts twoslash
+* import { Authorization } from 'ox'
+*
+* const authorization = Authorization.from({
+*   address: '0x1234567890abcdef1234567890abcdef12345678',
+*   chainId: 1,
+*   nonce: 69n,
+* })
+* ```
+*
+* @example
+* ### Attaching Signatures
+*
+* A {@link ox#Signature.Signature} can be attached with the `signature` option. The example below demonstrates signing
+* an Authorization with {@link ox#Secp256k1.(sign:function)}.
+*
+* ```ts twoslash
+* import { Authorization, Secp256k1 } from 'ox'
+*
+* const authorization = Authorization.from({
+*   address: '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',
+*   chainId: 1,
+*   nonce: 40n,
+* })
+*
+* const signature = Secp256k1.sign({
+*   payload: Authorization.getSignPayload(authorization),
+*   privateKey: '0x...',
+* })
+*
+* const authorization_signed = Authorization.from(authorization, { signature }) // [!code focus]
+* ```
+*
+* @param authorization - An [EIP-7702](https://eips.ethereum.org/EIPS/eip-7702) Authorization tuple in object format.
+* @param options - Authorization options.
+* @returns The {@link ox#Authorization.Authorization}.
+*/
+function from(authorization, options = {}) {
+	if (typeof authorization.chainId === "string") return fromRpc(authorization);
+	return {
+		...authorization,
+		...options.signature
+	};
+}
+/**
+* Converts an {@link ox#Authorization.Rpc} to an {@link ox#Authorization.Authorization}.
+*
+* @example
+* ```ts twoslash
+* import { Authorization } from 'ox'
+*
+* const authorization = Authorization.fromRpc({
+*   address: '0x0000000000000000000000000000000000000000',
+*   chainId: '0x1',
+*   nonce: '0x1',
+*   r: '0x635dc2033e60185bb36709c29c75d64ea51dfbd91c32ef4be198e4ceb169fb4d',
+*   s: '0x50c2667ac4c771072746acfdcf1f1483336dcca8bd2df47cd83175dbe60f0540',
+*   yParity: '0x0',
+* })
+* ```
+*
+* @param authorization - The RPC-formatted Authorization.
+* @returns A signed {@link ox#Authorization.Authorization}.
+*/
+function fromRpc(authorization) {
+	const { address, chainId, nonce } = authorization;
+	const signature = extract(authorization);
+	return {
+		address,
+		chainId: Number(chainId),
+		nonce: BigInt(nonce),
+		...signature
+	};
+}
+/**
+* Converts an {@link ox#Authorization.ListRpc} to an {@link ox#Authorization.List}.
+*
+* @example
+* ```ts twoslash
+* import { Authorization } from 'ox'
+*
+* const authorizationList = Authorization.fromRpcList([{
+*   address: '0x0000000000000000000000000000000000000000',
+*   chainId: '0x1',
+*   nonce: '0x1',
+*   r: '0x635dc2033e60185bb36709c29c75d64ea51dfbd91c32ef4be198e4ceb169fb4d',
+*   s: '0x50c2667ac4c771072746acfdcf1f1483336dcca8bd2df47cd83175dbe60f0540',
+*   yParity: '0x0',
+* }])
+* ```
+*
+* @param authorizationList - The RPC-formatted Authorization list.
+* @returns A signed {@link ox#Authorization.List}.
+*/
+function fromRpcList(authorizationList) {
+	return authorizationList.map(fromRpc);
+}
+/**
+* Converts an {@link ox#Authorization.Authorization} to an {@link ox#Authorization.Rpc}.
+*
+* @example
+* ```ts twoslash
+* import { Authorization } from 'ox'
+*
+* const authorization = Authorization.toRpc({
+*   address: '0x0000000000000000000000000000000000000000',
+*   chainId: 1,
+*   nonce: 1n,
+*   r: 44944627813007772897391531230081695102703289123332187696115181104739239197517n,
+*   s: 36528503505192438307355164441104001310566505351980369085208178712678799181120n,
+*   yParity: 0,
+* })
+* ```
+*
+* @param authorization - An Authorization.
+* @returns An RPC-formatted Authorization.
+*/
+function toRpc(authorization) {
+	const { address, chainId, nonce, ...signature } = authorization;
+	return {
+		address,
+		chainId: fromNumber(chainId),
+		nonce: fromNumber(nonce),
+		...toRpc$1(signature)
+	};
+}
+/**
+* Converts an {@link ox#Authorization.List} to an {@link ox#Authorization.ListRpc}.
+*
+* @example
+* ```ts twoslash
+* import { Authorization } from 'ox'
+*
+* const authorization = Authorization.toRpcList([{
+*   address: '0x0000000000000000000000000000000000000000',
+*   chainId: 1,
+*   nonce: 1n,
+*   r: 44944627813007772897391531230081695102703289123332187696115181104739239197517n,
+*   s: 36528503505192438307355164441104001310566505351980369085208178712678799181120n,
+*   yParity: 0,
+* }])
+* ```
+*
+* @param authorizationList - An Authorization List.
+* @returns An RPC-formatted Authorization List.
+*/
+function toRpcList(authorizationList) {
+	return authorizationList.map(toRpc);
+}
+//#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.
@@ -3521,7 +4953,7 @@ function recoverAddress(options) {
 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)));
+	return from$5(new secp256k1.Signature(BigInt(r), BigInt(s)).addRecoveryBit(yParity).recoverPublicKey(from$7(payload).substring(2)));
 }
 /**
 * Verifies a payload was signed by the provided address.
@@ -3567,46 +4999,631 @@ function verify(options) {
 		payload,
 		signature
 	}));
-	return secp256k1.verify(signature, from$5(payload), toBytes(publicKey), ...hash ? [{
+	return secp256k1.verify(signature, from$6(payload), toBytes(publicKey), ...hash ? [{
 		prehash: true,
 		lowS: true
 	}] : []);
 }
+/** Suffix ABI parameters for the ERC-8010 wrapped signature. */
+const suffixParameters = from$3("(uint256 chainId, address delegation, uint256 nonce, uint8 yParity, uint256 r, uint256 s), address to, bytes data");
+/**
+* Asserts that the wrapped signature is valid.
+*
+* @example
+* ```ts twoslash
+* import { SignatureErc8010 } from 'ox/erc8010'
+*
+* SignatureErc8010.assert('0xdeadbeef')
+* // @error: InvalidWrappedSignatureError: Value `0xdeadbeef` is an invalid ERC-8010 wrapped signature.
+* ```
+*
+* @param value - The value to assert.
+*/
+function assert$1(value) {
+	if (typeof value === "string") {
+		if (slice(value, -32) !== "0x8010801080108010801080108010801080108010801080108010801080108010") throw new InvalidWrappedSignatureError$1(value);
+	} else assert$2(value.authorization);
+}
+/**
+* Unwraps an [ERC-8010 wrapped signature](https://github.com/jxom/ERCs/blob/16f7e3891fff2e1e9c25dea0485497739db8a816/ERCS/erc-8010.md) into its constituent parts.
+*
+* @example
+* ```ts twoslash
+* import { SignatureErc8010 } from 'ox/erc8010'
+*
+* const { authorization, data, signature } = SignatureErc8010.unwrap('0x...')
+* ```
+*
+* @param wrapped - Wrapped signature to unwrap.
+* @returns Unwrapped signature.
+*/
+function unwrap(wrapped) {
+	assert$1(wrapped);
+	const suffixLength = toNumber$1(slice(wrapped, -64, -32));
+	const suffix = slice(wrapped, -suffixLength - 64, -64);
+	const signature = slice(wrapped, 0, -suffixLength - 64);
+	const [auth, to, data] = decode(suffixParameters, suffix);
+	return {
+		authorization: from({
+			address: auth.delegation,
+			chainId: Number(auth.chainId),
+			nonce: auth.nonce,
+			yParity: auth.yParity,
+			r: auth.r,
+			s: auth.s
+		}),
+		signature,
+		...data && data !== "0x" ? {
+			data,
+			to
+		} : {}
+	};
+}
+/**
+* Validates a wrapped signature. Returns `true` if the wrapped signature is valid, `false` otherwise.
+*
+* @example
+* ```ts twoslash
+* import { SignatureErc8010 } from 'ox/erc8010'
+*
+* const valid = SignatureErc8010.validate('0xdeadbeef')
+* // @log: false
+* ```
+*
+* @param value - The value to validate.
+* @returns `true` if the value is valid, `false` otherwise.
+*/
+function validate$1(value) {
+	try {
+		assert$1(value);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Thrown when the ERC-8010 wrapped signature is invalid. */
+var InvalidWrappedSignatureError$1 = class extends BaseError {
+	constructor(wrapped) {
+		super(`Value \`${wrapped}\` is an invalid ERC-8010 wrapped signature.`);
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "SignatureErc8010.InvalidWrappedSignatureError"
+		});
+	}
+};
 //#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
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/actions/public/getTransactionReceipt.js
 /**
-* Sends a **signed** transaction to the network synchronously,
-* and waits for the transaction to be included in a block.
+* Returns the [Transaction Receipt](https://viem.sh/docs/glossary/terms#transaction-receipt) given a [Transaction](https://viem.sh/docs/glossary/terms#transaction) hash.
 *
-* - Docs: https://viem.sh/docs/actions/wallet/sendRawTransactionSync
-* - JSON-RPC Method: [`eth_sendRawTransactionSync`](https://eips.ethereum.org/EIPS/eip-7966)
+* - Docs: https://viem.sh/docs/actions/public/getTransactionReceipt
+* - Example: https://stackblitz.com/github/wevm/viem/tree/main/examples/transactions_fetching-transactions
+* - JSON-RPC Methods: [`eth_getTransactionReceipt`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_gettransactionreceipt)
 *
 * @param client - Client to use
-* @param parameters - {@link SendRawTransactionParameters}
-* @returns The transaction receipt. {@link SendRawTransactionSyncReturnType}
+* @param parameters - {@link GetTransactionReceiptParameters}
+* @returns The transaction receipt. {@link GetTransactionReceiptReturnType}
 *
 * @example
-* import { createWalletClient, custom } from 'viem'
+* import { createPublicClient, http } from 'viem'
 * import { mainnet } from 'viem/chains'
-* import { sendRawTransactionSync } from 'viem/wallet'
+* import { getTransactionReceipt } from 'viem/public'
 *
-* const client = createWalletClient({
+* const client = createPublicClient({
 *   chain: mainnet,
-*   transport: custom(window.ethereum),
+*   transport: http(),
 * })
-*
-* const receipt = await sendRawTransactionSync(client, {
-*   serializedTransaction: '0x02f850018203118080825208808080c080a04012522854168b27e5dc3d5839bab5e6b39e1a0ffd343901ce1622e3d64b48f1a04e00902ae0502c4728cbf12156290df99c3ed7de85b1dbfe20b5c36931733a33'
+* const transactionReceipt = await getTransactionReceipt(client, {
+*   hash: '0x4ca7ee652d57678f26e887c149ab0735f41de37bcad58c9f6d3ed5824f15b74d',
 * })
 */
-async function sendRawTransactionSync(client, { serializedTransaction, throwOnReceiptRevert, timeout }) {
+async function getTransactionReceipt(client, { hash }) {
 	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;
+		method: "eth_getTransactionReceipt",
+		params: [hash]
+	}, { dedupe: true });
+	if (!receipt) throw new TransactionReceiptNotFoundError({ hash });
+	return (client.chain?.formatters?.transactionReceipt?.format || formatTransactionReceipt)(receipt, "getTransactionReceipt");
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/actions/public/multicall.js
+/**
+* Similar to [`readContract`](https://viem.sh/docs/contract/readContract), but batches up multiple functions on a contract in a single RPC call via the [`multicall3` contract](https://github.com/mds1/multicall).
+*
+* - Docs: https://viem.sh/docs/contract/multicall
+*
+* @param client - Client to use
+* @param parameters - {@link MulticallParameters}
+* @returns An array of results with accompanying status. {@link MulticallReturnType}
+*
+* @example
+* import { createPublicClient, http, parseAbi } from 'viem'
+* import { mainnet } from 'viem/chains'
+* import { multicall } from 'viem/contract'
+*
+* const client = createPublicClient({
+*   chain: mainnet,
+*   transport: http(),
+* })
+* const abi = parseAbi([
+*   'function balanceOf(address) view returns (uint256)',
+*   'function totalSupply() view returns (uint256)',
+* ])
+* const results = await multicall(client, {
+*   contracts: [
+*     {
+*       address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
+*       abi,
+*       functionName: 'balanceOf',
+*       args: ['0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'],
+*     },
+*     {
+*       address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
+*       abi,
+*       functionName: 'totalSupply',
+*     },
+*   ],
+* })
+* // [{ result: 424122n, status: 'success' }, { result: 1000000n, status: 'success' }]
+*/
+async function multicall(client, parameters) {
+	const { account, authorizationList, allowFailure = true, blockNumber, blockOverrides, blockTag, stateOverride } = parameters;
+	const contracts = parameters.contracts;
+	const { batchSize = parameters.batchSize ?? 1024, deployless = parameters.deployless ?? false } = typeof client.batch?.multicall === "object" ? client.batch.multicall : {};
+	const multicallAddress = (() => {
+		if (parameters.multicallAddress) return parameters.multicallAddress;
+		if (deployless) return null;
+		if (client.chain) return getChainContractAddress({
+			blockNumber,
+			chain: client.chain,
+			contract: "multicall3"
+		});
+		throw new Error("client chain not configured. multicallAddress is required.");
+	})();
+	const chunkedCalls = [[]];
+	let currentChunk = 0;
+	let currentChunkSize = 0;
+	for (let i = 0; i < contracts.length; i++) {
+		const { abi, address, args, functionName } = contracts[i];
+		try {
+			const callData = encodeFunctionData({
+				abi,
+				args,
+				functionName
+			});
+			currentChunkSize += (callData.length - 2) / 2;
+			if (batchSize > 0 && currentChunkSize > batchSize && chunkedCalls[currentChunk].length > 0) {
+				currentChunk++;
+				currentChunkSize = (callData.length - 2) / 2;
+				chunkedCalls[currentChunk] = [];
+			}
+			chunkedCalls[currentChunk] = [...chunkedCalls[currentChunk], {
+				allowFailure: true,
+				callData,
+				target: address
+			}];
+		} catch (err) {
+			const error = getContractError(err, {
+				abi,
+				address,
+				args,
+				docsPath: "/docs/contract/multicall",
+				functionName,
+				sender: account
+			});
+			if (!allowFailure) throw error;
+			chunkedCalls[currentChunk] = [...chunkedCalls[currentChunk], {
+				allowFailure: true,
+				callData: "0x",
+				target: address
+			}];
+		}
+	}
+	const aggregate3Results = await Promise.allSettled(chunkedCalls.map((calls) => getAction(client, readContract, "readContract")({
+		...multicallAddress === null ? { code: multicall3Bytecode } : { address: multicallAddress },
+		abi: multicall3Abi,
+		account,
+		args: [calls],
+		authorizationList,
+		blockNumber,
+		blockOverrides,
+		blockTag,
+		functionName: "aggregate3",
+		stateOverride
+	})));
+	const results = [];
+	for (let i = 0; i < aggregate3Results.length; i++) {
+		const result = aggregate3Results[i];
+		if (result.status === "rejected") {
+			if (!allowFailure) throw result.reason;
+			for (let j = 0; j < chunkedCalls[i].length; j++) results.push({
+				status: "failure",
+				error: result.reason,
+				result: void 0
+			});
+			continue;
+		}
+		const aggregate3Result = result.value;
+		for (let j = 0; j < aggregate3Result.length; j++) {
+			const { returnData, success } = aggregate3Result[j];
+			const { callData } = chunkedCalls[i][j];
+			const { abi, address, functionName, args } = contracts[results.length];
+			try {
+				if (callData === "0x") throw new AbiDecodingZeroDataError();
+				if (!success) throw new RawContractError({ data: returnData });
+				const result = decodeFunctionResult({
+					abi,
+					args,
+					data: returnData,
+					functionName
+				});
+				results.push(allowFailure ? {
+					result,
+					status: "success"
+				} : result);
+			} catch (err) {
+				const error = getContractError(err, {
+					abi,
+					address,
+					args,
+					docsPath: "/docs/contract/multicall",
+					functionName
+				});
+				if (!allowFailure) throw error;
+				results.push({
+					error,
+					result: void 0,
+					status: "failure"
+				});
+			}
+		}
+	}
+	if (results.length !== contracts.length) throw new BaseError$1("multicall results mismatch");
+	return results;
+}
+//#endregion
+//#region node_modules/.pnpm/ox@0.14.7_typescript@5.9.3_zod@4.3.6/node_modules/ox/_esm/erc6492/SignatureErc6492.js
+/**
+* Magic bytes used to identify ERC-6492 wrapped signatures.
+*/
+const magicBytes = "0x6492649264926492649264926492649264926492649264926492649264926492";
+/**
+* Asserts that the wrapped signature is valid.
+*
+* @example
+* ```ts twoslash
+* import { SignatureErc6492 } from 'ox/erc6492'
+*
+* SignatureErc6492.assert('0xdeadbeef')
+* // @error: InvalidWrappedSignatureError: Value `0xdeadbeef` is an invalid ERC-6492 wrapped signature.
+* ```
+*
+* @param wrapped - The wrapped signature to assert.
+*/
+function assert(wrapped) {
+	if (slice(wrapped, -32) !== "0x6492649264926492649264926492649264926492649264926492649264926492") throw new InvalidWrappedSignatureError(wrapped);
+}
+/**
+* Serializes an [ERC-6492 wrapped signature](https://eips.ethereum.org/EIPS/eip-6492#specification).
+*
+* @example
+* ```ts twoslash
+* import { Secp256k1, Signature } from 'ox'
+* import { SignatureErc6492 } from 'ox/erc6492' // [!code focus]
+*
+* const signature = Secp256k1.sign({
+*   payload: '0x...',
+*   privateKey: '0x...',
+* })
+*
+* const wrapped = SignatureErc6492.wrap({ // [!code focus]
+*   data: '0xdeadbeef', // [!code focus]
+*   signature: Signature.toHex(signature), // [!code focus]
+*   to: '0x00000000219ab540356cBB839Cbe05303d7705Fa', // [!code focus]
+* }) // [!code focus]
+* ```
+*
+* @param value - Wrapped signature to serialize.
+* @returns Serialized wrapped signature.
+*/
+function wrap(value) {
+	const { data, signature, to } = value;
+	return concat(encode(from$3("address, bytes, bytes"), [
+		to,
+		data,
+		signature
+	]), magicBytes);
+}
+/**
+* Validates a wrapped signature. Returns `true` if the wrapped signature is valid, `false` otherwise.
+*
+* @example
+* ```ts twoslash
+* import { SignatureErc6492 } from 'ox/erc6492'
+*
+* const valid = SignatureErc6492.validate('0xdeadbeef')
+* // @log: false
+* ```
+*
+* @param wrapped - The wrapped signature to validate.
+* @returns `true` if the wrapped signature is valid, `false` otherwise.
+*/
+function validate(wrapped) {
+	try {
+		assert(wrapped);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Thrown when the ERC-6492 wrapped signature is invalid. */
+var InvalidWrappedSignatureError = class extends BaseError {
+	constructor(wrapped) {
+		super(`Value \`${wrapped}\` is an invalid ERC-6492 wrapped signature.`);
+		Object.defineProperty(this, "name", {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: "SignatureErc6492.InvalidWrappedSignatureError"
+		});
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/actions/public/verifyHash.js
+/**
+* Verifies a message hash onchain using ERC-6492.
+*
+* @param client - Client to use.
+* @param parameters - {@link VerifyHashParameters}
+* @returns Whether or not the signature is valid. {@link VerifyHashReturnType}
+*/
+async function verifyHash(client, parameters) {
+	const { address, chain = client.chain, hash, erc6492VerifierAddress: verifierAddress = parameters.universalSignatureVerifierAddress ?? chain?.contracts?.erc6492Verifier?.address, multicallAddress = parameters.multicallAddress ?? chain?.contracts?.multicall3?.address, mode = "auto" } = parameters;
+	if (chain?.verifyHash) return await chain.verifyHash(client, parameters);
+	const signature = (() => {
+		const signature = parameters.signature;
+		if (isHex(signature)) return signature;
+		if (typeof signature === "object" && "r" in signature && "s" in signature) return serializeSignature(signature);
+		return bytesToHex(signature);
+	})();
+	try {
+		if (mode === "eoa") try {
+			if (isAddressEqual(getAddress(address), await recoverAddress$1({
+				hash,
+				signature
+			}))) return true;
+		} catch {}
+		if (validate$1(signature)) return await verifyErc8010(client, {
+			...parameters,
+			multicallAddress,
+			signature
+		});
+		return await verifyErc6492(client, {
+			...parameters,
+			verifierAddress,
+			signature
+		});
+	} catch (error) {
+		if (mode !== "eoa") try {
+			if (isAddressEqual(getAddress(address), await recoverAddress$1({
+				hash,
+				signature
+			}))) return true;
+		} catch {}
+		if (error instanceof VerificationError) return false;
+		throw error;
+	}
+}
+/** @internal */
+async function verifyErc8010(client, parameters) {
+	const { address, blockNumber, blockTag, hash, multicallAddress } = parameters;
+	const { authorization: authorization_ox, data: initData, signature, to } = unwrap(parameters.signature);
+	if (await getCode(client, {
+		address,
+		blockNumber,
+		blockTag
+	}) === concatHex(["0xef0100", authorization_ox.address])) return await verifyErc1271(client, {
+		address,
+		blockNumber,
+		blockTag,
+		hash,
+		signature
+	});
+	const authorization = {
+		address: authorization_ox.address,
+		chainId: Number(authorization_ox.chainId),
+		nonce: Number(authorization_ox.nonce),
+		r: numberToHex(authorization_ox.r, { size: 32 }),
+		s: numberToHex(authorization_ox.s, { size: 32 }),
+		yParity: authorization_ox.yParity
+	};
+	if (!await verifyAuthorization({
+		address,
+		authorization
+	})) throw new VerificationError();
+	const results = await getAction(client, readContract, "readContract")({
+		...multicallAddress ? { address: multicallAddress } : { code: multicall3Bytecode },
+		authorizationList: [authorization],
+		abi: multicall3Abi,
+		blockNumber,
+		blockTag: "pending",
+		functionName: "aggregate3",
+		args: [[...initData ? [{
+			allowFailure: true,
+			target: to ?? address,
+			callData: initData
+		}] : [], {
+			allowFailure: true,
+			target: address,
+			callData: encodeFunctionData({
+				abi: erc1271Abi,
+				functionName: "isValidSignature",
+				args: [hash, signature]
+			})
+		}]]
+	});
+	if ((results[results.length - 1]?.returnData)?.startsWith("0x1626ba7e")) return true;
+	throw new VerificationError();
+}
+/** @internal */
+async function verifyErc6492(client, parameters) {
+	const { address, factory, factoryData, hash, signature, verifierAddress, ...rest } = parameters;
+	const wrappedSignature = await (async () => {
+		if (!factory && !factoryData) return signature;
+		if (validate(signature)) return signature;
+		return wrap({
+			data: factoryData,
+			signature,
+			to: factory
+		});
+	})();
+	const args = verifierAddress ? {
+		to: verifierAddress,
+		data: encodeFunctionData({
+			abi: erc6492SignatureValidatorAbi,
+			functionName: "isValidSig",
+			args: [
+				address,
+				hash,
+				wrappedSignature
+			]
+		}),
+		...rest
+	} : {
+		data: encodeDeployData({
+			abi: erc6492SignatureValidatorAbi,
+			args: [
+				address,
+				hash,
+				wrappedSignature
+			],
+			bytecode: erc6492SignatureValidatorByteCode
+		}),
+		...rest
+	};
+	const { data } = await getAction(client, call, "call")(args).catch((error) => {
+		if (error instanceof CallExecutionError) throw new VerificationError();
+		throw error;
+	});
+	if (hexToBool(data ?? "0x0")) return true;
+	throw new VerificationError();
+}
+/** @internal */
+async function verifyErc1271(client, parameters) {
+	const { address, blockNumber, blockTag, hash, signature } = parameters;
+	if ((await getAction(client, readContract, "readContract")({
+		address,
+		abi: erc1271Abi,
+		args: [hash, signature],
+		blockNumber,
+		blockTag,
+		functionName: "isValidSignature"
+	}).catch((error) => {
+		if (error instanceof ContractFunctionExecutionError) throw new VerificationError();
+		throw error;
+	})).startsWith("0x1626ba7e")) return true;
+	throw new VerificationError();
+}
+var VerificationError = class extends Error {};
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/clients/transports/createTransport.js
+/**
+* @description Creates an transport intended to be used with a client.
+*/
+function createTransport({ key, methods, name, request, retryCount = 3, retryDelay = 150, timeout, type }, value) {
+	const uid$1 = uid();
+	return {
+		config: {
+			key,
+			methods,
+			name,
+			request,
+			retryCount,
+			retryDelay,
+			timeout,
+			type
+		},
+		request: buildRequest(request, {
+			methods,
+			retryCount,
+			retryDelay,
+			uid: uid$1
+		}),
+		value
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/errors/transport.js
+var UrlRequiredError = class extends BaseError$1 {
+	constructor() {
+		super("No URL was provided to the Transport. Please provide a valid RPC URL to the Transport.", {
+			docsPath: "/docs/clients/intro",
+			name: "UrlRequiredError"
+		});
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/viem@2.47.6_typescript@5.9.3_zod@4.3.6/node_modules/viem/_esm/clients/transports/http.js
+/**
+* @description Creates a HTTP transport that connects to a JSON-RPC API.
+*/
+function http(url, config = {}) {
+	const { batch, fetchFn, fetchOptions, key = "http", methods, name = "HTTP JSON-RPC", onFetchRequest, onFetchResponse, retryDelay, raw } = config;
+	return ({ chain, retryCount: retryCount_, timeout: timeout_ }) => {
+		const { batchSize = 1e3, wait = 0 } = typeof batch === "object" ? batch : {};
+		const retryCount = config.retryCount ?? retryCount_;
+		const timeout = timeout_ ?? config.timeout ?? 1e4;
+		const url_ = url || chain?.rpcUrls.default.http[0];
+		if (!url_) throw new UrlRequiredError();
+		const rpcClient = getHttpRpcClient(url_, {
+			fetchFn,
+			fetchOptions,
+			onRequest: onFetchRequest,
+			onResponse: onFetchResponse,
+			timeout
+		});
+		return createTransport({
+			key,
+			methods,
+			name,
+			async request({ method, params }) {
+				const body = {
+					method,
+					params
+				};
+				const { schedule } = createBatchScheduler({
+					id: url_,
+					wait,
+					shouldSplitBatch(requests) {
+						return requests.length > batchSize;
+					},
+					fn: (body) => rpcClient.request({ body }),
+					sort: (a, b) => a.id - b.id
+				});
+				const fn = async (body) => batch ? schedule(body) : [await rpcClient.request({ body })];
+				const [{ error, result }] = await fn(body);
+				if (raw) return {
+					error,
+					result
+				};
+				if (error) throw new RpcRequestError({
+					body,
+					error,
+					url: url_
+				});
+				return result;
+			},
+			retryCount,
+			retryDelay,
+			timeout,
+			type: "http"
+		}, {
+			fetchOptions,
+			url: url_
+		});
+	};
 }
 //#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 };
+export { parseEventLogs as $, toBytes as A, formatTransactionReceipt as B, encode as C, getAction as Ct, fromPublicKey as D, checksum as E, defineChain as F, uninstallFilter as G, withRetry as H, extendSchema as I, poll as J, getFilterChanges as K, getCode as L, keccak256 as M, sha256 as N, isEqual as O, validate$3 as P, getLogs as Q, createClient as R, toHex$1 as S, encodeEventTopics as St, assert$3 as T, sendRawTransaction as U, receiptStatuses as V, watchContractEvent as W, readContract as X, observe as Y, getContractEvents as Z, toHex as _, BlockNotFoundError as _t, getTransactionReceipt as a, fillTransaction as at, yParityToV as b, createContractEventFilter as bt, verify as c, getTransactionCount as ct, assert$2 as d, getGasPrice as dt, decodeEventLog as et, extract as f, getBlock as ft, fromTuple as g, formatTransaction as gt, fromRpc$1 as h, defineTransaction as ht, multicall as i, prepareTransactionRequest as it, toHex$2 as j, validate$2 as k, fromRpcList as l, estimateFeesPerGas as lt, fromHex as m, formatBlock as mt, createTransport as n, estimateGas as nt, recoverAddress as o, getChainId as ot, from$1 as p, defineBlock as pt, getBlockNumber as q, verifyHash as r, defaultParameters as rt, recoverPublicKey as s, getTransactionError as st, http as t, formatLog as tt, toRpcList as u, estimateMaxPriorityFeePerGas as ut, toRpc$1 as v, recoverAuthorizationAddress as vt, create as w, parseAbiParameters as wt, fromHex$1 as x, createFilterRequestScope as xt, toTuple as y, getContractError as yt, defineTransactionReceipt as z };