x402-proxy 0.10.7 → 0.10.9

package/dist/http-BAtucMbS.js

@@ -0,0 +1,2060 @@
+#!/usr/bin/env node
+import { At as UnknownRpcError, Bt as ContractFunctionExecutionError, C as concat, Ct as ProviderDisconnectedError, D as fromNumber, Dt as TransactionRejectedRpcError, Et as SwitchChainError, Ft as WalletConnectSessionSettlementError, I as toNumber, It as HttpRequestError, Jt as encodeFunctionData, Kt as decodeAbiParameters, Lt as RpcRequestError, Mt as UnsupportedNonOptionalCapabilityError, N as slice, Nt as UnsupportedProviderMethodError, Ot as UnauthorizedProviderError, Pt as UserRejectedRequestError, Rt as TimeoutError, St as ParseRpcError, Tt as ResourceUnavailableRpcError, Ut as RawContractError, Yt as getAbiItem, Zt as toEventSelector, _t as InvalidRequestRpcError, bt as MethodNotFoundRpcError, dt as BundleTooLargeError, et as BaseError, ft as ChainDisconnectedError, gt as InvalidParamsRpcError, h as multicall3Abi, ht as InvalidInputRpcError, jt as UnsupportedChainIdError, kt as UnknownBundleIdError, l as erc6492SignatureValidatorByteCode, lt as AtomicReadyWalletRejectedUpgradeError, m as erc6492SignatureValidatorAbi, mt as InternalRpcError, n as call, o as getChainContractAddress, p as erc1271Abi, pt as DuplicateIdError, r as createBatchScheduler, s as encodeDeployData, tt as decodeFunctionResult, u as multicall3Bytecode, ut as AtomicityNotSupportedError, vt as JsonRpcVersionUnsupportedError, wt as ResourceNotFoundRpcError, xt as MethodNotSupportedRpcError, yt as LimitExceededRpcError, zt as CallExecutionError } from "./decodeFunctionData-DuFcwhC_.js";
+import { $ as recoverAuthorizationAddress, F as readContract, I as formatLog, M as formatTransactionReceipt, _ as decode, a as assert$2, et as recoverAddress, f as toRpc$1, nt as getAction, o as extract, tt as getContractError, v as encode, y as from$1 } from "./sendRawTransactionSync-DvSkhZtW.js";
+import { $ as toBytes, E as TransactionReceiptNotFoundError, F as parseAccount, Ft as formatAbiItem, I as encodeAbiParameters, J as LruMap, M as stringify, Mt as BaseError$1, Nt as size$1, Ot as DecodeLogDataMismatch, P as PositionOutOfBoundsError, Pt as isHex, St as AbiEventSignatureNotFoundError, W as concatHex, X as keccak256, bt as AbiEventNotFoundError, et as bytesToHex, gt as AbiDecodingZeroDataError, ht as AbiDecodingDataSizeTooSmallError, kt as DecodeLogTopicsMismatch, nt as stringToHex, ot as hexToBool, q as getAddress, tt as numberToHex, xt as AbiEventSignatureEmptyTopicsError } from "./chain-CafcHffR.js";
+import { t as isAddressEqual } from "./isAddressEqual-DsAqfQOD.js";
+import { c as serializeSignature } from "./accounts-IG-Cmrwy.js";
+//#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(toBytes(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/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) throw new DecodeLogDataMismatch({
+					abiItem,
+					data,
+					params: inputsToDecode,
+					size: size$1(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(toBytes(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/utils/observe.js
+/** @internal */
+const listenersCache = /* @__PURE__ */ new Map();
+/** @internal */
+const cleanupCache = /* @__PURE__ */ new Map();
+let callbackCount = 0;
+/**
+* @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.
+*/
+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/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();
+	};
+	watch();
+	return unwatch;
+}
+//#endregion
+//#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
+	};
+}
+/**
+* @description Returns the result of a given promise, and caches the result for
+* subsequent invocations against a provided cache key.
+*/
+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;
+	}
+	let promise = cache.promise.get();
+	if (!promise) {
+		promise = fn();
+		cache.promise.set(promise);
+	}
+	try {
+		const data = await promise;
+		cache.response.set({
+			created: /* @__PURE__ */ new Date(),
+			data
+		});
+		return data;
+	} finally {
+		cache.promise.clear();
+	}
+}
+//#endregion
+//#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}`;
+/**
+* Returns the number of the most recent block seen.
+*
+* - 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
+* import { createPublicClient, http } from 'viem'
+* import { mainnet } from 'viem/chains'
+* import { getBlockNumber } from 'viem/public'
+*
+* 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.
+*
+* - Docs: https://viem.sh/docs/actions/public/getFilterChanges
+* - JSON-RPC Methods: [`eth_getFilterChanges`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getfilterchanges)
+*
+* 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([
+			"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([
+			"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/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/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(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(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(body.map((body) => ({
+						jsonrpc: "2.0",
+						id: body.id ?? idCache.take(),
+						...body
+					}))) : stringify({
+						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(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/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);
+}
+/** Suffix ABI parameters for the ERC-8010 wrapped signature. */
+const suffixParameters = from$1("(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(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/public/getTransactionReceipt.js
+/**
+* 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/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 GetTransactionReceiptParameters}
+* @returns The transaction receipt. {@link GetTransactionReceiptReturnType}
+*
+* @example
+* import { createPublicClient, http } from 'viem'
+* import { mainnet } from 'viem/chains'
+* import { getTransactionReceipt } from 'viem/public'
+*
+* const client = createPublicClient({
+*   chain: mainnet,
+*   transport: http(),
+* })
+* const transactionReceipt = await getTransactionReceipt(client, {
+*   hash: '0x4ca7ee652d57678f26e887c149ab0735f41de37bcad58c9f6d3ed5824f15b74d',
+* })
+*/
+async function getTransactionReceipt(client, { hash }) {
+	const receipt = await client.request({
+		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$1("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({
+				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({
+				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 { createContractEventFilter as C, decodeEventLog as S, encodeEventTopics as T, poll as _, getTransactionReceipt as a, getLogs as b, defineChain as c, createClient as d, withRetry as f, getBlockNumber as g, getFilterChanges as h, multicall as i, extendSchema as l, uninstallFilter as m, createTransport as n, fromRpcList as o, watchContractEvent as p, verifyHash as r, toRpcList as s, http as t, getCode as u, observe as v, createFilterRequestScope as w, parseEventLogs as x, getContractEvents as y };