@reown/appkit-cdn 1.8.15-ea982070c1d274f5971447c430b6d77717082e78.0 → 1.8.15-viem-upgrade.0

package/dist/parseSignature-MJforcG6.js

@@ -1,4690 +0,0 @@
-import { T as BaseError, ae as getAbiItem, cJ as AbiEventNotFoundError, ab as formatAbiItem, cK as toEventSelector, aF as keccak256$1, cL as toBytes, a0 as encodeAbiParameters, cM as createFilterRequestScope, K as numberToHex, b4 as encodeFunctionData, cN as getAction, cO as estimateGas, cP as parseAccount, cQ as getContractError, cR as formatLog, cS as parseEventLogs, cT as assertSize$1, cU as padRight$1, cV as BaseError$1, cW as fromBytes$2, cX as toNumber$1, cY as toBigInt$1, cZ as stringify, _ as call, c_ as decodeFunctionResult, X as stringify$1, c$ as observe, d0 as poll, d1 as getFilterChanges, d2 as getBlockNumber, d3 as InvalidInputRpcError, d4 as uninstallFilter, d5 as decodeEventLog, d6 as DecodeLogDataMismatch, d7 as DecodeLogTopicsMismatch, $ as concat, d8 as UnsupportedNonOptionalCapabilityError, d9 as AtomicityNotSupportedError, da as sendTransaction, db as hexToBigInt, dc as getTransactionError, dd as hexToNumber, de as receiptStatuses, df as trim$1, dg as sliceHex, dh as withResolvers, di as withRetry, dj as ContractFunctionRevertedError, a2 as isHex, aD as bytesToHex, dk as stringToBytes, dl as getChainContractAddress, dm as addressResolverAbi, aL as toHex$1, dn as universalResolverResolveAbi, dp as readContract, dq as textResolverAbi, dr as universalResolverReverseAbi, ds as assertRequest, dt as formatTransactionRequest, du as extract$1, dv as getCallError, dw as AbiEncodingLengthMismatchError, ah as concatHex, aH as isAddress, aI as InvalidAddressError$1, dx as pad$1, aC as stringToHex, dy as boolToHex, aG as integerRegex$1, aJ as bytesRegex$1, aK as BytesSizeMismatchError$1, dz as arrayRegex$1, dA as UnsupportedPackedAbiType, Z as isAddressEqual, dB as recoverAuthorizationAddress, H as getAddress, dC as LruMap$1, dD as getTransactionCount, L as withTimeout, dE as TimeoutError, a1 as HttpRequestError, dF as keccak_256, dG as concat$1, dH as fromNumber, dI as validate$4, dJ as slice$1, dK as size$1, dL as from$a, dM as padLeft, dN as fromBoolean, dO as IntegerOutOfRangeError, dP as fromString$1, dQ as trimLeft$1, dR as secp256k1, dS as hexToBytes, dT as getTransaction, dU as toRpc, dV as serializeStateOverride, dW as formatBlock, dX as AbiDecodingZeroDataError, dY as RawContractError, dZ as getNodeError, d_ as UnknownNodeError, d$ as deploylessCallViaBytecodeBytecode, e0 as recoverAddress$1, e1 as multicall3Abi, e2 as multicall3Bytecode, e3 as erc1271Abi, e4 as erc6492SignatureValidatorAbi, e5 as encodeDeployData, e6 as erc6492SignatureValidatorByteCode, e7 as CallExecutionError, e8 as hexToBool, e9 as ContractFunctionExecutionError, ea as getBlock, eb as watchPendingTransactions, ec as watchBlockNumber, ed as waitForTransactionReceipt, ee as sendRawTransaction, ef as prepareTransactionRequest, eg as multicall, eh as getTransactionReceipt, ei as estimateMaxPriorityFeePerGas, ej as getGasPrice, ek as estimateFeesPerGas, el as getChainId, em as getBalance, en as createPendingTransactionFilter, eo as createClient, ep as AccountNotFoundError, eq as createTransport, er as createBatchScheduler, es as RpcRequestError } from "./appkit-ppmICUF1.js";
-import { l as localBatchGatewayUrl } from "./localBatchGatewayRequest-CLL1gABv.js";
-import { p as parseAbiParameters, f as formatAbiParameters, a as parseAbiItem, b as formatAbiItem$1 } from "./parseAbiParameters-DfJcIE_w.js";
-import { h as hashMessage, a as hashTypedData } from "./hashTypedData-MEx8_Z-J.js";
-class FilterTypeNotSupportedError extends BaseError {
-  constructor(type) {
-    super(`Filter type "${type}" is not supported.`, {
-      name: "FilterTypeNotSupportedError"
-    });
-  }
-}
-const docsPath = "/docs/contract/encodeEventTopics";
-function encodeEventTopics(parameters) {
-  var _a;
-  const { abi: abi2, eventName, args } = parameters;
-  let abiItem = abi2[0];
-  if (eventName) {
-    const item = getAbiItem({ abi: abi2, name: eventName });
-    if (!item)
-      throw new AbiEventNotFoundError(eventName, { docsPath });
-    abiItem = item;
-  }
-  if (abiItem.type !== "event")
-    throw new AbiEventNotFoundError(void 0, { docsPath });
-  const definition = formatAbiItem(abiItem);
-  const signature = toEventSelector(definition);
-  let topics = [];
-  if (args && "inputs" in abiItem) {
-    const indexedInputs = (_a = abiItem.inputs) == null ? void 0 : _a.filter((param) => "indexed" in param && param.indexed);
-    const args_ = Array.isArray(args) ? args : Object.values(args).length > 0 ? (indexedInputs == null ? void 0 : indexedInputs.map((x) => args[x.name])) ?? [] : [];
-    if (args_.length > 0) {
-      topics = (indexedInputs == null ? void 0 : 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(value));
-  if (param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
-    throw new FilterTypeNotSupportedError(param.type);
-  return encodeAbiParameters([param], [value]);
-}
-async function createContractEventFilter(client, parameters) {
-  const { address, abi: abi2, args, eventName, fromBlock, strict, toBlock } = parameters;
-  const getRequest = createFilterRequestScope(client, {
-    method: "eth_newFilter"
-  });
-  const topics = eventName ? encodeEventTopics({
-    abi: abi2,
-    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: abi2,
-    args,
-    eventName,
-    id,
-    request: getRequest(id),
-    strict: Boolean(strict),
-    type: "event"
-  };
-}
-async function estimateContractGas(client, parameters) {
-  const { abi: abi2, address, args, functionName, dataSuffix, ...request } = parameters;
-  const data = encodeFunctionData({
-    abi: abi2,
-    args,
-    functionName
-  });
-  try {
-    const gas = await getAction(client, estimateGas, "estimateGas")({
-      data: `${data}${dataSuffix ? dataSuffix.replace("0x", "") : ""}`,
-      to: address,
-      ...request
-    });
-    return gas;
-  } catch (error) {
-    const account = request.account ? parseAccount(request.account) : void 0;
-    throw getContractError(error, {
-      abi: abi2,
-      address,
-      args,
-      docsPath: "/docs/contract/estimateContractGas",
-      functionName,
-      sender: account == null ? void 0 : account.address
-    });
-  }
-}
-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) {
-    const encoded = events.flatMap((event2) => encodeEventTopics({
-      abi: [event2],
-      eventName: event2.name,
-      args: events_ ? void 0 : args
-    }));
-    topics = [encoded];
-    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
-  });
-}
-async function getContractEvents(client, parameters) {
-  const { abi: abi2, address, args, blockHash, eventName, fromBlock, toBlock, strict } = parameters;
-  const event = eventName ? getAbiItem({ abi: abi2, name: eventName }) : void 0;
-  const events = !event ? abi2.filter((x) => x.type === "event") : void 0;
-  return getAction(client, getLogs, "getLogs")({
-    address,
-    args,
-    blockHash,
-    event,
-    events,
-    fromBlock,
-    toBlock,
-    strict
-  });
-}
-function assertSize(bytes, size_) {
-  if (size(bytes) > size_)
-    throw new SizeOverflowError({
-      givenSize: size(bytes),
-      maxSize: size_
-    });
-}
-const charCodeMap = {
-  zero: 48,
-  nine: 57,
-  A: 65,
-  F: 70,
-  a: 97,
-  f: 102
-};
-function charCodeToBase16(char) {
-  if (char >= charCodeMap.zero && char <= charCodeMap.nine)
-    return char - charCodeMap.zero;
-  if (char >= charCodeMap.A && char <= charCodeMap.F)
-    return char - (charCodeMap.A - 10);
-  if (char >= charCodeMap.a && char <= charCodeMap.f)
-    return char - (charCodeMap.a - 10);
-  return void 0;
-}
-function pad(bytes, options = {}) {
-  const { dir, size: size2 = 32 } = options;
-  if (size2 === 0)
-    return bytes;
-  if (bytes.length > size2)
-    throw new SizeExceedsPaddingSizeError({
-      size: bytes.length,
-      targetSize: size2,
-      type: "Bytes"
-    });
-  const paddedBytes = new Uint8Array(size2);
-  for (let i = 0; i < size2; i++) {
-    const padEnd = dir === "right";
-    paddedBytes[padEnd ? i : size2 - i - 1] = bytes[padEnd ? i : bytes.length - i - 1];
-  }
-  return paddedBytes;
-}
-function trim(value, options = {}) {
-  const { dir = "left" } = options;
-  let data = value;
-  let sliceLength = 0;
-  for (let i = 0; i < data.length - 1; i++) {
-    if (data[dir === "left" ? i : data.length - i - 1].toString() === "0")
-      sliceLength++;
-    else
-      break;
-  }
-  data = dir === "left" ? data.slice(sliceLength) : data.slice(0, data.length - sliceLength);
-  return data;
-}
-const decoder = /* @__PURE__ */ new TextDecoder();
-const encoder = /* @__PURE__ */ new TextEncoder();
-function assert$5(value) {
-  if (value instanceof Uint8Array)
-    return;
-  if (!value)
-    throw new InvalidBytesTypeError(value);
-  if (typeof value !== "object")
-    throw new InvalidBytesTypeError(value);
-  if (!("BYTES_PER_ELEMENT" in value))
-    throw new InvalidBytesTypeError(value);
-  if (value.BYTES_PER_ELEMENT !== 1 || value.constructor.name !== "Uint8Array")
-    throw new InvalidBytesTypeError(value);
-}
-function from$9(value) {
-  if (value instanceof Uint8Array)
-    return value;
-  if (typeof value === "string")
-    return fromHex$3(value);
-  return fromArray(value);
-}
-function fromArray(value) {
-  return value instanceof Uint8Array ? value : new Uint8Array(value);
-}
-function fromHex$3(value, options = {}) {
-  const { size: size2 } = options;
-  let hex = value;
-  if (size2) {
-    assertSize$1(value, size2);
-    hex = padRight$1(value, size2);
-  }
-  let hexString = hex.slice(2);
-  if (hexString.length % 2)
-    hexString = `0${hexString}`;
-  const length = hexString.length / 2;
-  const bytes = new Uint8Array(length);
-  for (let index = 0, j = 0; index < length; index++) {
-    const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
-    const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
-    if (nibbleLeft === void 0 || nibbleRight === void 0) {
-      throw new BaseError$1(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
-    }
-    bytes[index] = nibbleLeft * 16 + nibbleRight;
-  }
-  return bytes;
-}
-function fromString(value, options = {}) {
-  const { size: size2 } = options;
-  const bytes = encoder.encode(value);
-  if (typeof size2 === "number") {
-    assertSize(bytes, size2);
-    return padRight(bytes, size2);
-  }
-  return bytes;
-}
-function padRight(value, size2) {
-  return pad(value, { dir: "right", size: size2 });
-}
-function size(value) {
-  return value.length;
-}
-function slice(value, start, end, options = {}) {
-  const { strict } = options;
-  const value_ = value.slice(start, end);
-  return value_;
-}
-function toBigInt(bytes, options = {}) {
-  const { size: size2 } = options;
-  if (typeof size2 !== "undefined")
-    assertSize(bytes, size2);
-  const hex = fromBytes$2(bytes, options);
-  return toBigInt$1(hex, options);
-}
-function toBoolean(bytes, options = {}) {
-  const { size: size2 } = options;
-  let bytes_ = bytes;
-  if (typeof size2 !== "undefined") {
-    assertSize(bytes_, size2);
-    bytes_ = trimLeft(bytes_);
-  }
-  if (bytes_.length > 1 || bytes_[0] > 1)
-    throw new InvalidBytesBooleanError(bytes_);
-  return Boolean(bytes_[0]);
-}
-function toNumber(bytes, options = {}) {
-  const { size: size2 } = options;
-  if (typeof size2 !== "undefined")
-    assertSize(bytes, size2);
-  const hex = fromBytes$2(bytes, options);
-  return toNumber$1(hex, options);
-}
-function toString(bytes, options = {}) {
-  const { size: size2 } = options;
-  let bytes_ = bytes;
-  if (typeof size2 !== "undefined") {
-    assertSize(bytes_, size2);
-    bytes_ = trimRight(bytes_);
-  }
-  return decoder.decode(bytes_);
-}
-function trimLeft(value) {
-  return trim(value, { dir: "left" });
-}
-function trimRight(value) {
-  return trim(value, { dir: "right" });
-}
-function validate$3(value) {
-  try {
-    assert$5(value);
-    return true;
-  } catch {
-    return false;
-  }
-}
-class InvalidBytesBooleanError extends BaseError$1 {
-  constructor(bytes) {
-    super(`Bytes value \`${bytes}\` is not a valid boolean.`, {
-      metaMessages: [
-        "The bytes array must contain a single byte of either a `0` or `1` value."
-      ]
-    });
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "Bytes.InvalidBytesBooleanError"
-    });
-  }
-}
-class InvalidBytesTypeError extends BaseError$1 {
-  constructor(value) {
-    super(`Value \`${typeof value === "object" ? stringify(value) : value}\` of type \`${typeof value}\` is an invalid Bytes value.`, {
-      metaMessages: ["Bytes values must be of type `Bytes`."]
-    });
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "Bytes.InvalidBytesTypeError"
-    });
-  }
-}
-class SizeOverflowError extends BaseError$1 {
-  constructor({ givenSize, maxSize }) {
-    super(`Size cannot exceed \`${maxSize}\` bytes. Given size: \`${givenSize}\` bytes.`);
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "Bytes.SizeOverflowError"
-    });
-  }
-}
-class SizeExceedsPaddingSizeError extends BaseError$1 {
-  constructor({ size: size2, targetSize, type }) {
-    super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (\`${size2}\`) exceeds padding size (\`${targetSize}\`).`);
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "Bytes.SizeExceedsPaddingSizeError"
-    });
-  }
-}
-async function simulateContract(client, parameters) {
-  const { abi: abi2, address, args, dataSuffix, functionName, ...callRequest } = parameters;
-  const account = callRequest.account ? parseAccount(callRequest.account) : client.account;
-  const calldata = encodeFunctionData({ abi: abi2, args, functionName });
-  try {
-    const { data } = await getAction(client, call, "call")({
-      batch: false,
-      data: `${calldata}${dataSuffix ? dataSuffix.replace("0x", "") : ""}`,
-      to: address,
-      ...callRequest,
-      account
-    });
-    const result = decodeFunctionResult({
-      abi: abi2,
-      args,
-      functionName,
-      data: data || "0x"
-    });
-    const minimizedAbi = abi2.filter((abiItem) => "name" in abiItem && abiItem.name === parameters.functionName);
-    return {
-      result,
-      request: {
-        abi: minimizedAbi,
-        address,
-        args,
-        dataSuffix,
-        functionName,
-        ...callRequest,
-        account
-      }
-    };
-  } catch (error) {
-    throw getContractError(error, {
-      abi: abi2,
-      address,
-      args,
-      docsPath: "/docs/contract/simulateContract",
-      functionName,
-      sender: account == null ? void 0 : account.address
-    });
-  }
-}
-function watchContractEvent(client, parameters) {
-  const { abi: abi2, 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;
-    const observerId = stringify$1([
-      "watchContractEvent",
-      address,
-      args,
-      batch,
-      client.uid,
-      eventName,
-      pollingInterval,
-      strict,
-      fromBlock
-    ]);
-    return observe(observerId, { onLogs, onError }, (emit) => {
-      let previousBlockNumber;
-      if (fromBlock !== void 0)
-        previousBlockNumber = fromBlock - 1n;
-      let filter;
-      let initialized = false;
-      const unwatch = poll(async () => {
-        var _a;
-        if (!initialized) {
-          try {
-            filter = await getAction(client, createContractEventFilter, "createContractEventFilter")({
-              abi: abi2,
-              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: abi2,
-                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;
-          (_a = emit.onError) == null ? void 0 : _a.call(emit, 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 transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket" || transport3.config.type === "ipc");
-              if (!transport2)
-                return client.transport;
-              return transport2.value;
-            }
-            return client.transport;
-          })();
-          const topics = eventName ? encodeEventTopics({
-            abi: abi2,
-            eventName,
-            args
-          }) : [];
-          const { unsubscribe: unsubscribe_ } = await transport.subscribe({
-            params: ["logs", { address, topics }],
-            onData(data) {
-              var _a;
-              if (!active)
-                return;
-              const log = data.result;
-              try {
-                const { eventName: eventName2, args: args2 } = decodeEventLog({
-                  abi: abi2,
-                  data: log.data,
-                  topics: log.topics,
-                  strict: strict_
-                });
-                const formatted = formatLog(log, {
-                  args: args2,
-                  eventName: eventName2
-                });
-                emit.onLogs([formatted]);
-              } catch (err) {
-                let eventName2;
-                let isUnnamed;
-                if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
-                  if (strict_)
-                    return;
-                  eventName2 = err.abiItem.name;
-                  isUnnamed = (_a = err.abiItem.inputs) == null ? void 0 : _a.some((x) => !("name" in x && x.name));
-                }
-                const formatted = formatLog(log, {
-                  args: isUnnamed ? [] : {},
-                  eventName: eventName2
-                });
-                emit.onLogs([formatted]);
-              }
-            },
-            onError(error) {
-              var _a;
-              (_a = emit.onError) == null ? void 0 : _a.call(emit, error);
-            }
-          });
-          unsubscribe = unsubscribe_;
-          if (!active)
-            unsubscribe();
-        } catch (err) {
-          onError == null ? void 0 : onError(err);
-        }
-      })();
-      return () => unsubscribe();
-    });
-  };
-  return enablePolling ? pollContractEvent() : subscribeContractEvent();
-}
-class BundleFailedError extends BaseError {
-  constructor(result) {
-    super(`Call bundle failed with status: ${result.statusCode}`, {
-      name: "BundleFailedError"
-    });
-    Object.defineProperty(this, "result", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    this.result = result;
-  }
-}
-const fallbackMagicIdentifier = "0x5792579257925792579257925792579257925792579257925792579257925792";
-const fallbackTransactionErrorMagicIdentifier = numberToHex(0, {
-  size: 32
-});
-async function sendCalls(client, parameters) {
-  const { account: account_ = client.account, capabilities, chain = client.chain, experimental_fallback, experimental_fallbackDelay = 32, forceAtomic = false, id, version = "2.0.0" } = parameters;
-  const account = account_ ? parseAccount(account_) : null;
-  const calls = parameters.calls.map((call_) => {
-    const call2 = call_;
-    const data = call2.abi ? encodeFunctionData({
-      abi: call2.abi,
-      functionName: call2.functionName,
-      args: call2.args
-    }) : call2.data;
-    return {
-      data: call2.dataSuffix && data ? concat([data, call2.dataSuffix]) : data,
-      to: call2.to,
-      value: call2.value ? numberToHex(call2.value) : void 0
-    };
-  });
-  try {
-    const response = await client.request({
-      method: "wallet_sendCalls",
-      params: [
-        {
-          atomicRequired: forceAtomic,
-          calls,
-          capabilities,
-          chainId: numberToHex(chain.id),
-          from: account == null ? void 0 : account.address,
-          id,
-          version
-        }
-      ]
-    }, { retryCount: 0 });
-    if (typeof response === "string")
-      return { id: response };
-    return response;
-  } catch (err) {
-    const error = err;
-    if (experimental_fallback && (error.name === "MethodNotFoundRpcError" || error.name === "MethodNotSupportedRpcError" || error.name === "UnknownRpcError" || error.details.toLowerCase().includes("does not exist / is not available") || error.details.toLowerCase().includes("missing or invalid. request()") || error.details.toLowerCase().includes("did not match any variant of untagged enum") || error.details.toLowerCase().includes("account upgraded to unsupported contract") || error.details.toLowerCase().includes("eip-7702 not supported") || error.details.toLowerCase().includes("unsupported wc_ method") || error.details.toLowerCase().includes("feature toggled misconfigured"))) {
-      if (capabilities) {
-        const hasNonOptionalCapability = Object.values(capabilities).some((capability) => !capability.optional);
-        if (hasNonOptionalCapability) {
-          const message = "non-optional `capabilities` are not supported on fallback to `eth_sendTransaction`.";
-          throw new UnsupportedNonOptionalCapabilityError(new BaseError(message, {
-            details: message
-          }));
-        }
-      }
-      if (forceAtomic && calls.length > 1) {
-        const message = "`forceAtomic` is not supported on fallback to `eth_sendTransaction`.";
-        throw new AtomicityNotSupportedError(new BaseError(message, {
-          details: message
-        }));
-      }
-      const promises = [];
-      for (const call2 of calls) {
-        const promise = sendTransaction(client, {
-          account,
-          chain,
-          data: call2.data,
-          to: call2.to,
-          value: call2.value ? hexToBigInt(call2.value) : void 0
-        });
-        promises.push(promise);
-        if (experimental_fallbackDelay > 0)
-          await new Promise((resolve) => setTimeout(resolve, experimental_fallbackDelay));
-      }
-      const results = await Promise.allSettled(promises);
-      if (results.every((r) => r.status === "rejected"))
-        throw results[0].reason;
-      const hashes = results.map((result) => {
-        if (result.status === "fulfilled")
-          return result.value;
-        return fallbackTransactionErrorMagicIdentifier;
-      });
-      return {
-        id: concat([
-          ...hashes,
-          numberToHex(chain.id, { size: 32 }),
-          fallbackMagicIdentifier
-        ])
-      };
-    }
-    throw getTransactionError(err, {
-      ...parameters,
-      account,
-      chain: parameters.chain
-    });
-  }
-}
-async function getCallsStatus(client, parameters) {
-  async function getStatus(id) {
-    const isTransactions = id.endsWith(fallbackMagicIdentifier.slice(2));
-    if (isTransactions) {
-      const chainId2 = trim$1(sliceHex(id, -64, -32));
-      const hashes = sliceHex(id, 0, -64).slice(2).match(/.{1,64}/g);
-      const receipts2 = await Promise.all(hashes.map((hash2) => fallbackTransactionErrorMagicIdentifier.slice(2) !== hash2 ? client.request({
-        method: "eth_getTransactionReceipt",
-        params: [`0x${hash2}`]
-      }, { dedupe: true }) : void 0));
-      const status2 = (() => {
-        if (receipts2.some((r) => r === null))
-          return 100;
-        if (receipts2.every((r) => (r == null ? void 0 : r.status) === "0x1"))
-          return 200;
-        if (receipts2.every((r) => (r == null ? void 0 : r.status) === "0x0"))
-          return 500;
-        return 600;
-      })();
-      return {
-        atomic: false,
-        chainId: hexToNumber(chainId2),
-        receipts: receipts2.filter(Boolean),
-        status: status2,
-        version: "2.0.0"
-      };
-    }
-    return client.request({
-      method: "wallet_getCallsStatus",
-      params: [id]
-    });
-  }
-  const { atomic = false, chainId, receipts, version = "2.0.0", ...response } = await getStatus(parameters.id);
-  const [status, statusCode] = (() => {
-    const statusCode2 = response.status;
-    if (statusCode2 >= 100 && statusCode2 < 200)
-      return ["pending", statusCode2];
-    if (statusCode2 >= 200 && statusCode2 < 300)
-      return ["success", statusCode2];
-    if (statusCode2 >= 300 && statusCode2 < 700)
-      return ["failure", statusCode2];
-    if (statusCode2 === "CONFIRMED")
-      return ["success", 200];
-    if (statusCode2 === "PENDING")
-      return ["pending", 100];
-    return [void 0, statusCode2];
-  })();
-  return {
-    ...response,
-    atomic,
-    // @ts-expect-error: for backwards compatibility
-    chainId: chainId ? hexToNumber(chainId) : void 0,
-    receipts: (receipts == null ? void 0 : receipts.map((receipt) => ({
-      ...receipt,
-      blockNumber: hexToBigInt(receipt.blockNumber),
-      gasUsed: hexToBigInt(receipt.gasUsed),
-      status: receiptStatuses[receipt.status]
-    }))) ?? [],
-    statusCode,
-    status,
-    version
-  };
-}
-async function waitForCallsStatus(client, parameters) {
-  const {
-    id,
-    pollingInterval = client.pollingInterval,
-    status = ({ statusCode }) => statusCode === 200 || statusCode >= 300,
-    retryCount = 4,
-    retryDelay = ({ count }) => ~~(1 << count) * 200,
-    // exponential backoff
-    timeout = 6e4,
-    throwOnFailure = false
-  } = parameters;
-  const observerId = stringify$1(["waitForCallsStatus", client.uid, id]);
-  const { promise, resolve, reject } = withResolvers();
-  let timer;
-  const unobserve = observe(observerId, { resolve, reject }, (emit) => {
-    const unpoll = poll(async () => {
-      const done = (fn) => {
-        clearTimeout(timer);
-        unpoll();
-        fn();
-        unobserve();
-      };
-      try {
-        const result = await withRetry(async () => {
-          const result2 = await getAction(client, getCallsStatus, "getCallsStatus")({ id });
-          if (throwOnFailure && result2.status === "failure")
-            throw new BundleFailedError(result2);
-          return result2;
-        }, {
-          retryCount,
-          delay: retryDelay
-        });
-        if (!status(result))
-          return;
-        done(() => emit.resolve(result));
-      } catch (error) {
-        done(() => emit.reject(error));
-      }
-    }, {
-      interval: pollingInterval,
-      emitOnBegin: true
-    });
-    return unpoll;
-  });
-  timer = timeout ? setTimeout(() => {
-    unobserve();
-    clearTimeout(timer);
-    reject(new WaitForCallsStatusTimeoutError({ id }));
-  }, timeout) : void 0;
-  return await promise;
-}
-class WaitForCallsStatusTimeoutError extends BaseError {
-  constructor({ id }) {
-    super(`Timed out while waiting for call bundle with id "${id}" to be confirmed.`, { name: "WaitForCallsStatusTimeoutError" });
-  }
-}
-function isNullUniversalResolverError(err) {
-  var _a, _b, _c, _d, _e, _f;
-  if (!(err instanceof BaseError))
-    return false;
-  const cause = err.walk((e) => e instanceof ContractFunctionRevertedError);
-  if (!(cause instanceof ContractFunctionRevertedError))
-    return false;
-  if (((_a = cause.data) == null ? void 0 : _a.errorName) === "HttpError")
-    return true;
-  if (((_b = cause.data) == null ? void 0 : _b.errorName) === "ResolverError")
-    return true;
-  if (((_c = cause.data) == null ? void 0 : _c.errorName) === "ResolverNotContract")
-    return true;
-  if (((_d = cause.data) == null ? void 0 : _d.errorName) === "ResolverNotFound")
-    return true;
-  if (((_e = cause.data) == null ? void 0 : _e.errorName) === "ReverseAddressMismatch")
-    return true;
-  if (((_f = cause.data) == null ? void 0 : _f.errorName) === "UnsupportedResolverProfile")
-    return true;
-  return false;
-}
-function encodedLabelToLabelhash(label) {
-  if (label.length !== 66)
-    return null;
-  if (label.indexOf("[") !== 0)
-    return null;
-  if (label.indexOf("]") !== 65)
-    return null;
-  const hash2 = `0x${label.slice(1, 65)}`;
-  if (!isHex(hash2))
-    return null;
-  return hash2;
-}
-function namehash(name) {
-  let result = new Uint8Array(32).fill(0);
-  if (!name)
-    return bytesToHex(result);
-  const labels = name.split(".");
-  for (let i = labels.length - 1; i >= 0; i -= 1) {
-    const hashFromEncodedLabel = encodedLabelToLabelhash(labels[i]);
-    const hashed = hashFromEncodedLabel ? toBytes(hashFromEncodedLabel) : keccak256$1(stringToBytes(labels[i]), "bytes");
-    result = keccak256$1(concat([result, hashed]), "bytes");
-  }
-  return bytesToHex(result);
-}
-function encodeLabelhash(hash2) {
-  return `[${hash2.slice(2)}]`;
-}
-function labelhash(label) {
-  const result = new Uint8Array(32).fill(0);
-  if (!label)
-    return bytesToHex(result);
-  return encodedLabelToLabelhash(label) || keccak256$1(stringToBytes(label));
-}
-function packetToBytes(packet) {
-  const value = packet.replace(/^\.|\.$/gm, "");
-  if (value.length === 0)
-    return new Uint8Array(1);
-  const bytes = new Uint8Array(stringToBytes(value).byteLength + 2);
-  let offset = 0;
-  const list = value.split(".");
-  for (let i = 0; i < list.length; i++) {
-    let encoded = stringToBytes(list[i]);
-    if (encoded.byteLength > 255)
-      encoded = stringToBytes(encodeLabelhash(labelhash(list[i])));
-    bytes[offset] = encoded.length;
-    bytes.set(encoded, offset + 1);
-    offset += encoded.length + 1;
-  }
-  if (bytes.byteLength !== offset + 1)
-    return bytes.slice(0, offset + 1);
-  return bytes;
-}
-async function getEnsAddress(client, parameters) {
-  const { blockNumber, blockTag, coinType, name, gatewayUrls, strict } = parameters;
-  const { chain } = client;
-  const universalResolverAddress = (() => {
-    if (parameters.universalResolverAddress)
-      return parameters.universalResolverAddress;
-    if (!chain)
-      throw new Error("client chain not configured. universalResolverAddress is required.");
-    return getChainContractAddress({
-      blockNumber,
-      chain,
-      contract: "ensUniversalResolver"
-    });
-  })();
-  const tlds = chain == null ? void 0 : chain.ensTlds;
-  if (tlds && !tlds.some((tld) => name.endsWith(tld)))
-    return null;
-  const args = (() => {
-    if (coinType != null)
-      return [namehash(name), BigInt(coinType)];
-    return [namehash(name)];
-  })();
-  try {
-    const functionData = encodeFunctionData({
-      abi: addressResolverAbi,
-      functionName: "addr",
-      args
-    });
-    const readContractParameters = {
-      address: universalResolverAddress,
-      abi: universalResolverResolveAbi,
-      functionName: "resolveWithGateways",
-      args: [
-        toHex$1(packetToBytes(name)),
-        functionData,
-        gatewayUrls ?? [localBatchGatewayUrl]
-      ],
-      blockNumber,
-      blockTag
-    };
-    const readContractAction = getAction(client, readContract, "readContract");
-    const res = await readContractAction(readContractParameters);
-    if (res[0] === "0x")
-      return null;
-    const address = decodeFunctionResult({
-      abi: addressResolverAbi,
-      args,
-      functionName: "addr",
-      data: res[0]
-    });
-    if (address === "0x")
-      return null;
-    if (trim$1(address) === "0x00")
-      return null;
-    return address;
-  } catch (err) {
-    if (strict)
-      throw err;
-    if (isNullUniversalResolverError(err))
-      return null;
-    throw err;
-  }
-}
-class EnsAvatarInvalidMetadataError extends BaseError {
-  constructor({ data }) {
-    super("Unable to extract image from metadata. The metadata may be malformed or invalid.", {
-      metaMessages: [
-        "- Metadata must be a JSON object with at least an `image`, `image_url` or `image_data` property.",
-        "",
-        `Provided data: ${JSON.stringify(data)}`
-      ],
-      name: "EnsAvatarInvalidMetadataError"
-    });
-  }
-}
-class EnsAvatarInvalidNftUriError extends BaseError {
-  constructor({ reason }) {
-    super(`ENS NFT avatar URI is invalid. ${reason}`, {
-      name: "EnsAvatarInvalidNftUriError"
-    });
-  }
-}
-class EnsAvatarUriResolutionError extends BaseError {
-  constructor({ uri }) {
-    super(`Unable to resolve ENS avatar URI "${uri}". The URI may be malformed, invalid, or does not respond with a valid image.`, { name: "EnsAvatarUriResolutionError" });
-  }
-}
-class EnsAvatarUnsupportedNamespaceError extends BaseError {
-  constructor({ namespace }) {
-    super(`ENS NFT avatar namespace "${namespace}" is not supported. Must be "erc721" or "erc1155".`, { name: "EnsAvatarUnsupportedNamespaceError" });
-  }
-}
-class EnsInvalidChainIdError extends BaseError {
-  constructor({ chainId }) {
-    super(`Invalid ENSIP-11 chainId: ${chainId}. Must be between 0 and 0x7fffffff, or 1.`, {
-      name: "EnsInvalidChainIdError"
-    });
-  }
-}
-const networkRegex = /(?<protocol>https?:\/\/[^/]*|ipfs:\/|ipns:\/|ar:\/)?(?<root>\/)?(?<subpath>ipfs\/|ipns\/)?(?<target>[\w\-.]+)(?<subtarget>\/.*)?/;
-const ipfsHashRegex = /^(Qm[1-9A-HJ-NP-Za-km-z]{44,}|b[A-Za-z2-7]{58,}|B[A-Z2-7]{58,}|z[1-9A-HJ-NP-Za-km-z]{48,}|F[0-9A-F]{50,})(\/(?<target>[\w\-.]+))?(?<subtarget>\/.*)?$/;
-const base64Regex = /^data:([a-zA-Z\-/+]*);base64,([^"].*)/;
-const dataURIRegex = /^data:([a-zA-Z\-/+]*)?(;[a-zA-Z0-9].*?)?(,)/;
-async function isImageUri(uri) {
-  try {
-    const res = await fetch(uri, { method: "HEAD" });
-    if (res.status === 200) {
-      const contentType = res.headers.get("content-type");
-      return contentType == null ? void 0 : contentType.startsWith("image/");
-    }
-    return false;
-  } catch (error) {
-    if (typeof error === "object" && typeof error.response !== "undefined") {
-      return false;
-    }
-    if (!Object.hasOwn(globalThis, "Image"))
-      return false;
-    return new Promise((resolve) => {
-      const img = new Image();
-      img.onload = () => {
-        resolve(true);
-      };
-      img.onerror = () => {
-        resolve(false);
-      };
-      img.src = uri;
-    });
-  }
-}
-function getGateway(custom, defaultGateway) {
-  if (!custom)
-    return defaultGateway;
-  if (custom.endsWith("/"))
-    return custom.slice(0, -1);
-  return custom;
-}
-function resolveAvatarUri({ uri, gatewayUrls }) {
-  const isEncoded = base64Regex.test(uri);
-  if (isEncoded)
-    return { uri, isOnChain: true, isEncoded };
-  const ipfsGateway = getGateway(gatewayUrls == null ? void 0 : gatewayUrls.ipfs, "https://ipfs.io");
-  const arweaveGateway = getGateway(gatewayUrls == null ? void 0 : gatewayUrls.arweave, "https://arweave.net");
-  const networkRegexMatch = uri.match(networkRegex);
-  const { protocol, subpath, target, subtarget = "" } = (networkRegexMatch == null ? void 0 : networkRegexMatch.groups) || {};
-  const isIPNS = protocol === "ipns:/" || subpath === "ipns/";
-  const isIPFS = protocol === "ipfs:/" || subpath === "ipfs/" || ipfsHashRegex.test(uri);
-  if (uri.startsWith("http") && !isIPNS && !isIPFS) {
-    let replacedUri = uri;
-    if (gatewayUrls == null ? void 0 : gatewayUrls.arweave)
-      replacedUri = uri.replace(/https:\/\/arweave.net/g, gatewayUrls == null ? void 0 : gatewayUrls.arweave);
-    return { uri: replacedUri, isOnChain: false, isEncoded: false };
-  }
-  if ((isIPNS || isIPFS) && target) {
-    return {
-      uri: `${ipfsGateway}/${isIPNS ? "ipns" : "ipfs"}/${target}${subtarget}`,
-      isOnChain: false,
-      isEncoded: false
-    };
-  }
-  if (protocol === "ar:/" && target) {
-    return {
-      uri: `${arweaveGateway}/${target}${subtarget || ""}`,
-      isOnChain: false,
-      isEncoded: false
-    };
-  }
-  let parsedUri = uri.replace(dataURIRegex, "");
-  if (parsedUri.startsWith("<svg")) {
-    parsedUri = `data:image/svg+xml;base64,${btoa(parsedUri)}`;
-  }
-  if (parsedUri.startsWith("data:") || parsedUri.startsWith("{")) {
-    return {
-      uri: parsedUri,
-      isOnChain: true,
-      isEncoded: false
-    };
-  }
-  throw new EnsAvatarUriResolutionError({ uri });
-}
-function getJsonImage(data) {
-  if (typeof data !== "object" || !("image" in data) && !("image_url" in data) && !("image_data" in data)) {
-    throw new EnsAvatarInvalidMetadataError({ data });
-  }
-  return data.image || data.image_url || data.image_data;
-}
-async function getMetadataAvatarUri({ gatewayUrls, uri }) {
-  try {
-    const res = await fetch(uri).then((res2) => res2.json());
-    const image = await parseAvatarUri({
-      gatewayUrls,
-      uri: getJsonImage(res)
-    });
-    return image;
-  } catch {
-    throw new EnsAvatarUriResolutionError({ uri });
-  }
-}
-async function parseAvatarUri({ gatewayUrls, uri }) {
-  const { uri: resolvedURI, isOnChain } = resolveAvatarUri({ uri, gatewayUrls });
-  if (isOnChain)
-    return resolvedURI;
-  const isImage = await isImageUri(resolvedURI);
-  if (isImage)
-    return resolvedURI;
-  throw new EnsAvatarUriResolutionError({ uri });
-}
-function parseNftUri(uri_) {
-  let uri = uri_;
-  if (uri.startsWith("did:nft:")) {
-    uri = uri.replace("did:nft:", "").replace(/_/g, "/");
-  }
-  const [reference, asset_namespace, tokenID] = uri.split("/");
-  const [eip_namespace, chainID] = reference.split(":");
-  const [erc_namespace, contractAddress] = asset_namespace.split(":");
-  if (!eip_namespace || eip_namespace.toLowerCase() !== "eip155")
-    throw new EnsAvatarInvalidNftUriError({ reason: "Only EIP-155 supported" });
-  if (!chainID)
-    throw new EnsAvatarInvalidNftUriError({ reason: "Chain ID not found" });
-  if (!contractAddress)
-    throw new EnsAvatarInvalidNftUriError({
-      reason: "Contract address not found"
-    });
-  if (!tokenID)
-    throw new EnsAvatarInvalidNftUriError({ reason: "Token ID not found" });
-  if (!erc_namespace)
-    throw new EnsAvatarInvalidNftUriError({ reason: "ERC namespace not found" });
-  return {
-    chainID: Number.parseInt(chainID, 10),
-    namespace: erc_namespace.toLowerCase(),
-    contractAddress,
-    tokenID
-  };
-}
-async function getNftTokenUri(client, { nft }) {
-  if (nft.namespace === "erc721") {
-    return readContract(client, {
-      address: nft.contractAddress,
-      abi: [
-        {
-          name: "tokenURI",
-          type: "function",
-          stateMutability: "view",
-          inputs: [{ name: "tokenId", type: "uint256" }],
-          outputs: [{ name: "", type: "string" }]
-        }
-      ],
-      functionName: "tokenURI",
-      args: [BigInt(nft.tokenID)]
-    });
-  }
-  if (nft.namespace === "erc1155") {
-    return readContract(client, {
-      address: nft.contractAddress,
-      abi: [
-        {
-          name: "uri",
-          type: "function",
-          stateMutability: "view",
-          inputs: [{ name: "_id", type: "uint256" }],
-          outputs: [{ name: "", type: "string" }]
-        }
-      ],
-      functionName: "uri",
-      args: [BigInt(nft.tokenID)]
-    });
-  }
-  throw new EnsAvatarUnsupportedNamespaceError({ namespace: nft.namespace });
-}
-async function parseAvatarRecord(client, { gatewayUrls, record }) {
-  if (/eip155:/i.test(record))
-    return parseNftAvatarUri(client, { gatewayUrls, record });
-  return parseAvatarUri({ uri: record, gatewayUrls });
-}
-async function parseNftAvatarUri(client, { gatewayUrls, record }) {
-  const nft = parseNftUri(record);
-  const nftUri = await getNftTokenUri(client, { nft });
-  const { uri: resolvedNftUri, isOnChain, isEncoded } = resolveAvatarUri({ uri: nftUri, gatewayUrls });
-  if (isOnChain && (resolvedNftUri.includes("data:application/json;base64,") || resolvedNftUri.startsWith("{"))) {
-    const encodedJson = isEncoded ? (
-      // if it is encoded, decode it
-      atob(resolvedNftUri.replace("data:application/json;base64,", ""))
-    ) : (
-      // if it isn't encoded assume it is a JSON string, but it could be anything (it will error if it is)
-      resolvedNftUri
-    );
-    const decoded = JSON.parse(encodedJson);
-    return parseAvatarUri({ uri: getJsonImage(decoded), gatewayUrls });
-  }
-  let uriTokenId = nft.tokenID;
-  if (nft.namespace === "erc1155")
-    uriTokenId = uriTokenId.replace("0x", "").padStart(64, "0");
-  return getMetadataAvatarUri({
-    gatewayUrls,
-    uri: resolvedNftUri.replace(/(?:0x)?{id}/, uriTokenId)
-  });
-}
-async function getEnsText(client, parameters) {
-  const { blockNumber, blockTag, key, name, gatewayUrls, strict } = parameters;
-  const { chain } = client;
-  const universalResolverAddress = (() => {
-    if (parameters.universalResolverAddress)
-      return parameters.universalResolverAddress;
-    if (!chain)
-      throw new Error("client chain not configured. universalResolverAddress is required.");
-    return getChainContractAddress({
-      blockNumber,
-      chain,
-      contract: "ensUniversalResolver"
-    });
-  })();
-  const tlds = chain == null ? void 0 : chain.ensTlds;
-  if (tlds && !tlds.some((tld) => name.endsWith(tld)))
-    return null;
-  try {
-    const readContractParameters = {
-      address: universalResolverAddress,
-      abi: universalResolverResolveAbi,
-      args: [
-        toHex$1(packetToBytes(name)),
-        encodeFunctionData({
-          abi: textResolverAbi,
-          functionName: "text",
-          args: [namehash(name), key]
-        }),
-        gatewayUrls ?? [localBatchGatewayUrl]
-      ],
-      functionName: "resolveWithGateways",
-      blockNumber,
-      blockTag
-    };
-    const readContractAction = getAction(client, readContract, "readContract");
-    const res = await readContractAction(readContractParameters);
-    if (res[0] === "0x")
-      return null;
-    const record = decodeFunctionResult({
-      abi: textResolverAbi,
-      functionName: "text",
-      data: res[0]
-    });
-    return record === "" ? null : record;
-  } catch (err) {
-    if (strict)
-      throw err;
-    if (isNullUniversalResolverError(err))
-      return null;
-    throw err;
-  }
-}
-async function getEnsAvatar(client, { blockNumber, blockTag, assetGatewayUrls, name, gatewayUrls, strict, universalResolverAddress }) {
-  const record = await getAction(client, getEnsText, "getEnsText")({
-    blockNumber,
-    blockTag,
-    key: "avatar",
-    name,
-    universalResolverAddress,
-    gatewayUrls,
-    strict
-  });
-  if (!record)
-    return null;
-  try {
-    return await parseAvatarRecord(client, {
-      record,
-      gatewayUrls: assetGatewayUrls
-    });
-  } catch {
-    return null;
-  }
-}
-async function getEnsName(client, parameters) {
-  const { address, blockNumber, blockTag, coinType = 60n, gatewayUrls, strict } = parameters;
-  const { chain } = client;
-  const universalResolverAddress = (() => {
-    if (parameters.universalResolverAddress)
-      return parameters.universalResolverAddress;
-    if (!chain)
-      throw new Error("client chain not configured. universalResolverAddress is required.");
-    return getChainContractAddress({
-      blockNumber,
-      chain,
-      contract: "ensUniversalResolver"
-    });
-  })();
-  try {
-    const readContractParameters = {
-      address: universalResolverAddress,
-      abi: universalResolverReverseAbi,
-      args: [address, coinType, gatewayUrls ?? [localBatchGatewayUrl]],
-      functionName: "reverseWithGateways",
-      blockNumber,
-      blockTag
-    };
-    const readContractAction = getAction(client, readContract, "readContract");
-    const [name] = await readContractAction(readContractParameters);
-    return name || null;
-  } catch (err) {
-    if (strict)
-      throw err;
-    if (isNullUniversalResolverError(err))
-      return null;
-    throw err;
-  }
-}
-async function getEnsResolver(client, parameters) {
-  const { blockNumber, blockTag, name } = parameters;
-  const { chain } = client;
-  const universalResolverAddress = (() => {
-    if (parameters.universalResolverAddress)
-      return parameters.universalResolverAddress;
-    if (!chain)
-      throw new Error("client chain not configured. universalResolverAddress is required.");
-    return getChainContractAddress({
-      blockNumber,
-      chain,
-      contract: "ensUniversalResolver"
-    });
-  })();
-  const tlds = chain == null ? void 0 : chain.ensTlds;
-  if (tlds && !tlds.some((tld) => name.endsWith(tld)))
-    throw new Error(`${name} is not a valid ENS TLD (${tlds == null ? void 0 : tlds.join(", ")}) for chain "${chain.name}" (id: ${chain.id}).`);
-  const [resolverAddress] = await getAction(client, readContract, "readContract")({
-    address: universalResolverAddress,
-    abi: [
-      {
-        inputs: [{ type: "bytes" }],
-        name: "findResolver",
-        outputs: [
-          { type: "address" },
-          { type: "bytes32" },
-          { type: "uint256" }
-        ],
-        stateMutability: "view",
-        type: "function"
-      }
-    ],
-    functionName: "findResolver",
-    args: [toHex$1(packetToBytes(name))],
-    blockNumber,
-    blockTag
-  });
-  return resolverAddress;
-}
-async function createAccessList(client, args) {
-  var _a, _b, _c;
-  const { account: account_ = client.account, blockNumber, blockTag = "latest", blobs, data, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, to, value, ...rest } = args;
-  const account = account_ ? parseAccount(account_) : void 0;
-  try {
-    assertRequest(args);
-    const blockNumberHex = typeof blockNumber === "bigint" ? numberToHex(blockNumber) : void 0;
-    const block = blockNumberHex || blockTag;
-    const chainFormat = (_c = (_b = (_a = client.chain) == null ? void 0 : _a.formatters) == null ? void 0 : _b.transactionRequest) == null ? void 0 : _c.format;
-    const format = chainFormat || formatTransactionRequest;
-    const request = format({
-      // Pick out extra data that might exist on the chain's transaction request type.
-      ...extract$1(rest, { format: chainFormat }),
-      from: account == null ? void 0 : account.address,
-      blobs,
-      data,
-      gas,
-      gasPrice,
-      maxFeePerBlobGas,
-      maxFeePerGas,
-      maxPriorityFeePerGas,
-      to,
-      value
-    });
-    const response = await client.request({
-      method: "eth_createAccessList",
-      params: [request, block]
-    });
-    return {
-      accessList: response.accessList,
-      gasUsed: BigInt(response.gasUsed)
-    };
-  } catch (err) {
-    throw getCallError(err, {
-      ...args,
-      account,
-      chain: client.chain
-    });
-  }
-}
-async function createBlockFilter(client) {
-  const getRequest = createFilterRequestScope(client, {
-    method: "eth_newBlockFilter"
-  });
-  const id = await client.request({
-    method: "eth_newBlockFilter"
-  });
-  return { id, request: getRequest(id), type: "block" };
-}
-async function createEventFilter(client, { address, args, event, events: events_, fromBlock, strict, toBlock } = {}) {
-  const events = events_ ?? (event ? [event] : void 0);
-  const getRequest = createFilterRequestScope(client, {
-    method: "eth_newFilter"
-  });
-  let topics = [];
-  if (events) {
-    const encoded = events.flatMap((event2) => encodeEventTopics({
-      abi: [event2],
-      eventName: event2.name,
-      args
-    }));
-    topics = [encoded];
-    if (event)
-      topics = topics[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.length ? { topics } : {}
-      }
-    ]
-  });
-  return {
-    abi: events,
-    args,
-    eventName: event ? event.name : void 0,
-    fromBlock,
-    id,
-    request: getRequest(id),
-    strict: Boolean(strict),
-    toBlock,
-    type: "event"
-  };
-}
-async function getBlobBaseFee(client) {
-  const baseFee = await client.request({
-    method: "eth_blobBaseFee"
-  });
-  return BigInt(baseFee);
-}
-async function getBlockTransactionCount(client, { blockHash, blockNumber, blockTag = "latest" } = {}) {
-  const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
-  let count;
-  if (blockHash) {
-    count = await client.request({
-      method: "eth_getBlockTransactionCountByHash",
-      params: [blockHash]
-    }, { dedupe: true });
-  } else {
-    count = await client.request({
-      method: "eth_getBlockTransactionCountByNumber",
-      params: [blockNumberHex || blockTag]
-    }, { dedupe: Boolean(blockNumberHex) });
-  }
-  return hexToNumber(count);
-}
-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;
-}
-class Eip712DomainNotFoundError extends BaseError {
-  constructor({ address }) {
-    super(`No EIP-712 domain found on contract "${address}".`, {
-      metaMessages: [
-        "Ensure that:",
-        `- The contract is deployed at the address "${address}".`,
-        "- `eip712Domain()` function exists on the contract.",
-        "- `eip712Domain()` function matches signature to ERC-5267 specification."
-      ],
-      name: "Eip712DomainNotFoundError"
-    });
-  }
-}
-async function getEip712Domain(client, parameters) {
-  const { address, factory, factoryData } = parameters;
-  try {
-    const [fields, name, version, chainId, verifyingContract, salt, extensions] = await getAction(client, readContract, "readContract")({
-      abi,
-      address,
-      functionName: "eip712Domain",
-      factory,
-      factoryData
-    });
-    return {
-      domain: {
-        name,
-        version,
-        chainId: Number(chainId),
-        verifyingContract,
-        salt
-      },
-      extensions,
-      fields
-    };
-  } catch (e) {
-    const error = e;
-    if (error.name === "ContractFunctionExecutionError" && error.cause.name === "ContractFunctionZeroDataError") {
-      throw new Eip712DomainNotFoundError({ address });
-    }
-    throw error;
-  }
-}
-const abi = [
-  {
-    inputs: [],
-    name: "eip712Domain",
-    outputs: [
-      { name: "fields", type: "bytes1" },
-      { name: "name", type: "string" },
-      { name: "version", type: "string" },
-      { name: "chainId", type: "uint256" },
-      { name: "verifyingContract", type: "address" },
-      { name: "salt", type: "bytes32" },
-      { name: "extensions", type: "uint256[]" }
-    ],
-    stateMutability: "view",
-    type: "function"
-  }
-];
-function formatFeeHistory(feeHistory) {
-  var _a;
-  return {
-    baseFeePerGas: feeHistory.baseFeePerGas.map((value) => BigInt(value)),
-    gasUsedRatio: feeHistory.gasUsedRatio,
-    oldestBlock: BigInt(feeHistory.oldestBlock),
-    reward: (_a = feeHistory.reward) == null ? void 0 : _a.map((reward) => reward.map((value) => BigInt(value)))
-  };
-}
-async function getFeeHistory(client, { blockCount, blockNumber, blockTag = "latest", rewardPercentiles }) {
-  const blockNumberHex = typeof blockNumber === "bigint" ? numberToHex(blockNumber) : void 0;
-  const feeHistory = await client.request({
-    method: "eth_feeHistory",
-    params: [
-      numberToHex(blockCount),
-      blockNumberHex || blockTag,
-      rewardPercentiles
-    ]
-  }, { dedupe: Boolean(blockNumberHex) });
-  return formatFeeHistory(feeHistory);
-}
-async function getFilterLogs(_client, { filter }) {
-  const strict = filter.strict ?? false;
-  const logs = await filter.request({
-    method: "eth_getFilterLogs",
-    params: [filter.id]
-  });
-  const formattedLogs = logs.map((log) => formatLog(log));
-  if (!filter.abi)
-    return formattedLogs;
-  return parseEventLogs({
-    abi: filter.abi,
-    logs: formattedLogs,
-    strict
-  });
-}
-function encodePacked$1(types, values) {
-  if (types.length !== values.length)
-    throw new AbiEncodingLengthMismatchError({
-      expectedLength: types.length,
-      givenLength: values.length
-    });
-  const data = [];
-  for (let i = 0; i < types.length; i++) {
-    const type = types[i];
-    const value = values[i];
-    data.push(encode$3(type, value));
-  }
-  return concatHex(data);
-}
-function encode$3(type, value, isArray = false) {
-  if (type === "address") {
-    const address = value;
-    if (!isAddress(address))
-      throw new InvalidAddressError$1({ address });
-    return pad$1(address.toLowerCase(), {
-      size: isArray ? 32 : null
-    });
-  }
-  if (type === "string")
-    return stringToHex(value);
-  if (type === "bytes")
-    return value;
-  if (type === "bool")
-    return pad$1(boolToHex(value), { size: isArray ? 32 : 1 });
-  const intMatch = type.match(integerRegex$1);
-  if (intMatch) {
-    const [_type, baseType, bits = "256"] = intMatch;
-    const size2 = Number.parseInt(bits, 10) / 8;
-    return numberToHex(value, {
-      size: isArray ? 32 : size2,
-      signed: baseType === "int"
-    });
-  }
-  const bytesMatch = type.match(bytesRegex$1);
-  if (bytesMatch) {
-    const [_type, size2] = bytesMatch;
-    if (Number.parseInt(size2, 10) !== (value.length - 2) / 2)
-      throw new BytesSizeMismatchError$1({
-        expectedSize: Number.parseInt(size2, 10),
-        givenSize: (value.length - 2) / 2
-      });
-    return pad$1(value, { dir: "right", size: isArray ? 32 : null });
-  }
-  const arrayMatch = type.match(arrayRegex$1);
-  if (arrayMatch && Array.isArray(value)) {
-    const [_type, childType] = arrayMatch;
-    const data = [];
-    for (let i = 0; i < value.length; i++) {
-      data.push(encode$3(childType, value[i], true));
-    }
-    if (data.length === 0)
-      return "0x";
-    return concatHex(data);
-  }
-  throw new UnsupportedPackedAbiType(type);
-}
-async function verifyAuthorization({ address, authorization, signature }) {
-  return isAddressEqual(getAddress(address), await recoverAuthorizationAddress({
-    authorization,
-    signature
-  }));
-}
-function createNonceManager(parameters) {
-  const { source } = parameters;
-  const deltaMap = /* @__PURE__ */ new Map();
-  const nonceMap = new LruMap$1(8192);
-  const promiseMap = /* @__PURE__ */ new Map();
-  const getKey = ({ address, chainId }) => `${address}.${chainId}`;
-  return {
-    async consume({ address, chainId, client }) {
-      const key = getKey({ address, chainId });
-      const promise = this.get({ address, chainId, client });
-      this.increment({ address, chainId });
-      const nonce = await promise;
-      await source.set({ address, chainId }, nonce);
-      nonceMap.set(key, nonce);
-      return nonce;
-    },
-    async increment({ address, chainId }) {
-      const key = getKey({ address, chainId });
-      const delta = deltaMap.get(key) ?? 0;
-      deltaMap.set(key, delta + 1);
-    },
-    async get({ address, chainId, client }) {
-      const key = getKey({ address, chainId });
-      let promise = promiseMap.get(key);
-      if (!promise) {
-        promise = (async () => {
-          try {
-            const nonce = await source.get({ address, chainId, client });
-            const previousNonce = nonceMap.get(key) ?? 0;
-            if (previousNonce > 0 && nonce <= previousNonce)
-              return previousNonce + 1;
-            nonceMap.delete(key);
-            return nonce;
-          } finally {
-            this.reset({ address, chainId });
-          }
-        })();
-        promiseMap.set(key, promise);
-      }
-      const delta = deltaMap.get(key) ?? 0;
-      return delta + await promise;
-    },
-    reset({ address, chainId }) {
-      const key = getKey({ address, chainId });
-      deltaMap.delete(key);
-      promiseMap.delete(key);
-    }
-  };
-}
-function jsonRpc() {
-  return {
-    async get(parameters) {
-      const { address, client } = parameters;
-      return getTransactionCount(client, {
-        address,
-        blockTag: "pending"
-      });
-    },
-    set() {
-    }
-  };
-}
-const nonceManager = /* @__PURE__ */ createNonceManager({
-  source: jsonRpc()
-});
-function createIdStore() {
-  return {
-    current: 0,
-    take() {
-      return this.current++;
-    },
-    reset() {
-      this.current = 0;
-    }
-  };
-}
-const idCache = /* @__PURE__ */ createIdStore();
-function getHttpRpcClient(url, options = {}) {
-  return {
-    async request(params) {
-      var _a;
-      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((body2) => ({
-              jsonrpc: "2.0",
-              id: body2.id ?? idCache.take(),
-              ...body2
-            }))) : stringify$1({
-              jsonrpc: "2.0",
-              id: body.id ?? idCache.take(),
-              ...body
-            }),
-            headers: {
-              "Content-Type": "application/json",
-              ...headers
-            },
-            method: method || "POST",
-            signal: signal_ || (timeout > 0 ? signal : null)
-          };
-          const request = new Request(url, init);
-          const args = await (onRequest == null ? void 0 : onRequest(request, init)) ?? { ...init, url };
-          const response2 = await fetchFn(args.url ?? url, args);
-          return response2;
-        }, {
-          errorInstance: new TimeoutError({ body, url }),
-          timeout,
-          signal: true
-        });
-        if (onResponse)
-          await onResponse(response);
-        let data;
-        if ((_a = response.headers.get("Content-Type")) == null ? void 0 : _a.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) {
-          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
-        });
-      }
-    }
-  };
-}
-const erc6492MagicBytes = "0x6492649264926492649264926492649264926492649264926492649264926492";
-const zeroHash = "0x0000000000000000000000000000000000000000000000000000000000000000";
-class LruMap extends Map {
-  constructor(size2) {
-    super();
-    Object.defineProperty(this, "maxSize", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    this.maxSize = size2;
-  }
-  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 caches = {
-  checksum: /* @__PURE__ */ new LruMap(8192)
-};
-const checksum$1 = caches.checksum;
-function keccak256(value, options = {}) {
-  const { as = typeof value === "string" ? "Hex" : "Bytes" } = options;
-  const bytes = keccak_256(from$9(value));
-  if (as === "Bytes")
-    return bytes;
-  return fromBytes$2(bytes);
-}
-function assert$4(publicKey, options = {}) {
-  const { compressed } = options;
-  const { prefix, x, y } = publicKey;
-  if (compressed === false || typeof x === "bigint" && typeof y === "bigint") {
-    if (prefix !== 4)
-      throw new InvalidPrefixError({
-        prefix,
-        cause: new InvalidUncompressedPrefixError()
-      });
-    return;
-  }
-  if (compressed === true || typeof x === "bigint" && typeof y === "undefined") {
-    if (prefix !== 3 && prefix !== 2)
-      throw new InvalidPrefixError({
-        prefix,
-        cause: new InvalidCompressedPrefixError()
-      });
-    return;
-  }
-  throw new InvalidError({ publicKey });
-}
-function from$8(value) {
-  const publicKey = (() => {
-    if (validate$4(value))
-      return fromHex$2(value);
-    if (validate$3(value))
-      return fromBytes$1(value);
-    const { prefix, x, y } = value;
-    if (typeof x === "bigint" && typeof y === "bigint")
-      return { prefix: prefix ?? 4, x, y };
-    return { prefix, x };
-  })();
-  assert$4(publicKey);
-  return publicKey;
-}
-function fromBytes$1(publicKey) {
-  return fromHex$2(fromBytes$2(publicKey));
-}
-function fromHex$2(publicKey) {
-  if (publicKey.length !== 132 && publicKey.length !== 130 && publicKey.length !== 68)
-    throw new InvalidSerializedSizeError$1({ publicKey });
-  if (publicKey.length === 130) {
-    const x2 = BigInt(slice$1(publicKey, 0, 32));
-    const y = BigInt(slice$1(publicKey, 32, 64));
-    return {
-      prefix: 4,
-      x: x2,
-      y
-    };
-  }
-  if (publicKey.length === 132) {
-    const prefix2 = Number(slice$1(publicKey, 0, 1));
-    const x2 = BigInt(slice$1(publicKey, 1, 33));
-    const y = BigInt(slice$1(publicKey, 33, 65));
-    return {
-      prefix: prefix2,
-      x: x2,
-      y
-    };
-  }
-  const prefix = Number(slice$1(publicKey, 0, 1));
-  const x = BigInt(slice$1(publicKey, 1, 33));
-  return {
-    prefix,
-    x
-  };
-}
-function toHex(publicKey, options = {}) {
-  assert$4(publicKey);
-  const { prefix, x, y } = publicKey;
-  const { includePrefix = true } = options;
-  const publicKey_ = concat$1(
-    includePrefix ? fromNumber(prefix, { size: 1 }) : "0x",
-    fromNumber(x, { size: 32 }),
-    // If the public key is not compressed, add the y coordinate.
-    typeof y === "bigint" ? fromNumber(y, { size: 32 }) : "0x"
-  );
-  return publicKey_;
-}
-class InvalidError extends BaseError$1 {
-  constructor({ publicKey }) {
-    super(`Value \`${stringify(publicKey)}\` is not a valid public key.`, {
-      metaMessages: [
-        "Public key must contain:",
-        "- an `x` and `prefix` value (compressed)",
-        "- an `x`, `y`, and `prefix` value (uncompressed)"
-      ]
-    });
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "PublicKey.InvalidError"
-    });
-  }
-}
-class InvalidPrefixError extends BaseError$1 {
-  constructor({ prefix, cause }) {
-    super(`Prefix "${prefix}" is invalid.`, {
-      cause
-    });
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "PublicKey.InvalidPrefixError"
-    });
-  }
-}
-class InvalidCompressedPrefixError extends BaseError$1 {
-  constructor() {
-    super("Prefix must be 2 or 3 for compressed public keys.");
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "PublicKey.InvalidCompressedPrefixError"
-    });
-  }
-}
-class InvalidUncompressedPrefixError extends BaseError$1 {
-  constructor() {
-    super("Prefix must be 4 for uncompressed public keys.");
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "PublicKey.InvalidUncompressedPrefixError"
-    });
-  }
-}
-let InvalidSerializedSizeError$1 = class InvalidSerializedSizeError extends BaseError$1 {
-  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$1(from$a(publicKey))} bytes.`
-      ]
-    });
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "PublicKey.InvalidSerializedSizeError"
-    });
-  }
-};
-const addressRegex = /^0x[a-fA-F0-9]{40}$/;
-function assert$3(value, options = {}) {
-  const { strict = true } = options;
-  if (!addressRegex.test(value))
-    throw new InvalidAddressError({
-      address: value,
-      cause: new InvalidInputError()
-    });
-  if (strict) {
-    if (value.toLowerCase() === value)
-      return;
-    if (checksum(value) !== value)
-      throw new InvalidAddressError({
-        address: value,
-        cause: new InvalidChecksumError()
-      });
-  }
-}
-function checksum(address) {
-  if (checksum$1.has(address))
-    return checksum$1.get(address);
-  assert$3(address, { strict: false });
-  const hexAddress = address.substring(2).toLowerCase();
-  const hash2 = keccak256(fromString(hexAddress), { as: "Bytes" });
-  const characters = hexAddress.split("");
-  for (let i = 0; i < 40; i += 2) {
-    if (hash2[i >> 1] >> 4 >= 8 && characters[i]) {
-      characters[i] = characters[i].toUpperCase();
-    }
-    if ((hash2[i >> 1] & 15) >= 8 && characters[i + 1]) {
-      characters[i + 1] = characters[i + 1].toUpperCase();
-    }
-  }
-  const result = `0x${characters.join("")}`;
-  checksum$1.set(address, result);
-  return result;
-}
-function from$7(address, options = {}) {
-  const { checksum: checksumVal = false } = options;
-  assert$3(address);
-  if (checksumVal)
-    return checksum(address);
-  return address;
-}
-function fromPublicKey(publicKey, options = {}) {
-  const address = keccak256(`0x${toHex(publicKey).slice(4)}`).substring(26);
-  return from$7(`0x${address}`, options);
-}
-function validate$2(address, options = {}) {
-  const { strict = true } = options ?? {};
-  try {
-    assert$3(address, { strict });
-    return true;
-  } catch {
-    return false;
-  }
-}
-class InvalidAddressError extends BaseError$1 {
-  constructor({ address, cause }) {
-    super(`Address "${address}" is invalid.`, {
-      cause
-    });
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "Address.InvalidAddressError"
-    });
-  }
-}
-class InvalidInputError extends BaseError$1 {
-  constructor() {
-    super("Address is not a 20 byte (40 hexadecimal character) value.");
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "Address.InvalidInputError"
-    });
-  }
-}
-class InvalidChecksumError extends BaseError$1 {
-  constructor() {
-    super("Address does not match its checksum counterpart.");
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "Address.InvalidChecksumError"
-    });
-  }
-}
-const arrayRegex = /^(.*)\[([0-9]*)\]$/;
-const bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
-const integerRegex = /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
-const maxUint256 = 2n ** 256n - 1n;
-function decodeParameter(cursor, param, options) {
-  const { checksumAddress, staticPosition } = options;
-  const arrayComponents = getArrayComponents(param.type);
-  if (arrayComponents) {
-    const [length, type] = arrayComponents;
-    return decodeArray(cursor, { ...param, type }, { checksumAddress, length, staticPosition });
-  }
-  if (param.type === "tuple")
-    return decodeTuple(cursor, param, {
-      checksumAddress,
-      staticPosition
-    });
-  if (param.type === "address")
-    return decodeAddress(cursor, { checksum: checksumAddress });
-  if (param.type === "bool")
-    return decodeBool(cursor);
-  if (param.type.startsWith("bytes"))
-    return decodeBytes(cursor, param, { staticPosition });
-  if (param.type.startsWith("uint") || param.type.startsWith("int"))
-    return decodeNumber(cursor, param);
-  if (param.type === "string")
-    return decodeString(cursor, { staticPosition });
-  throw new InvalidTypeError(param.type);
-}
-const sizeOfLength = 32;
-const sizeOfOffset = 32;
-function decodeAddress(cursor, options = {}) {
-  const { checksum: checksum$12 = false } = options;
-  const value = cursor.readBytes(32);
-  const wrap2 = (address) => checksum$12 ? checksum(address) : address;
-  return [wrap2(fromBytes$2(slice(value, -20))), 32];
-}
-function decodeArray(cursor, param, options) {
-  const { checksumAddress, length, staticPosition } = options;
-  if (!length) {
-    const offset = toNumber(cursor.readBytes(sizeOfOffset));
-    const start = staticPosition + offset;
-    const startOfData = start + sizeOfLength;
-    cursor.setPosition(start);
-    const length2 = toNumber(cursor.readBytes(sizeOfLength));
-    const dynamicChild = hasDynamicChild(param);
-    let consumed2 = 0;
-    const value2 = [];
-    for (let i = 0; i < length2; ++i) {
-      cursor.setPosition(startOfData + (dynamicChild ? i * 32 : consumed2));
-      const [data, consumed_] = decodeParameter(cursor, param, {
-        checksumAddress,
-        staticPosition: startOfData
-      });
-      consumed2 += consumed_;
-      value2.push(data);
-    }
-    cursor.setPosition(staticPosition + 32);
-    return [value2, 32];
-  }
-  if (hasDynamicChild(param)) {
-    const offset = toNumber(cursor.readBytes(sizeOfOffset));
-    const start = staticPosition + offset;
-    const value2 = [];
-    for (let i = 0; i < length; ++i) {
-      cursor.setPosition(start + i * 32);
-      const [data] = decodeParameter(cursor, param, {
-        checksumAddress,
-        staticPosition: start
-      });
-      value2.push(data);
-    }
-    cursor.setPosition(staticPosition + 32);
-    return [value2, 32];
-  }
-  let consumed = 0;
-  const value = [];
-  for (let i = 0; i < length; ++i) {
-    const [data, consumed_] = decodeParameter(cursor, param, {
-      checksumAddress,
-      staticPosition: staticPosition + consumed
-    });
-    consumed += consumed_;
-    value.push(data);
-  }
-  return [value, consumed];
-}
-function decodeBool(cursor) {
-  return [toBoolean(cursor.readBytes(32), { size: 32 }), 32];
-}
-function decodeBytes(cursor, param, { staticPosition }) {
-  const [_, size2] = param.type.split("bytes");
-  if (!size2) {
-    const offset = toNumber(cursor.readBytes(32));
-    cursor.setPosition(staticPosition + offset);
-    const length = toNumber(cursor.readBytes(32));
-    if (length === 0) {
-      cursor.setPosition(staticPosition + 32);
-      return ["0x", 32];
-    }
-    const data = cursor.readBytes(length);
-    cursor.setPosition(staticPosition + 32);
-    return [fromBytes$2(data), 32];
-  }
-  const value = fromBytes$2(cursor.readBytes(Number.parseInt(size2, 10), 32));
-  return [value, 32];
-}
-function decodeNumber(cursor, param) {
-  const signed = param.type.startsWith("int");
-  const size2 = Number.parseInt(param.type.split("int")[1] || "256", 10);
-  const value = cursor.readBytes(32);
-  return [
-    size2 > 48 ? toBigInt(value, { signed }) : toNumber(value, { signed }),
-    32
-  ];
-}
-function decodeTuple(cursor, param, options) {
-  const { checksumAddress, staticPosition } = options;
-  const hasUnnamedChild = param.components.length === 0 || param.components.some(({ name }) => !name);
-  const value = hasUnnamedChild ? [] : {};
-  let consumed = 0;
-  if (hasDynamicChild(param)) {
-    const offset = toNumber(cursor.readBytes(sizeOfOffset));
-    const start = staticPosition + offset;
-    for (let i = 0; i < param.components.length; ++i) {
-      const component = param.components[i];
-      cursor.setPosition(start + consumed);
-      const [data, consumed_] = decodeParameter(cursor, component, {
-        checksumAddress,
-        staticPosition: start
-      });
-      consumed += consumed_;
-      value[hasUnnamedChild ? i : component == null ? void 0 : component.name] = data;
-    }
-    cursor.setPosition(staticPosition + 32);
-    return [value, 32];
-  }
-  for (let i = 0; i < param.components.length; ++i) {
-    const component = param.components[i];
-    const [data, consumed_] = decodeParameter(cursor, component, {
-      checksumAddress,
-      staticPosition
-    });
-    value[hasUnnamedChild ? i : component == null ? void 0 : component.name] = data;
-    consumed += consumed_;
-  }
-  return [value, consumed];
-}
-function decodeString(cursor, { staticPosition }) {
-  const offset = toNumber(cursor.readBytes(32));
-  const start = staticPosition + offset;
-  cursor.setPosition(start);
-  const length = toNumber(cursor.readBytes(32));
-  if (length === 0) {
-    cursor.setPosition(staticPosition + 32);
-    return ["", 32];
-  }
-  const data = cursor.readBytes(length, 32);
-  const value = toString(trimLeft(data));
-  cursor.setPosition(staticPosition + 32);
-  return [value, 32];
-}
-function prepareParameters({ checksumAddress, parameters, values }) {
-  const preparedParameters = [];
-  for (let i = 0; i < parameters.length; i++) {
-    preparedParameters.push(prepareParameter({
-      checksumAddress,
-      parameter: parameters[i],
-      value: values[i]
-    }));
-  }
-  return preparedParameters;
-}
-function prepareParameter({ checksumAddress = false, parameter: parameter_, value }) {
-  const parameter = parameter_;
-  const arrayComponents = getArrayComponents(parameter.type);
-  if (arrayComponents) {
-    const [length, type] = arrayComponents;
-    return encodeArray(value, {
-      checksumAddress,
-      length,
-      parameter: {
-        ...parameter,
-        type
-      }
-    });
-  }
-  if (parameter.type === "tuple") {
-    return encodeTuple(value, {
-      checksumAddress,
-      parameter
-    });
-  }
-  if (parameter.type === "address") {
-    return encodeAddress(value, {
-      checksum: checksumAddress
-    });
-  }
-  if (parameter.type === "bool") {
-    return encodeBoolean(value);
-  }
-  if (parameter.type.startsWith("uint") || parameter.type.startsWith("int")) {
-    const signed = parameter.type.startsWith("int");
-    const [, , size2 = "256"] = integerRegex.exec(parameter.type) ?? [];
-    return encodeNumber(value, {
-      signed,
-      size: Number(size2)
-    });
-  }
-  if (parameter.type.startsWith("bytes")) {
-    return encodeBytes(value, { type: parameter.type });
-  }
-  if (parameter.type === "string") {
-    return encodeString(value);
-  }
-  throw new InvalidTypeError(parameter.type);
-}
-function encode$2(preparedParameters) {
-  let staticSize = 0;
-  for (let i = 0; i < preparedParameters.length; i++) {
-    const { dynamic, encoded } = preparedParameters[i];
-    if (dynamic)
-      staticSize += 32;
-    else
-      staticSize += size$1(encoded);
-  }
-  const staticParameters = [];
-  const dynamicParameters = [];
-  let dynamicSize = 0;
-  for (let i = 0; i < preparedParameters.length; i++) {
-    const { dynamic, encoded } = preparedParameters[i];
-    if (dynamic) {
-      staticParameters.push(fromNumber(staticSize + dynamicSize, { size: 32 }));
-      dynamicParameters.push(encoded);
-      dynamicSize += size$1(encoded);
-    } else {
-      staticParameters.push(encoded);
-    }
-  }
-  return concat$1(...staticParameters, ...dynamicParameters);
-}
-function encodeAddress(value, options) {
-  const { checksum: checksum2 = false } = options;
-  assert$3(value, { strict: checksum2 });
-  return {
-    dynamic: false,
-    encoded: padLeft(value.toLowerCase())
-  };
-}
-function encodeArray(value, options) {
-  const { checksumAddress, length, parameter } = options;
-  const dynamic = length === null;
-  if (!Array.isArray(value))
-    throw new InvalidArrayError(value);
-  if (!dynamic && value.length !== length)
-    throw new ArrayLengthMismatchError({
-      expectedLength: length,
-      givenLength: value.length,
-      type: `${parameter.type}[${length}]`
-    });
-  let dynamicChild = false;
-  const preparedParameters = [];
-  for (let i = 0; i < value.length; i++) {
-    const preparedParam = prepareParameter({
-      checksumAddress,
-      parameter,
-      value: value[i]
-    });
-    if (preparedParam.dynamic)
-      dynamicChild = true;
-    preparedParameters.push(preparedParam);
-  }
-  if (dynamic || dynamicChild) {
-    const data = encode$2(preparedParameters);
-    if (dynamic) {
-      const length2 = fromNumber(preparedParameters.length, { size: 32 });
-      return {
-        dynamic: true,
-        encoded: preparedParameters.length > 0 ? concat$1(length2, data) : length2
-      };
-    }
-    if (dynamicChild)
-      return { dynamic: true, encoded: data };
-  }
-  return {
-    dynamic: false,
-    encoded: concat$1(...preparedParameters.map(({ encoded }) => encoded))
-  };
-}
-function encodeBytes(value, { type }) {
-  const [, parametersize] = type.split("bytes");
-  const bytesSize = size$1(value);
-  if (!parametersize) {
-    let value_ = value;
-    if (bytesSize % 32 !== 0)
-      value_ = padRight$1(value_, Math.ceil((value.length - 2) / 2 / 32) * 32);
-    return {
-      dynamic: true,
-      encoded: concat$1(padLeft(fromNumber(bytesSize, { size: 32 })), value_)
-    };
-  }
-  if (bytesSize !== Number.parseInt(parametersize, 10))
-    throw new BytesSizeMismatchError({
-      expectedSize: Number.parseInt(parametersize, 10),
-      value
-    });
-  return { dynamic: false, encoded: padRight$1(value) };
-}
-function encodeBoolean(value) {
-  if (typeof value !== "boolean")
-    throw new BaseError$1(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
-  return { dynamic: false, encoded: padLeft(fromBoolean(value)) };
-}
-function encodeNumber(value, { signed, size: size2 }) {
-  if (typeof size2 === "number") {
-    const max = 2n ** (BigInt(size2) - (signed ? 1n : 0n)) - 1n;
-    const min = signed ? -max - 1n : 0n;
-    if (value > max || value < min)
-      throw new IntegerOutOfRangeError({
-        max: max.toString(),
-        min: min.toString(),
-        signed,
-        size: size2 / 8,
-        value: value.toString()
-      });
-  }
-  return {
-    dynamic: false,
-    encoded: fromNumber(value, {
-      size: 32,
-      signed
-    })
-  };
-}
-function encodeString(value) {
-  const hexValue = fromString$1(value);
-  const partsLength = Math.ceil(size$1(hexValue) / 32);
-  const parts = [];
-  for (let i = 0; i < partsLength; i++) {
-    parts.push(padRight$1(slice$1(hexValue, i * 32, (i + 1) * 32)));
-  }
-  return {
-    dynamic: true,
-    encoded: concat$1(padRight$1(fromNumber(size$1(hexValue), { size: 32 })), ...parts)
-  };
-}
-function encodeTuple(value, options) {
-  const { checksumAddress, parameter } = options;
-  let dynamic = false;
-  const preparedParameters = [];
-  for (let i = 0; i < parameter.components.length; i++) {
-    const param_ = parameter.components[i];
-    const index = Array.isArray(value) ? i : param_.name;
-    const preparedParam = prepareParameter({
-      checksumAddress,
-      parameter: param_,
-      value: value[index]
-    });
-    preparedParameters.push(preparedParam);
-    if (preparedParam.dynamic)
-      dynamic = true;
-  }
-  return {
-    dynamic,
-    encoded: dynamic ? encode$2(preparedParameters) : concat$1(...preparedParameters.map(({ encoded }) => encoded))
-  };
-}
-function getArrayComponents(type) {
-  const matches = type.match(/^(.*)\[(\d+)?\]$/);
-  return matches ? (
-    // Return `null` if the array is dynamic.
-    [matches[2] ? Number(matches[2]) : null, matches[1]]
-  ) : void 0;
-}
-function hasDynamicChild(param) {
-  var _a;
-  const { type } = param;
-  if (type === "string")
-    return true;
-  if (type === "bytes")
-    return true;
-  if (type.endsWith("[]"))
-    return true;
-  if (type === "tuple")
-    return (_a = param.components) == null ? void 0 : _a.some(hasDynamicChild);
-  const arrayComponents = getArrayComponents(param.type);
-  if (arrayComponents && hasDynamicChild({
-    ...param,
-    type: arrayComponents[1]
-  }))
-    return true;
-  return false;
-}
-const staticCursor = {
-  bytes: new Uint8Array(),
-  dataView: new DataView(new ArrayBuffer(0)),
-  position: 0,
-  positionReadCount: /* @__PURE__ */ new Map(),
-  recursiveReadCount: 0,
-  recursiveReadLimit: Number.POSITIVE_INFINITY,
-  assertReadLimit() {
-    if (this.recursiveReadCount >= this.recursiveReadLimit)
-      throw new RecursiveReadLimitExceededError({
-        count: this.recursiveReadCount + 1,
-        limit: this.recursiveReadLimit
-      });
-  },
-  assertPosition(position) {
-    if (position < 0 || position > this.bytes.length - 1)
-      throw new PositionOutOfBoundsError({
-        length: this.bytes.length,
-        position
-      });
-  },
-  decrementPosition(offset) {
-    if (offset < 0)
-      throw new NegativeOffsetError({ offset });
-    const position = this.position - offset;
-    this.assertPosition(position);
-    this.position = position;
-  },
-  getReadCount(position) {
-    return this.positionReadCount.get(position || this.position) || 0;
-  },
-  incrementPosition(offset) {
-    if (offset < 0)
-      throw new NegativeOffsetError({ offset });
-    const position = this.position + offset;
-    this.assertPosition(position);
-    this.position = position;
-  },
-  inspectByte(position_) {
-    const position = position_ ?? this.position;
-    this.assertPosition(position);
-    return this.bytes[position];
-  },
-  inspectBytes(length, position_) {
-    const position = position_ ?? this.position;
-    this.assertPosition(position + length - 1);
-    return this.bytes.subarray(position, position + length);
-  },
-  inspectUint8(position_) {
-    const position = position_ ?? this.position;
-    this.assertPosition(position);
-    return this.bytes[position];
-  },
-  inspectUint16(position_) {
-    const position = position_ ?? this.position;
-    this.assertPosition(position + 1);
-    return this.dataView.getUint16(position);
-  },
-  inspectUint24(position_) {
-    const position = position_ ?? this.position;
-    this.assertPosition(position + 2);
-    return (this.dataView.getUint16(position) << 8) + this.dataView.getUint8(position + 2);
-  },
-  inspectUint32(position_) {
-    const position = position_ ?? this.position;
-    this.assertPosition(position + 3);
-    return this.dataView.getUint32(position);
-  },
-  pushByte(byte) {
-    this.assertPosition(this.position);
-    this.bytes[this.position] = byte;
-    this.position++;
-  },
-  pushBytes(bytes) {
-    this.assertPosition(this.position + bytes.length - 1);
-    this.bytes.set(bytes, this.position);
-    this.position += bytes.length;
-  },
-  pushUint8(value) {
-    this.assertPosition(this.position);
-    this.bytes[this.position] = value;
-    this.position++;
-  },
-  pushUint16(value) {
-    this.assertPosition(this.position + 1);
-    this.dataView.setUint16(this.position, value);
-    this.position += 2;
-  },
-  pushUint24(value) {
-    this.assertPosition(this.position + 2);
-    this.dataView.setUint16(this.position, value >> 8);
-    this.dataView.setUint8(this.position + 2, value & 255);
-    this.position += 3;
-  },
-  pushUint32(value) {
-    this.assertPosition(this.position + 3);
-    this.dataView.setUint32(this.position, value);
-    this.position += 4;
-  },
-  readByte() {
-    this.assertReadLimit();
-    this._touch();
-    const value = this.inspectByte();
-    this.position++;
-    return value;
-  },
-  readBytes(length, size2) {
-    this.assertReadLimit();
-    this._touch();
-    const value = this.inspectBytes(length);
-    this.position += size2 ?? length;
-    return value;
-  },
-  readUint8() {
-    this.assertReadLimit();
-    this._touch();
-    const value = this.inspectUint8();
-    this.position += 1;
-    return value;
-  },
-  readUint16() {
-    this.assertReadLimit();
-    this._touch();
-    const value = this.inspectUint16();
-    this.position += 2;
-    return value;
-  },
-  readUint24() {
-    this.assertReadLimit();
-    this._touch();
-    const value = this.inspectUint24();
-    this.position += 3;
-    return value;
-  },
-  readUint32() {
-    this.assertReadLimit();
-    this._touch();
-    const value = this.inspectUint32();
-    this.position += 4;
-    return value;
-  },
-  get remaining() {
-    return this.bytes.length - this.position;
-  },
-  setPosition(position) {
-    const oldPosition = this.position;
-    this.assertPosition(position);
-    this.position = position;
-    return () => this.position = oldPosition;
-  },
-  _touch() {
-    if (this.recursiveReadLimit === Number.POSITIVE_INFINITY)
-      return;
-    const count = this.getReadCount();
-    this.positionReadCount.set(this.position, count + 1);
-    if (count > 0)
-      this.recursiveReadCount++;
-  }
-};
-function create(bytes, { recursiveReadLimit = 8192 } = {}) {
-  const cursor = Object.create(staticCursor);
-  cursor.bytes = bytes;
-  cursor.dataView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  cursor.positionReadCount = /* @__PURE__ */ new Map();
-  cursor.recursiveReadLimit = recursiveReadLimit;
-  return cursor;
-}
-class NegativeOffsetError extends BaseError$1 {
-  constructor({ offset }) {
-    super(`Offset \`${offset}\` cannot be negative.`);
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "Cursor.NegativeOffsetError"
-    });
-  }
-}
-class PositionOutOfBoundsError extends BaseError$1 {
-  constructor({ length, position }) {
-    super(`Position \`${position}\` is out of bounds (\`0 < position < ${length}\`).`);
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "Cursor.PositionOutOfBoundsError"
-    });
-  }
-}
-class RecursiveReadLimitExceededError extends BaseError$1 {
-  constructor({ count, limit }) {
-    super(`Recursive read limit of \`${limit}\` exceeded (recursive read count: \`${count}\`).`);
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "Cursor.RecursiveReadLimitExceededError"
-    });
-  }
-}
-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(bytes) === 0 && parameters.length > 0)
-    throw new ZeroDataError();
-  if (size(bytes) && size(bytes) < 32)
-    throw new DataSizeTooSmallError({
-      data: typeof data === "string" ? data : fromBytes$2(data),
-      parameters,
-      size: size(bytes)
-    });
-  let consumed = 0;
-  const values = as === "Array" ? [] : {};
-  for (let i = 0; i < parameters.length; ++i) {
-    const param = parameters[i];
-    cursor.setPosition(consumed);
-    const [data2, consumed_] = decodeParameter(cursor, param, {
-      checksumAddress,
-      staticPosition: 0
-    });
-    consumed += consumed_;
-    if (as === "Array")
-      values.push(data2);
-    else
-      values[param.name ?? i] = data2;
-  }
-  return values;
-}
-function encode$1(parameters, values, options) {
-  const { checksumAddress = false } = {};
-  if (parameters.length !== values.length)
-    throw new LengthMismatchError({
-      expectedLength: parameters.length,
-      givenLength: values.length
-    });
-  const preparedParameters = prepareParameters({
-    checksumAddress,
-    parameters,
-    values
-  });
-  const data = encode$2(preparedParameters);
-  if (data.length === 0)
-    return "0x";
-  return data;
-}
-function encodePacked(types, values) {
-  if (types.length !== values.length)
-    throw new LengthMismatchError({
-      expectedLength: types.length,
-      givenLength: values.length
-    });
-  const data = [];
-  for (let i = 0; i < types.length; i++) {
-    const type = types[i];
-    const value = values[i];
-    data.push(encodePacked.encode(type, value));
-  }
-  return concat$1(...data);
-}
-(function(encodePacked2) {
-  function encode2(type, value, isArray = false) {
-    if (type === "address") {
-      const address = value;
-      assert$3(address);
-      return padLeft(address.toLowerCase(), isArray ? 32 : 0);
-    }
-    if (type === "string")
-      return fromString$1(value);
-    if (type === "bytes")
-      return value;
-    if (type === "bool")
-      return padLeft(fromBoolean(value), isArray ? 32 : 1);
-    const intMatch = type.match(integerRegex);
-    if (intMatch) {
-      const [_type, baseType, bits = "256"] = intMatch;
-      const size2 = Number.parseInt(bits, 10) / 8;
-      return fromNumber(value, {
-        size: isArray ? 32 : size2,
-        signed: baseType === "int"
-      });
-    }
-    const bytesMatch = type.match(bytesRegex);
-    if (bytesMatch) {
-      const [_type, size2] = bytesMatch;
-      if (Number.parseInt(size2, 10) !== (value.length - 2) / 2)
-        throw new BytesSizeMismatchError({
-          expectedSize: Number.parseInt(size2, 10),
-          value
-        });
-      return padRight$1(value, isArray ? 32 : 0);
-    }
-    const arrayMatch = type.match(arrayRegex);
-    if (arrayMatch && Array.isArray(value)) {
-      const [_type, childType] = arrayMatch;
-      const data = [];
-      for (let i = 0; i < value.length; i++) {
-        data.push(encode2(childType, value[i], true));
-      }
-      if (data.length === 0)
-        return "0x";
-      return concat$1(...data);
-    }
-    throw new InvalidTypeError(type);
-  }
-  encodePacked2.encode = encode2;
-})(encodePacked || (encodePacked = {}));
-function from$6(parameters) {
-  if (Array.isArray(parameters) && typeof parameters[0] === "string")
-    return parseAbiParameters(parameters);
-  if (typeof parameters === "string")
-    return parseAbiParameters(parameters);
-  return parameters;
-}
-class DataSizeTooSmallError extends BaseError$1 {
-  constructor({ data, parameters, size: size2 }) {
-    super(`Data size of ${size2} bytes is too small for given parameters.`, {
-      metaMessages: [
-        `Params: (${formatAbiParameters(parameters)})`,
-        `Data:   ${data} (${size2} bytes)`
-      ]
-    });
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "AbiParameters.DataSizeTooSmallError"
-    });
-  }
-}
-class ZeroDataError extends BaseError$1 {
-  constructor() {
-    super('Cannot decode zero data ("0x") with ABI parameters.');
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "AbiParameters.ZeroDataError"
-    });
-  }
-}
-class ArrayLengthMismatchError extends BaseError$1 {
-  constructor({ expectedLength, givenLength, type }) {
-    super(`Array length mismatch for type \`${type}\`. Expected: \`${expectedLength}\`. Given: \`${givenLength}\`.`);
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "AbiParameters.ArrayLengthMismatchError"
-    });
-  }
-}
-class BytesSizeMismatchError extends BaseError$1 {
-  constructor({ expectedSize, value }) {
-    super(`Size of bytes "${value}" (bytes${size$1(value)}) does not match expected size (bytes${expectedSize}).`);
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "AbiParameters.BytesSizeMismatchError"
-    });
-  }
-}
-class LengthMismatchError extends BaseError$1 {
-  constructor({ expectedLength, givenLength }) {
-    super([
-      "ABI encoding parameters/values length mismatch.",
-      `Expected length (parameters): ${expectedLength}`,
-      `Given length (values): ${givenLength}`
-    ].join("\n"));
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "AbiParameters.LengthMismatchError"
-    });
-  }
-}
-class InvalidArrayError extends BaseError$1 {
-  constructor(value) {
-    super(`Value \`${value}\` is not a valid array.`);
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "AbiParameters.InvalidArrayError"
-    });
-  }
-}
-class InvalidTypeError extends BaseError$1 {
-  constructor(type) {
-    super(`Type \`${type}\` is not a valid ABI Type.`);
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "AbiParameters.InvalidTypeError"
-    });
-  }
-}
-function from$5(value, options) {
-  const { as } = options;
-  const encodable = getEncodable(value);
-  const cursor = create(new Uint8Array(encodable.length));
-  encodable.encode(cursor);
-  if (as === "Hex")
-    return fromBytes$2(cursor.bytes);
-  return cursor.bytes;
-}
-function fromHex$1(hex, options = {}) {
-  const { as = "Hex" } = options;
-  return from$5(hex, { as });
-}
-function getEncodable(bytes) {
-  if (Array.isArray(bytes))
-    return getEncodableList(bytes.map((x) => getEncodable(x)));
-  return getEncodableBytes(bytes);
-}
-function getEncodableList(list) {
-  const bodyLength = list.reduce((acc, x) => acc + x.length, 0);
-  const sizeOfBodyLength = getSizeOfLength(bodyLength);
-  const length = (() => {
-    if (bodyLength <= 55)
-      return 1 + bodyLength;
-    return 1 + sizeOfBodyLength + bodyLength;
-  })();
-  return {
-    length,
-    encode(cursor) {
-      if (bodyLength <= 55) {
-        cursor.pushByte(192 + bodyLength);
-      } else {
-        cursor.pushByte(192 + 55 + sizeOfBodyLength);
-        if (sizeOfBodyLength === 1)
-          cursor.pushUint8(bodyLength);
-        else if (sizeOfBodyLength === 2)
-          cursor.pushUint16(bodyLength);
-        else if (sizeOfBodyLength === 3)
-          cursor.pushUint24(bodyLength);
-        else
-          cursor.pushUint32(bodyLength);
-      }
-      for (const { encode: encode2 } of list) {
-        encode2(cursor);
-      }
-    }
-  };
-}
-function getEncodableBytes(bytesOrHex) {
-  const bytes = typeof bytesOrHex === "string" ? fromHex$3(bytesOrHex) : bytesOrHex;
-  const sizeOfBytesLength = getSizeOfLength(bytes.length);
-  const length = (() => {
-    if (bytes.length === 1 && bytes[0] < 128)
-      return 1;
-    if (bytes.length <= 55)
-      return 1 + bytes.length;
-    return 1 + sizeOfBytesLength + bytes.length;
-  })();
-  return {
-    length,
-    encode(cursor) {
-      if (bytes.length === 1 && bytes[0] < 128) {
-        cursor.pushBytes(bytes);
-      } else if (bytes.length <= 55) {
-        cursor.pushByte(128 + bytes.length);
-        cursor.pushBytes(bytes);
-      } else {
-        cursor.pushByte(128 + 55 + sizeOfBytesLength);
-        if (sizeOfBytesLength === 1)
-          cursor.pushUint8(bytes.length);
-        else if (sizeOfBytesLength === 2)
-          cursor.pushUint16(bytes.length);
-        else if (sizeOfBytesLength === 3)
-          cursor.pushUint24(bytes.length);
-        else
-          cursor.pushUint32(bytes.length);
-        cursor.pushBytes(bytes);
-      }
-    }
-  };
-}
-function getSizeOfLength(length) {
-  if (length < 2 ** 8)
-    return 1;
-  if (length < 2 ** 16)
-    return 2;
-  if (length < 2 ** 24)
-    return 3;
-  if (length < 2 ** 32)
-    return 4;
-  throw new BaseError$1("Length is too large.");
-}
-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 });
-  if (recovered && typeof signature.yParity === "undefined")
-    throw new MissingPropertiesError({ signature });
-  if (signature.r < 0n || signature.r > maxUint256)
-    throw new InvalidRError({ value: signature.r });
-  if (signature.s < 0n || signature.s > maxUint256)
-    throw new InvalidSError({ value: signature.s });
-  if (typeof signature.yParity === "number" && signature.yParity !== 0 && signature.yParity !== 1)
-    throw new InvalidYParityError({ value: signature.yParity });
-}
-function fromBytes(signature) {
-  return fromHex(fromBytes$2(signature));
-}
-function fromHex(signature) {
-  if (signature.length !== 130 && signature.length !== 132)
-    throw new InvalidSerializedSizeError2({ signature });
-  const r = BigInt(slice$1(signature, 0, 32));
-  const s = BigInt(slice$1(signature, 32, 64));
-  const yParity = (() => {
-    const yParity2 = Number(`0x${signature.slice(130)}`);
-    if (Number.isNaN(yParity2))
-      return void 0;
-    try {
-      return vToYParity(yParity2);
-    } catch {
-      throw new InvalidYParityError({ value: yParity2 });
-    }
-  })();
-  if (typeof yParity === "undefined")
-    return {
-      r,
-      s
-    };
-  return {
-    r,
-    s,
-    yParity
-  };
-}
-function extract(value) {
-  if (typeof value.r === "undefined")
-    return void 0;
-  if (typeof value.s === "undefined")
-    return void 0;
-  return from$4(value);
-}
-function from$4(signature) {
-  const signature_ = (() => {
-    if (typeof signature === "string")
-      return fromHex(signature);
-    if (signature instanceof Uint8Array)
-      return fromBytes(signature);
-    if (typeof signature.r === "string")
-      return fromRpc$1(signature);
-    if (signature.v)
-      return fromLegacy(signature);
-    return {
-      r: signature.r,
-      s: signature.s,
-      ...typeof signature.yParity !== "undefined" ? { yParity: signature.yParity } : {}
-    };
-  })();
-  assert$2(signature_);
-  return signature_;
-}
-function fromLegacy(signature) {
-  return {
-    r: signature.r,
-    s: signature.s,
-    yParity: vToYParity(signature.v)
-  };
-}
-function fromRpc$1(signature) {
-  const yParity = (() => {
-    const v = signature.v ? Number(signature.v) : void 0;
-    let yParity2 = signature.yParity ? Number(signature.yParity) : void 0;
-    if (typeof v === "number" && typeof yParity2 !== "number")
-      yParity2 = vToYParity(v);
-    if (typeof yParity2 !== "number")
-      throw new InvalidYParityError({ value: signature.yParity });
-    return yParity2;
-  })();
-  return {
-    r: BigInt(signature.r),
-    s: BigInt(signature.s),
-    yParity
-  };
-}
-function toTuple$1(signature) {
-  const { r, s, yParity } = signature;
-  return [
-    yParity ? "0x01" : "0x",
-    r === 0n ? "0x" : trimLeft$1(fromNumber(r)),
-    s === 0n ? "0x" : trimLeft$1(fromNumber(s))
-  ];
-}
-function vToYParity(v) {
-  if (v === 0 || v === 27)
-    return 0;
-  if (v === 1 || v === 28)
-    return 1;
-  if (v >= 35)
-    return v % 2 === 0 ? 1 : 0;
-  throw new InvalidVError({ value: v });
-}
-class InvalidSerializedSizeError2 extends BaseError$1 {
-  constructor({ signature }) {
-    super(`Value \`${signature}\` is an invalid signature size.`, {
-      metaMessages: [
-        "Expected: 64 bytes or 65 bytes.",
-        `Received ${size$1(from$a(signature))} bytes.`
-      ]
-    });
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "Signature.InvalidSerializedSizeError"
-    });
-  }
-}
-class MissingPropertiesError extends BaseError$1 {
-  constructor({ signature }) {
-    super(`Signature \`${stringify(signature)}\` is missing either an \`r\`, \`s\`, or \`yParity\` property.`);
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "Signature.MissingPropertiesError"
-    });
-  }
-}
-class InvalidRError extends BaseError$1 {
-  constructor({ value }) {
-    super(`Value \`${value}\` is an invalid r value. r must be a positive integer less than 2^256.`);
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "Signature.InvalidRError"
-    });
-  }
-}
-class InvalidSError extends BaseError$1 {
-  constructor({ value }) {
-    super(`Value \`${value}\` is an invalid s value. s must be a positive integer less than 2^256.`);
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "Signature.InvalidSError"
-    });
-  }
-}
-class InvalidYParityError extends BaseError$1 {
-  constructor({ value }) {
-    super(`Value \`${value}\` is an invalid y-parity value. Y-parity must be 0 or 1.`);
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "Signature.InvalidYParityError"
-    });
-  }
-}
-class InvalidVError extends BaseError$1 {
-  constructor({ value }) {
-    super(`Value \`${value}\` is an invalid v value. v must be 27, 28 or >=35.`);
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "Signature.InvalidVError"
-    });
-  }
-}
-function from$3(authorization, options = {}) {
-  if (typeof authorization.chainId === "string")
-    return fromRpc(authorization);
-  return { ...authorization, ...options.signature };
-}
-function fromRpc(authorization) {
-  const { address, chainId, nonce } = authorization;
-  const signature = extract(authorization);
-  return {
-    address,
-    chainId: Number(chainId),
-    nonce: BigInt(nonce),
-    ...signature
-  };
-}
-function getSignPayload(authorization) {
-  return hash(authorization, { presign: true });
-}
-function hash(authorization, options = {}) {
-  const { presign } = options;
-  return keccak256(concat$1("0x05", fromHex$1(toTuple(presign ? {
-    address: authorization.address,
-    chainId: authorization.chainId,
-    nonce: authorization.nonce
-  } : authorization))));
-}
-function toTuple(authorization) {
-  const { address, chainId, nonce } = authorization;
-  const signature = extract(authorization);
-  return [
-    chainId ? fromNumber(chainId) : "0x",
-    address,
-    nonce ? fromNumber(nonce) : "0x",
-    ...signature ? toTuple$1(signature) : []
-  ];
-}
-function recoverAddress(options) {
-  return fromPublicKey(recoverPublicKey(options));
-}
-function recoverPublicKey(options) {
-  const { payload, signature } = options;
-  const { r, s, yParity } = signature;
-  const signature_ = new secp256k1.Signature(BigInt(r), BigInt(s)).addRecoveryBit(yParity);
-  const point = signature_.recoverPublicKey(from$a(payload).substring(2));
-  return from$8(point);
-}
-const magicBytes$1 = "0x8010801080108010801080108010801080108010801080108010801080108010";
-const suffixParameters = from$6("(uint256 chainId, address delegation, uint256 nonce, uint8 yParity, uint256 r, uint256 s), address to, bytes data");
-function assert$1(value) {
-  if (typeof value === "string") {
-    if (slice$1(value, -32) !== magicBytes$1)
-      throw new InvalidWrappedSignatureError$1(value);
-  } else
-    assert$2(value.authorization);
-}
-function unwrap(wrapped) {
-  assert$1(wrapped);
-  const suffixLength = toNumber$1(slice$1(wrapped, -64, -32));
-  const suffix = slice$1(wrapped, -suffixLength - 64, -64);
-  const signature = slice$1(wrapped, 0, -suffixLength - 64);
-  const [auth, to, data] = decode(suffixParameters, suffix);
-  const authorization = from$3({
-    address: auth.delegation,
-    chainId: Number(auth.chainId),
-    nonce: auth.nonce,
-    yParity: auth.yParity,
-    r: auth.r,
-    s: auth.s
-  });
-  return {
-    authorization,
-    signature,
-    ...data && data !== "0x" ? { data, to } : {}
-  };
-}
-function wrap$1(value) {
-  const { data, signature } = value;
-  assert$1(value);
-  const self = recoverAddress({
-    payload: getSignPayload(value.authorization),
-    signature: from$4(value.authorization)
-  });
-  const suffix = encode$1(suffixParameters, [
-    {
-      ...value.authorization,
-      delegation: value.authorization.address,
-      chainId: BigInt(value.authorization.chainId)
-    },
-    value.to ?? self,
-    data ?? "0x"
-  ]);
-  const suffixLength = fromNumber(size$1(suffix), { size: 32 });
-  return concat$1(signature, suffix, suffixLength, magicBytes$1);
-}
-function validate$1(value) {
-  try {
-    assert$1(value);
-    return true;
-  } catch {
-    return false;
-  }
-}
-let InvalidWrappedSignatureError$1 = class InvalidWrappedSignatureError extends BaseError$1 {
-  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"
-    });
-  }
-};
-function serializeErc6492Signature(parameters) {
-  const { address, data, signature, to = "hex" } = parameters;
-  const signature_ = concatHex([
-    encodeAbiParameters([{ type: "address" }, { type: "bytes" }, { type: "bytes" }], [address, data, signature]),
-    erc6492MagicBytes
-  ]);
-  if (to === "hex")
-    return signature_;
-  return hexToBytes(signature_);
-}
-function formatStorageProof(storageProof) {
-  return storageProof.map((proof) => ({
-    ...proof,
-    value: BigInt(proof.value)
-  }));
-}
-function formatProof(proof) {
-  return {
-    ...proof,
-    balance: proof.balance ? BigInt(proof.balance) : void 0,
-    nonce: proof.nonce ? hexToNumber(proof.nonce) : void 0,
-    storageProof: proof.storageProof ? formatStorageProof(proof.storageProof) : void 0
-  };
-}
-async function getProof(client, { address, blockNumber, blockTag: blockTag_, storageKeys }) {
-  const blockTag = blockTag_ ?? "latest";
-  const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
-  const proof = await client.request({
-    method: "eth_getProof",
-    params: [address, storageKeys, blockNumberHex || blockTag]
-  });
-  return formatProof(proof);
-}
-async function getStorageAt(client, { address, blockNumber, blockTag = "latest", slot }) {
-  const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
-  const data = await client.request({
-    method: "eth_getStorageAt",
-    params: [address, slot, blockNumberHex || blockTag]
-  });
-  return data;
-}
-async function getTransactionConfirmations(client, { hash: hash2, transactionReceipt }) {
-  const [blockNumber, transaction] = await Promise.all([
-    getAction(client, getBlockNumber, "getBlockNumber")({}),
-    hash2 ? getAction(client, getTransaction, "getTransaction")({ hash: hash2 }) : void 0
-  ]);
-  const transactionBlockNumber = (transactionReceipt == null ? void 0 : transactionReceipt.blockNumber) || (transaction == null ? void 0 : transaction.blockNumber);
-  if (!transactionBlockNumber)
-    return 0n;
-  return blockNumber - transactionBlockNumber + 1n;
-}
-async function simulateBlocks(client, parameters) {
-  const { blockNumber, blockTag = client.experimental_blockTag ?? "latest", blocks, returnFullTransactions, traceTransfers, validation } = parameters;
-  try {
-    const blockStateCalls = [];
-    for (const block2 of blocks) {
-      const blockOverrides = block2.blockOverrides ? toRpc(block2.blockOverrides) : void 0;
-      const calls = block2.calls.map((call_) => {
-        const call2 = call_;
-        const account = call2.account ? parseAccount(call2.account) : void 0;
-        const data = call2.abi ? encodeFunctionData(call2) : call2.data;
-        const request = {
-          ...call2,
-          data: call2.dataSuffix ? concat([data || "0x", call2.dataSuffix]) : data,
-          from: call2.from ?? (account == null ? void 0 : account.address)
-        };
-        assertRequest(request);
-        return formatTransactionRequest(request);
-      });
-      const stateOverrides = block2.stateOverrides ? serializeStateOverride(block2.stateOverrides) : void 0;
-      blockStateCalls.push({
-        blockOverrides,
-        calls,
-        stateOverrides
-      });
-    }
-    const blockNumberHex = typeof blockNumber === "bigint" ? numberToHex(blockNumber) : void 0;
-    const block = blockNumberHex || blockTag;
-    const result = await client.request({
-      method: "eth_simulateV1",
-      params: [
-        { blockStateCalls, returnFullTransactions, traceTransfers, validation },
-        block
-      ]
-    });
-    return result.map((block2, i) => ({
-      ...formatBlock(block2),
-      calls: block2.calls.map((call2, j) => {
-        var _a, _b;
-        const { abi: abi2, args, functionName, to } = blocks[i].calls[j];
-        const data = ((_a = call2.error) == null ? void 0 : _a.data) ?? call2.returnData;
-        const gasUsed = BigInt(call2.gasUsed);
-        const logs = (_b = call2.logs) == null ? void 0 : _b.map((log) => formatLog(log));
-        const status = call2.status === "0x1" ? "success" : "failure";
-        const result2 = abi2 && status === "success" && data !== "0x" ? decodeFunctionResult({
-          abi: abi2,
-          data,
-          functionName
-        }) : null;
-        const error = (() => {
-          var _a2;
-          if (status === "success")
-            return void 0;
-          let error2;
-          if (((_a2 = call2.error) == null ? void 0 : _a2.data) === "0x")
-            error2 = new AbiDecodingZeroDataError();
-          else if (call2.error)
-            error2 = new RawContractError(call2.error);
-          if (!error2)
-            return void 0;
-          return getContractError(error2, {
-            abi: abi2 ?? [],
-            address: to ?? "0x",
-            args,
-            functionName: functionName ?? "<unknown>"
-          });
-        })();
-        return {
-          data,
-          gasUsed,
-          logs,
-          status,
-          ...status === "success" ? {
-            result: result2
-          } : {
-            error
-          }
-        };
-      })
-    }));
-  } catch (e) {
-    const cause = e;
-    const error = getNodeError(cause, {});
-    if (error instanceof UnknownNodeError)
-      throw cause;
-    throw error;
-  }
-}
-function normalizeSignature(signature) {
-  let active = true;
-  let current = "";
-  let level = 0;
-  let result = "";
-  let valid = false;
-  for (let i = 0; i < signature.length; i++) {
-    const char = signature[i];
-    if (["(", ")", ","].includes(char))
-      active = true;
-    if (char === "(")
-      level++;
-    if (char === ")")
-      level--;
-    if (!active)
-      continue;
-    if (level === 0) {
-      if (char === " " && ["event", "function", "error", ""].includes(result))
-        result = "";
-      else {
-        result += char;
-        if (char === ")") {
-          valid = true;
-          break;
-        }
-      }
-      continue;
-    }
-    if (char === " ") {
-      if (signature[i - 1] !== "," && current !== "," && current !== ",(") {
-        current = "";
-        active = false;
-      }
-      continue;
-    }
-    result += char;
-    current += char;
-  }
-  if (!valid)
-    throw new BaseError$1("Unable to normalize signature.");
-  return result;
-}
-function isArgOfType(arg, abiParameter) {
-  const argType = typeof arg;
-  const abiParameterType = abiParameter.type;
-  switch (abiParameterType) {
-    case "address":
-      return validate$2(arg, { strict: false });
-    case "bool":
-      return argType === "boolean";
-    case "function":
-      return argType === "string";
-    case "string":
-      return argType === "string";
-    default: {
-      if (abiParameterType === "tuple" && "components" in abiParameter)
-        return Object.values(abiParameter.components).every((component, index) => {
-          return isArgOfType(Object.values(arg)[index], component);
-        });
-      if (/^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/.test(abiParameterType))
-        return argType === "number" || argType === "bigint";
-      if (/^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/.test(abiParameterType))
-        return argType === "string" || arg instanceof Uint8Array;
-      if (/[a-z]+[1-9]{0,3}(\[[0-9]{0,}\])+$/.test(abiParameterType)) {
-        return Array.isArray(arg) && arg.every((x) => isArgOfType(x, {
-          ...abiParameter,
-          // Pop off `[]` or `[M]` from end of type
-          type: abiParameterType.replace(/(\[[0-9]{0,}\])$/, "")
-        }));
-      }
-      return false;
-    }
-  }
-}
-function getAmbiguousTypes(sourceParameters, targetParameters, args) {
-  for (const parameterIndex in sourceParameters) {
-    const sourceParameter = sourceParameters[parameterIndex];
-    const targetParameter = targetParameters[parameterIndex];
-    if (sourceParameter.type === "tuple" && targetParameter.type === "tuple" && "components" in sourceParameter && "components" in targetParameter)
-      return getAmbiguousTypes(sourceParameter.components, targetParameter.components, args[parameterIndex]);
-    const types = [sourceParameter.type, targetParameter.type];
-    const ambiguous = (() => {
-      if (types.includes("address") && types.includes("bytes20"))
-        return true;
-      if (types.includes("address") && types.includes("string"))
-        return validate$2(args[parameterIndex], {
-          strict: false
-        });
-      if (types.includes("address") && types.includes("bytes"))
-        return validate$2(args[parameterIndex], {
-          strict: false
-        });
-      return false;
-    })();
-    if (ambiguous)
-      return types;
-  }
-  return;
-}
-function from$2(abiItem, options = {}) {
-  const { prepare = true } = options;
-  const item = (() => {
-    if (Array.isArray(abiItem))
-      return parseAbiItem(abiItem);
-    if (typeof abiItem === "string")
-      return parseAbiItem(abiItem);
-    return abiItem;
-  })();
-  return {
-    ...item,
-    ...prepare ? { hash: getSignatureHash(item) } : {}
-  };
-}
-function fromAbi$2(abi2, name, options) {
-  const { args = [], prepare = true } = options ?? {};
-  const isSelector = validate$4(name, { strict: false });
-  const abiItems = abi2.filter((abiItem2) => {
-    if (isSelector) {
-      if (abiItem2.type === "function" || abiItem2.type === "error")
-        return getSelector$1(abiItem2) === slice$1(name, 0, 4);
-      if (abiItem2.type === "event")
-        return getSignatureHash(abiItem2) === name;
-      return false;
-    }
-    return "name" in abiItem2 && abiItem2.name === name;
-  });
-  if (abiItems.length === 0)
-    throw new NotFoundError({ name });
-  if (abiItems.length === 1)
-    return {
-      ...abiItems[0],
-      ...prepare ? { hash: getSignatureHash(abiItems[0]) } : {}
-    };
-  let matchedAbiItem;
-  for (const abiItem2 of abiItems) {
-    if (!("inputs" in abiItem2))
-      continue;
-    if (!args || args.length === 0) {
-      if (!abiItem2.inputs || abiItem2.inputs.length === 0)
-        return {
-          ...abiItem2,
-          ...prepare ? { hash: getSignatureHash(abiItem2) } : {}
-        };
-      continue;
-    }
-    if (!abiItem2.inputs)
-      continue;
-    if (abiItem2.inputs.length === 0)
-      continue;
-    if (abiItem2.inputs.length !== args.length)
-      continue;
-    const matched = args.every((arg, index) => {
-      const abiParameter = "inputs" in abiItem2 && abiItem2.inputs[index];
-      if (!abiParameter)
-        return false;
-      return isArgOfType(arg, abiParameter);
-    });
-    if (matched) {
-      if (matchedAbiItem && "inputs" in matchedAbiItem && matchedAbiItem.inputs) {
-        const ambiguousTypes = getAmbiguousTypes(abiItem2.inputs, matchedAbiItem.inputs, args);
-        if (ambiguousTypes)
-          throw new AmbiguityError({
-            abiItem: abiItem2,
-            type: ambiguousTypes[0]
-          }, {
-            abiItem: matchedAbiItem,
-            type: ambiguousTypes[1]
-          });
-      }
-      matchedAbiItem = abiItem2;
-    }
-  }
-  const abiItem = (() => {
-    if (matchedAbiItem)
-      return matchedAbiItem;
-    const [abiItem2, ...overloads] = abiItems;
-    return { ...abiItem2, overloads };
-  })();
-  if (!abiItem)
-    throw new NotFoundError({ name });
-  return {
-    ...abiItem,
-    ...prepare ? { hash: getSignatureHash(abiItem) } : {}
-  };
-}
-function getSelector$1(...parameters) {
-  const abiItem = (() => {
-    if (Array.isArray(parameters[0])) {
-      const [abi2, name] = parameters;
-      return fromAbi$2(abi2, name);
-    }
-    return parameters[0];
-  })();
-  return slice$1(getSignatureHash(abiItem), 0, 4);
-}
-function getSignature(...parameters) {
-  const abiItem = (() => {
-    if (Array.isArray(parameters[0])) {
-      const [abi2, name] = parameters;
-      return fromAbi$2(abi2, name);
-    }
-    return parameters[0];
-  })();
-  const signature = (() => {
-    if (typeof abiItem === "string")
-      return abiItem;
-    return formatAbiItem$1(abiItem);
-  })();
-  return normalizeSignature(signature);
-}
-function getSignatureHash(...parameters) {
-  const abiItem = (() => {
-    if (Array.isArray(parameters[0])) {
-      const [abi2, name] = parameters;
-      return fromAbi$2(abi2, name);
-    }
-    return parameters[0];
-  })();
-  if (typeof abiItem !== "string" && "hash" in abiItem && abiItem.hash)
-    return abiItem.hash;
-  return keccak256(fromString$1(getSignature(abiItem)));
-}
-class AmbiguityError extends BaseError$1 {
-  constructor(x, y) {
-    super("Found ambiguous types in overloaded ABI Items.", {
-      metaMessages: [
-        // TODO: abitype to add support for signature-formatted ABI items.
-        `\`${x.type}\` in \`${normalizeSignature(formatAbiItem$1(x.abiItem))}\`, and`,
-        `\`${y.type}\` in \`${normalizeSignature(formatAbiItem$1(y.abiItem))}\``,
-        "",
-        "These types encode differently and cannot be distinguished at runtime.",
-        "Remove one of the ambiguous items in the ABI."
-      ]
-    });
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "AbiItem.AmbiguityError"
-    });
-  }
-}
-class NotFoundError extends BaseError$1 {
-  constructor({ name, data, type = "item" }) {
-    const selector = (() => {
-      if (name)
-        return ` with name "${name}"`;
-      if (data)
-        return ` with data "${data}"`;
-      return "";
-    })();
-    super(`ABI ${type}${selector} not found.`);
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "AbiItem.NotFoundError"
-    });
-  }
-}
-function encode(...parameters) {
-  var _a;
-  const [abiConstructor, options] = (() => {
-    if (Array.isArray(parameters[0])) {
-      const [abi2, options2] = parameters;
-      return [fromAbi$1(abi2), options2];
-    }
-    return parameters;
-  })();
-  const { bytecode, args } = options;
-  return concat$1(bytecode, ((_a = abiConstructor.inputs) == null ? void 0 : _a.length) && (args == null ? void 0 : args.length) ? encode$1(abiConstructor.inputs, args) : "0x");
-}
-function from$1(abiConstructor) {
-  return from$2(abiConstructor);
-}
-function fromAbi$1(abi2) {
-  const item = abi2.find((item2) => item2.type === "constructor");
-  if (!item)
-    throw new NotFoundError({ name: "constructor" });
-  return item;
-}
-function encodeData(...parameters) {
-  const [abiFunction, args = []] = (() => {
-    if (Array.isArray(parameters[0])) {
-      const [abi2, name, args3] = parameters;
-      return [fromAbi(abi2, name, { args: args3 }), args3];
-    }
-    const [abiFunction2, args2] = parameters;
-    return [abiFunction2, args2];
-  })();
-  const { overloads } = abiFunction;
-  const item = overloads ? fromAbi([abiFunction, ...overloads], abiFunction.name, {
-    args
-  }) : abiFunction;
-  const selector = getSelector(item);
-  const data = args.length > 0 ? encode$1(item.inputs, args) : void 0;
-  return data ? concat$1(selector, data) : selector;
-}
-function from(abiFunction, options = {}) {
-  return from$2(abiFunction, options);
-}
-function fromAbi(abi2, name, options) {
-  const item = fromAbi$2(abi2, name, options);
-  if (item.type !== "function")
-    throw new NotFoundError({ name, type: "function" });
-  return item;
-}
-function getSelector(abiItem) {
-  return getSelector$1(abiItem);
-}
-const ethAddress = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
-const zeroAddress = "0x0000000000000000000000000000000000000000";
-const getBalanceCode = "0x6080604052348015600e575f80fd5b5061016d8061001c5f395ff3fe608060405234801561000f575f80fd5b5060043610610029575f3560e01c8063f8b2cb4f1461002d575b5f80fd5b610047600480360381019061004291906100db565b61005d565b604051610054919061011e565b60405180910390f35b5f8173ffffffffffffffffffffffffffffffffffffffff16319050919050565b5f80fd5b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f6100aa82610081565b9050919050565b6100ba816100a0565b81146100c4575f80fd5b50565b5f813590506100d5816100b1565b92915050565b5f602082840312156100f0576100ef61007d565b5b5f6100fd848285016100c7565b91505092915050565b5f819050919050565b61011881610106565b82525050565b5f6020820190506101315f83018461010f565b9291505056fea26469706673582212203b9fe929fe995c7cf9887f0bdba8a36dd78e8b73f149b17d2d9ad7cd09d2dc6264736f6c634300081a0033";
-async function simulateCalls(client, parameters) {
-  const { blockNumber, blockTag, calls, stateOverrides, traceAssetChanges, traceTransfers, validation } = parameters;
-  const account = parameters.account ? parseAccount(parameters.account) : void 0;
-  if (traceAssetChanges && !account)
-    throw new BaseError("`account` is required when `traceAssetChanges` is true");
-  const getBalanceData = account ? encode(from$1("constructor(bytes, bytes)"), {
-    bytecode: deploylessCallViaBytecodeBytecode,
-    args: [
-      getBalanceCode,
-      encodeData(from("function getBalance(address)"), [account.address])
-    ]
-  }) : void 0;
-  const assetAddresses = traceAssetChanges ? await Promise.all(parameters.calls.map(async (call2) => {
-    if (!call2.data && !call2.abi)
-      return;
-    const { accessList } = await createAccessList(client, {
-      account: account.address,
-      ...call2,
-      data: call2.abi ? encodeFunctionData(call2) : call2.data
-    });
-    return accessList.map(({ address, storageKeys }) => storageKeys.length > 0 ? address : null);
-  })).then((x) => x.flat().filter(Boolean)) : [];
-  const blocks = await simulateBlocks(client, {
-    blockNumber,
-    blockTag,
-    blocks: [
-      ...traceAssetChanges ? [
-        // ETH pre balances
-        {
-          calls: [{ data: getBalanceData }],
-          stateOverrides
-        },
-        // Asset pre balances
-        {
-          calls: assetAddresses.map((address, i) => ({
-            abi: [
-              from("function balanceOf(address) returns (uint256)")
-            ],
-            functionName: "balanceOf",
-            args: [account.address],
-            to: address,
-            from: zeroAddress,
-            nonce: i
-          })),
-          stateOverrides: [
-            {
-              address: zeroAddress,
-              nonce: 0
-            }
-          ]
-        }
-      ] : [],
-      {
-        calls: [...calls, {}].map((call2) => ({
-          ...call2,
-          from: account == null ? void 0 : account.address
-        })),
-        stateOverrides
-      },
-      ...traceAssetChanges ? [
-        // ETH post balances
-        {
-          calls: [{ data: getBalanceData }]
-        },
-        // Asset post balances
-        {
-          calls: assetAddresses.map((address, i) => ({
-            abi: [
-              from("function balanceOf(address) returns (uint256)")
-            ],
-            functionName: "balanceOf",
-            args: [account.address],
-            to: address,
-            from: zeroAddress,
-            nonce: i
-          })),
-          stateOverrides: [
-            {
-              address: zeroAddress,
-              nonce: 0
-            }
-          ]
-        },
-        // Decimals
-        {
-          calls: assetAddresses.map((address, i) => ({
-            to: address,
-            abi: [
-              from("function decimals() returns (uint256)")
-            ],
-            functionName: "decimals",
-            from: zeroAddress,
-            nonce: i
-          })),
-          stateOverrides: [
-            {
-              address: zeroAddress,
-              nonce: 0
-            }
-          ]
-        },
-        // Token URI
-        {
-          calls: assetAddresses.map((address, i) => ({
-            to: address,
-            abi: [
-              from("function tokenURI(uint256) returns (string)")
-            ],
-            functionName: "tokenURI",
-            args: [0n],
-            from: zeroAddress,
-            nonce: i
-          })),
-          stateOverrides: [
-            {
-              address: zeroAddress,
-              nonce: 0
-            }
-          ]
-        },
-        // Symbols
-        {
-          calls: assetAddresses.map((address, i) => ({
-            to: address,
-            abi: [from("function symbol() returns (string)")],
-            functionName: "symbol",
-            from: zeroAddress,
-            nonce: i
-          })),
-          stateOverrides: [
-            {
-              address: zeroAddress,
-              nonce: 0
-            }
-          ]
-        }
-      ] : []
-    ],
-    traceTransfers,
-    validation
-  });
-  const block_results = traceAssetChanges ? blocks[2] : blocks[0];
-  const [block_ethPre, block_assetsPre, , block_ethPost, block_assetsPost, block_decimals, block_tokenURI, block_symbols] = traceAssetChanges ? blocks : [];
-  const { calls: block_calls, ...block } = block_results;
-  const results = block_calls.slice(0, -1) ?? [];
-  const ethPre = (block_ethPre == null ? void 0 : block_ethPre.calls) ?? [];
-  const assetsPre = (block_assetsPre == null ? void 0 : block_assetsPre.calls) ?? [];
-  const balancesPre = [...ethPre, ...assetsPre].map((call2) => call2.status === "success" ? hexToBigInt(call2.data) : null);
-  const ethPost = (block_ethPost == null ? void 0 : block_ethPost.calls) ?? [];
-  const assetsPost = (block_assetsPost == null ? void 0 : block_assetsPost.calls) ?? [];
-  const balancesPost = [...ethPost, ...assetsPost].map((call2) => call2.status === "success" ? hexToBigInt(call2.data) : null);
-  const decimals = ((block_decimals == null ? void 0 : block_decimals.calls) ?? []).map((x) => x.status === "success" ? x.result : null);
-  const symbols = ((block_symbols == null ? void 0 : block_symbols.calls) ?? []).map((x) => x.status === "success" ? x.result : null);
-  const tokenURI = ((block_tokenURI == null ? void 0 : block_tokenURI.calls) ?? []).map((x) => x.status === "success" ? x.result : null);
-  const changes = [];
-  for (const [i, balancePost] of balancesPost.entries()) {
-    const balancePre = balancesPre[i];
-    if (typeof balancePost !== "bigint")
-      continue;
-    if (typeof balancePre !== "bigint")
-      continue;
-    const decimals_ = decimals[i - 1];
-    const symbol_ = symbols[i - 1];
-    const tokenURI_ = tokenURI[i - 1];
-    const token = (() => {
-      if (i === 0)
-        return {
-          address: ethAddress,
-          decimals: 18,
-          symbol: "ETH"
-        };
-      return {
-        address: assetAddresses[i - 1],
-        decimals: tokenURI_ || decimals_ ? Number(decimals_ ?? 1) : void 0,
-        symbol: symbol_ ?? void 0
-      };
-    })();
-    if (changes.some((change) => change.token.address === token.address))
-      continue;
-    changes.push({
-      token,
-      value: {
-        pre: balancePre,
-        post: balancePost,
-        diff: balancePost - balancePre
-      }
-    });
-  }
-  return {
-    assetChanges: changes,
-    block,
-    results
-  };
-}
-const magicBytes = "0x6492649264926492649264926492649264926492649264926492649264926492";
-function assert(wrapped) {
-  if (slice$1(wrapped, -32) !== magicBytes)
-    throw new InvalidWrappedSignatureError2(wrapped);
-}
-function wrap(value) {
-  const { data, signature, to } = value;
-  return concat$1(encode$1(from$6("address, bytes, bytes"), [
-    to,
-    data,
-    signature
-  ]), magicBytes);
-}
-function validate(wrapped) {
-  try {
-    assert(wrapped);
-    return true;
-  } catch {
-    return false;
-  }
-}
-class InvalidWrappedSignatureError2 extends BaseError$1 {
-  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"
-    });
-  }
-}
-function serializeSignature({ r, s, to = "hex", v, yParity }) {
-  const yParity_ = (() => {
-    if (yParity === 0 || yParity === 1)
-      return yParity;
-    if (v && (v === 27n || v === 28n || v >= 35n))
-      return v % 2n === 0n ? 1 : 0;
-    throw new Error("Invalid `v` or `yParity` value");
-  })();
-  const signature = `0x${new secp256k1.Signature(hexToBigInt(r), hexToBigInt(s)).toCompactHex()}${yParity_ === 0 ? "1b" : "1c"}`;
-  if (to === "hex")
-    return signature;
-  return hexToBytes(signature);
-}
-async function verifyHash(client, parameters) {
-  var _a, _b, _c, _d, _e, _f;
-  const { address, hash: hash2, erc6492VerifierAddress: verifierAddress = parameters.universalSignatureVerifierAddress ?? ((_c = (_b = (_a = client.chain) == null ? void 0 : _a.contracts) == null ? void 0 : _b.erc6492Verifier) == null ? void 0 : _c.address), multicallAddress = parameters.multicallAddress ?? ((_f = (_e = (_d = client.chain) == null ? void 0 : _d.contracts) == null ? void 0 : _e.multicall3) == null ? void 0 : _f.address) } = parameters;
-  const signature = (() => {
-    const signature2 = parameters.signature;
-    if (isHex(signature2))
-      return signature2;
-    if (typeof signature2 === "object" && "r" in signature2 && "s" in signature2)
-      return serializeSignature(signature2);
-    return bytesToHex(signature2);
-  })();
-  try {
-    if (validate$1(signature))
-      return await verifyErc8010(client, {
-        ...parameters,
-        multicallAddress,
-        signature
-      });
-    return await verifyErc6492(client, {
-      ...parameters,
-      verifierAddress,
-      signature
-    });
-  } catch (error) {
-    try {
-      const verified = isAddressEqual(getAddress(address), await recoverAddress$1({ hash: hash2, signature }));
-      if (verified)
-        return true;
-    } catch {
-    }
-    if (error instanceof VerificationError) {
-      return false;
-    }
-    throw error;
-  }
-}
-async function verifyErc8010(client, parameters) {
-  var _a;
-  const { address, blockNumber, blockTag, hash: hash2, multicallAddress } = parameters;
-  const { authorization: authorization_ox, data: initData, signature, to } = unwrap(parameters.signature);
-  const code = await getCode(client, {
-    address,
-    blockNumber,
-    blockTag
-  });
-  if (code === concatHex(["0xef0100", authorization_ox.address]))
-    return await verifyErc1271(client, {
-      address,
-      blockNumber,
-      blockTag,
-      hash: hash2,
-      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
-  };
-  const valid = await verifyAuthorization({
-    address,
-    authorization
-  });
-  if (!valid)
-    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: [hash2, signature]
-          })
-        }
-      ]
-    ]
-  });
-  const data = (_a = results[results.length - 1]) == null ? void 0 : _a.returnData;
-  if (data == null ? void 0 : data.startsWith("0x1626ba7e"))
-    return true;
-  throw new VerificationError();
-}
-async function verifyErc6492(client, parameters) {
-  const { address, factory, factoryData, hash: hash2, 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, hash2, wrappedSignature]
-    }),
-    ...rest
-  } : {
-    data: encodeDeployData({
-      abi: erc6492SignatureValidatorAbi,
-      args: [address, hash2, 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();
-}
-async function verifyErc1271(client, parameters) {
-  const { address, blockNumber, blockTag, hash: hash2, signature } = parameters;
-  const result = await getAction(client, readContract, "readContract")({
-    address,
-    abi: erc1271Abi,
-    args: [hash2, signature],
-    blockNumber,
-    blockTag,
-    functionName: "isValidSignature"
-  }).catch((error) => {
-    if (error instanceof ContractFunctionExecutionError)
-      throw new VerificationError();
-    throw error;
-  });
-  if (result.startsWith("0x1626ba7e"))
-    return true;
-  throw new VerificationError();
-}
-class VerificationError extends Error {
-}
-async function verifyMessage(client, { address, message, factory, factoryData, signature, ...callRequest }) {
-  const hash2 = hashMessage(message);
-  return verifyHash(client, {
-    address,
-    factory,
-    factoryData,
-    hash: hash2,
-    signature,
-    ...callRequest
-  });
-}
-async function verifyTypedData(client, parameters) {
-  const { address, factory, factoryData, signature, message, primaryType, types, domain, ...callRequest } = parameters;
-  const hash2 = hashTypedData({ message, primaryType, types, domain });
-  return verifyHash(client, {
-    address,
-    factory,
-    factoryData,
-    hash: hash2,
-    signature,
-    ...callRequest
-  });
-}
-function watchBlocks(client, { blockTag = client.experimental_blockTag ?? "latest", emitMissed = false, emitOnBegin = false, onBlock, onError, includeTransactions: includeTransactions_, poll: poll_, pollingInterval = client.pollingInterval }) {
-  const enablePolling = (() => {
-    if (typeof poll_ !== "undefined")
-      return poll_;
-    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 includeTransactions = includeTransactions_ ?? false;
-  let prevBlock;
-  const pollBlocks = () => {
-    const observerId = stringify$1([
-      "watchBlocks",
-      client.uid,
-      blockTag,
-      emitMissed,
-      emitOnBegin,
-      includeTransactions,
-      pollingInterval
-    ]);
-    return observe(observerId, { onBlock, onError }, (emit) => poll(async () => {
-      var _a;
-      try {
-        const block = await getAction(client, getBlock, "getBlock")({
-          blockTag,
-          includeTransactions
-        });
-        if (block.number !== null && (prevBlock == null ? void 0 : prevBlock.number) != null) {
-          if (block.number === prevBlock.number)
-            return;
-          if (block.number - prevBlock.number > 1 && emitMissed) {
-            for (let i = (prevBlock == null ? void 0 : prevBlock.number) + 1n; i < block.number; i++) {
-              const block2 = await getAction(client, getBlock, "getBlock")({
-                blockNumber: i,
-                includeTransactions
-              });
-              emit.onBlock(block2, prevBlock);
-              prevBlock = block2;
-            }
-          }
-        }
-        if (
-          // If no previous block exists, emit.
-          (prevBlock == null ? void 0 : prevBlock.number) == null || // If the block tag is "pending" with no block number, emit.
-          blockTag === "pending" && (block == null ? void 0 : block.number) == null || // If the next block number is greater than the previous block number, emit.
-          // We don't want to emit blocks in the past.
-          block.number !== null && block.number > prevBlock.number
-        ) {
-          emit.onBlock(block, prevBlock);
-          prevBlock = block;
-        }
-      } catch (err) {
-        (_a = emit.onError) == null ? void 0 : _a.call(emit, err);
-      }
-    }, {
-      emitOnBegin,
-      interval: pollingInterval
-    }));
-  };
-  const subscribeBlocks = () => {
-    let active = true;
-    let emitFetched = true;
-    let unsubscribe = () => active = false;
-    (async () => {
-      try {
-        if (emitOnBegin) {
-          getAction(client, getBlock, "getBlock")({
-            blockTag,
-            includeTransactions
-          }).then((block) => {
-            if (!active)
-              return;
-            if (!emitFetched)
-              return;
-            onBlock(block, void 0);
-            emitFetched = false;
-          }).catch(onError);
-        }
-        const transport = (() => {
-          if (client.transport.type === "fallback") {
-            const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket" || transport3.config.type === "ipc");
-            if (!transport2)
-              return client.transport;
-            return transport2.value;
-          }
-          return client.transport;
-        })();
-        const { unsubscribe: unsubscribe_ } = await transport.subscribe({
-          params: ["newHeads"],
-          async onData(data) {
-            var _a;
-            if (!active)
-              return;
-            const block = await getAction(client, getBlock, "getBlock")({
-              blockNumber: (_a = data.result) == null ? void 0 : _a.number,
-              includeTransactions
-            }).catch(() => {
-            });
-            if (!active)
-              return;
-            onBlock(block, prevBlock);
-            emitFetched = false;
-            prevBlock = block;
-          },
-          onError(error) {
-            onError == null ? void 0 : onError(error);
-          }
-        });
-        unsubscribe = unsubscribe_;
-        if (!active)
-          unsubscribe();
-      } catch (err) {
-        onError == null ? void 0 : onError(err);
-      }
-    })();
-    return () => unsubscribe();
-  };
-  return enablePolling ? pollBlocks() : subscribeBlocks();
-}
-function watchEvent(client, { address, args, batch = true, event, events, fromBlock, onError, onLogs, poll: poll_, pollingInterval = client.pollingInterval, strict: strict_ }) {
-  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 strict = strict_ ?? false;
-  const pollEvent = () => {
-    const observerId = stringify$1([
-      "watchEvent",
-      address,
-      args,
-      batch,
-      client.uid,
-      event,
-      pollingInterval,
-      fromBlock
-    ]);
-    return observe(observerId, { onLogs, onError }, (emit) => {
-      let previousBlockNumber;
-      if (fromBlock !== void 0)
-        previousBlockNumber = fromBlock - 1n;
-      let filter;
-      let initialized = false;
-      const unwatch = poll(async () => {
-        var _a;
-        if (!initialized) {
-          try {
-            filter = await getAction(client, createEventFilter, "createEventFilter")({
-              address,
-              args,
-              event,
-              events,
-              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, getLogs, "getLogs")({
-                address,
-                args,
-                event,
-                events,
-                fromBlock: previousBlockNumber + 1n,
-                toBlock: blockNumber
-              });
-            } 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;
-          (_a = emit.onError) == null ? void 0 : _a.call(emit, err);
-        }
-      }, {
-        emitOnBegin: true,
-        interval: pollingInterval
-      });
-      return async () => {
-        if (filter)
-          await getAction(client, uninstallFilter, "uninstallFilter")({ filter });
-        unwatch();
-      };
-    });
-  };
-  const subscribeEvent = () => {
-    let active = true;
-    let unsubscribe = () => active = false;
-    (async () => {
-      try {
-        const transport = (() => {
-          if (client.transport.type === "fallback") {
-            const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket" || transport3.config.type === "ipc");
-            if (!transport2)
-              return client.transport;
-            return transport2.value;
-          }
-          return client.transport;
-        })();
-        const events_ = events ?? (event ? [event] : void 0);
-        let topics = [];
-        if (events_) {
-          const encoded = events_.flatMap((event2) => encodeEventTopics({
-            abi: [event2],
-            eventName: event2.name,
-            args
-          }));
-          topics = [encoded];
-          if (event)
-            topics = topics[0];
-        }
-        const { unsubscribe: unsubscribe_ } = await transport.subscribe({
-          params: ["logs", { address, topics }],
-          onData(data) {
-            var _a;
-            if (!active)
-              return;
-            const log = data.result;
-            try {
-              const { eventName, args: args2 } = decodeEventLog({
-                abi: events_ ?? [],
-                data: log.data,
-                topics: log.topics,
-                strict
-              });
-              const formatted = formatLog(log, { args: args2, eventName });
-              onLogs([formatted]);
-            } catch (err) {
-              let eventName;
-              let isUnnamed;
-              if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
-                if (strict_)
-                  return;
-                eventName = err.abiItem.name;
-                isUnnamed = (_a = err.abiItem.inputs) == null ? void 0 : _a.some((x) => !("name" in x && x.name));
-              }
-              const formatted = formatLog(log, {
-                args: isUnnamed ? [] : {},
-                eventName
-              });
-              onLogs([formatted]);
-            }
-          },
-          onError(error) {
-            onError == null ? void 0 : onError(error);
-          }
-        });
-        unsubscribe = unsubscribe_;
-        if (!active)
-          unsubscribe();
-      } catch (err) {
-        onError == null ? void 0 : onError(err);
-      }
-    })();
-    return () => unsubscribe();
-  };
-  return enablePolling ? pollEvent() : subscribeEvent();
-}
-function parseSiweMessage(message) {
-  var _a, _b, _c;
-  const { scheme, statement, ...prefix } = ((_a = message.match(prefixRegex)) == null ? void 0 : _a.groups) ?? {};
-  const { chainId, expirationTime, issuedAt, notBefore, requestId, ...suffix } = ((_b = message.match(suffixRegex)) == null ? void 0 : _b.groups) ?? {};
-  const resources = (_c = message.split("Resources:")[1]) == null ? void 0 : _c.split("\n- ").slice(1);
-  return {
-    ...prefix,
-    ...suffix,
-    ...chainId ? { chainId: Number(chainId) } : {},
-    ...expirationTime ? { expirationTime: new Date(expirationTime) } : {},
-    ...issuedAt ? { issuedAt: new Date(issuedAt) } : {},
-    ...notBefore ? { notBefore: new Date(notBefore) } : {},
-    ...requestId ? { requestId } : {},
-    ...resources ? { resources } : {},
-    ...scheme ? { scheme } : {},
-    ...statement ? { statement } : {}
-  };
-}
-const prefixRegex = /^(?:(?<scheme>[a-zA-Z][a-zA-Z0-9+-.]*):\/\/)?(?<domain>[a-zA-Z0-9+-.]*(?::[0-9]{1,5})?) (?:wants you to sign in with your Ethereum account:\n)(?<address>0x[a-fA-F0-9]{40})\n\n(?:(?<statement>.*)\n\n)?/;
-const suffixRegex = /(?:URI: (?<uri>.+))\n(?:Version: (?<version>.+))\n(?:Chain ID: (?<chainId>\d+))\n(?:Nonce: (?<nonce>[a-zA-Z0-9]+))\n(?:Issued At: (?<issuedAt>.+))(?:\nExpiration Time: (?<expirationTime>.+))?(?:\nNot Before: (?<notBefore>.+))?(?:\nRequest ID: (?<requestId>.+))?/;
-function validateSiweMessage(parameters) {
-  const { address, domain, message, nonce, scheme, time = /* @__PURE__ */ new Date() } = parameters;
-  if (domain && message.domain !== domain)
-    return false;
-  if (nonce && message.nonce !== nonce)
-    return false;
-  if (scheme && message.scheme !== scheme)
-    return false;
-  if (message.expirationTime && time >= message.expirationTime)
-    return false;
-  if (message.notBefore && time < message.notBefore)
-    return false;
-  try {
-    if (!message.address)
-      return false;
-    if (!isAddress(message.address, { strict: false }))
-      return false;
-    if (address && !isAddressEqual(message.address, address))
-      return false;
-  } catch {
-    return false;
-  }
-  return true;
-}
-async function verifySiweMessage(client, parameters) {
-  const { address, domain, message, nonce, scheme, signature, time = /* @__PURE__ */ new Date(), ...callRequest } = parameters;
-  const parsed = parseSiweMessage(message);
-  if (!parsed.address)
-    return false;
-  const isValid = validateSiweMessage({
-    address,
-    domain,
-    message: parsed,
-    nonce,
-    scheme,
-    time
-  });
-  if (!isValid)
-    return false;
-  const hash2 = hashMessage(message);
-  return verifyHash(client, {
-    address: parsed.address,
-    hash: hash2,
-    signature,
-    ...callRequest
-  });
-}
-function publicActions(client) {
-  return {
-    call: (args) => call(client, args),
-    createAccessList: (args) => createAccessList(client, args),
-    createBlockFilter: () => createBlockFilter(client),
-    createContractEventFilter: (args) => createContractEventFilter(client, args),
-    createEventFilter: (args) => createEventFilter(client, args),
-    createPendingTransactionFilter: () => createPendingTransactionFilter(client),
-    estimateContractGas: (args) => estimateContractGas(client, args),
-    estimateGas: (args) => estimateGas(client, args),
-    getBalance: (args) => getBalance(client, args),
-    getBlobBaseFee: () => getBlobBaseFee(client),
-    getBlock: (args) => getBlock(client, args),
-    getBlockNumber: (args) => getBlockNumber(client, args),
-    getBlockTransactionCount: (args) => getBlockTransactionCount(client, args),
-    getBytecode: (args) => getCode(client, args),
-    getChainId: () => getChainId(client),
-    getCode: (args) => getCode(client, args),
-    getContractEvents: (args) => getContractEvents(client, args),
-    getEip712Domain: (args) => getEip712Domain(client, args),
-    getEnsAddress: (args) => getEnsAddress(client, args),
-    getEnsAvatar: (args) => getEnsAvatar(client, args),
-    getEnsName: (args) => getEnsName(client, args),
-    getEnsResolver: (args) => getEnsResolver(client, args),
-    getEnsText: (args) => getEnsText(client, args),
-    getFeeHistory: (args) => getFeeHistory(client, args),
-    estimateFeesPerGas: (args) => estimateFeesPerGas(client, args),
-    getFilterChanges: (args) => getFilterChanges(client, args),
-    getFilterLogs: (args) => getFilterLogs(client, args),
-    getGasPrice: () => getGasPrice(client),
-    getLogs: (args) => getLogs(client, args),
-    getProof: (args) => getProof(client, args),
-    estimateMaxPriorityFeePerGas: (args) => estimateMaxPriorityFeePerGas(client, args),
-    getStorageAt: (args) => getStorageAt(client, args),
-    getTransaction: (args) => getTransaction(client, args),
-    getTransactionConfirmations: (args) => getTransactionConfirmations(client, args),
-    getTransactionCount: (args) => getTransactionCount(client, args),
-    getTransactionReceipt: (args) => getTransactionReceipt(client, args),
-    multicall: (args) => multicall(client, args),
-    prepareTransactionRequest: (args) => prepareTransactionRequest(client, args),
-    readContract: (args) => readContract(client, args),
-    sendRawTransaction: (args) => sendRawTransaction(client, args),
-    simulate: (args) => simulateBlocks(client, args),
-    simulateBlocks: (args) => simulateBlocks(client, args),
-    simulateCalls: (args) => simulateCalls(client, args),
-    simulateContract: (args) => simulateContract(client, args),
-    verifyHash: (args) => verifyHash(client, args),
-    verifyMessage: (args) => verifyMessage(client, args),
-    verifySiweMessage: (args) => verifySiweMessage(client, args),
-    verifyTypedData: (args) => verifyTypedData(client, args),
-    uninstallFilter: (args) => uninstallFilter(client, args),
-    waitForTransactionReceipt: (args) => waitForTransactionReceipt(client, args),
-    watchBlocks: (args) => watchBlocks(client, args),
-    watchBlockNumber: (args) => watchBlockNumber(client, args),
-    watchContractEvent: (args) => watchContractEvent(client, args),
-    watchEvent: (args) => watchEvent(client, args),
-    watchPendingTransactions: (args) => watchPendingTransactions(client, args)
-  };
-}
-function createPublicClient(parameters) {
-  const { key = "public", name = "Public Client" } = parameters;
-  const client = createClient({
-    ...parameters,
-    key,
-    name,
-    type: "publicClient"
-  });
-  return client.extend(publicActions);
-}
-async function prepareAuthorization(client, parameters) {
-  var _a;
-  const { account: account_ = client.account, chainId, nonce } = parameters;
-  if (!account_)
-    throw new AccountNotFoundError({
-      docsPath: "/docs/eip7702/prepareAuthorization"
-    });
-  const account = parseAccount(account_);
-  const executor = (() => {
-    if (!parameters.executor)
-      return void 0;
-    if (parameters.executor === "self")
-      return parameters.executor;
-    return parseAccount(parameters.executor);
-  })();
-  const authorization = {
-    address: parameters.contractAddress ?? parameters.address,
-    chainId,
-    nonce
-  };
-  if (typeof authorization.chainId === "undefined")
-    authorization.chainId = ((_a = client.chain) == null ? void 0 : _a.id) ?? await getAction(client, getChainId, "getChainId")({});
-  if (typeof authorization.nonce === "undefined") {
-    authorization.nonce = await getAction(client, getTransactionCount, "getTransactionCount")({
-      address: account.address,
-      blockTag: "pending"
-    });
-    if (executor === "self" || (executor == null ? void 0 : executor.address) && isAddressEqual(executor.address, account.address))
-      authorization.nonce += 1;
-  }
-  return authorization;
-}
-class UrlRequiredError extends BaseError {
-  constructor() {
-    super("No URL was provided to the Transport. Please provide a valid RPC URL to the Transport.", {
-      docsPath: "/docs/clients/intro",
-      name: "UrlRequiredError"
-    });
-  }
-}
-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 == null ? void 0 : 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: (body2) => rpcClient.request({
-            body: body2
-          }),
-          sort: (a, b) => a.id - b.id
-        });
-        const fn = async (body2) => batch ? schedule(body2) : [
-          await rpcClient.request({
-            body: body2
-          })
-        ];
-        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_
-    });
-  };
-}
-function parseSignature(signatureHex) {
-  const { r, s } = secp256k1.Signature.fromCompact(signatureHex.slice(2, 130));
-  const yParityOrV = Number(`0x${signatureHex.slice(130)}`);
-  const [v, yParity] = (() => {
-    if (yParityOrV === 0 || yParityOrV === 1)
-      return [void 0, yParityOrV];
-    if (yParityOrV === 27)
-      return [BigInt(yParityOrV), 0];
-    if (yParityOrV === 28)
-      return [BigInt(yParityOrV), 1];
-    throw new Error("Invalid yParityOrV value");
-  })();
-  if (typeof v !== "undefined")
-    return {
-      r: numberToHex(r, { size: 32 }),
-      s: numberToHex(s, { size: 32 }),
-      v,
-      yParity
-    };
-  return {
-    r: numberToHex(r, { size: 32 }),
-    s: numberToHex(s, { size: 32 }),
-    yParity
-  };
-}
-export {
-  nonceManager as A,
-  BundleFailedError as B,
-  publicActions as C,
-  serializeErc6492Signature as D,
-  EnsInvalidChainIdError as E,
-  FilterTypeNotSupportedError as F,
-  serializeSignature as G,
-  zeroAddress as H,
-  zeroHash as I,
-  getCode as J,
-  UrlRequiredError as U,
-  WaitForCallsStatusTimeoutError as W,
-  erc6492MagicBytes as a,
-  wrap$1 as b,
-  createContractEventFilter as c,
-  waitForCallsStatus as d,
-  estimateContractGas as e,
-  sendCalls as f,
-  getContractEvents as g,
-  getCallsStatus as h,
-  idCache as i,
-  EnsAvatarInvalidNftUriError as j,
-  EnsAvatarUnsupportedNamespaceError as k,
-  EnsAvatarUriResolutionError as l,
-  createNonceManager as m,
-  createPublicClient as n,
-  encodeEventTopics as o,
-  prepareAuthorization as p,
-  encodePacked$1 as q,
-  ethAddress as r,
-  simulateContract as s,
-  parseSignature as t,
-  unwrap as u,
-  validate$1 as v,
-  watchContractEvent as w,
-  http as x,
-  labelhash as y,
-  namehash as z
-};
-//# sourceMappingURL=parseSignature-MJforcG6.js.map