@powerhousedao/connect 1.0.0-dev.221 → 1.0.0-dev.223

package/dist/assets/getEnsName-DVtbpogo.js

@@ -1,3736 +0,0 @@
-const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/ccip-BLPIQK-p.js","assets/app-B8nf-deX.js","assets/main.Bikg5D0d.js","assets/app-loader-BDXofohd.js","assets/app-loader-DaEnUcee.css","assets/isAddressEqual-HNfnZOzP.js"])))=>i.map(i=>d[i]);
-import { B as BaseError$1, O as size, v as isHex, ab as SliceOffsetOutOfBoundsError, C as numberToHex, U as isAddress, V as InvalidAddressError, ac as padHex, ad as boolToHex, ae as IntegerOutOfRangeError, W as stringToHex, z as bytesToHex, F as parseAccount, af as InvalidBytesLengthError, ag as assertSize, y as hexToNumber, P as trim, ah as InvalidBytesBooleanError, x as hexToBigInt, A as hexToBytes, s as checksumAddress, q as keccak256, N as toBytes, T as stringify, ai as getContractAddress, aj as stringToBytes, ak as InternalRpcError, al as RpcRequestError, am as createBatchScheduler, w as toHex } from "./app-B8nf-deX.js";
-import { _ as __vitePreload } from "./main.Bikg5D0d.js";
-function formatAbiItem$1(abiItem, { includeName = false } = {}) {
-  if (abiItem.type !== "function" && abiItem.type !== "event" && abiItem.type !== "error")
-    throw new InvalidDefinitionTypeError(abiItem.type);
-  return `${abiItem.name}(${formatAbiParams(abiItem.inputs, { includeName })})`;
-}
-function formatAbiParams(params, { includeName = false } = {}) {
-  if (!params)
-    return "";
-  return params.map((param) => formatAbiParam(param, { includeName })).join(includeName ? ", " : ",");
-}
-function formatAbiParam(param, { includeName }) {
-  if (param.type.startsWith("tuple")) {
-    return `(${formatAbiParams(param.components, { includeName })})${param.type.slice("tuple".length)}`;
-  }
-  return param.type + (includeName && param.name ? ` ${param.name}` : "");
-}
-class AbiConstructorNotFoundError extends BaseError$1 {
-  constructor({ docsPath: docsPath2 }) {
-    super([
-      "A constructor was not found on the ABI.",
-      "Make sure you are using the correct ABI and that the constructor exists on it."
-    ].join("\n"), {
-      docsPath: docsPath2,
-      name: "AbiConstructorNotFoundError"
-    });
-  }
-}
-class AbiConstructorParamsNotFoundError extends BaseError$1 {
-  constructor({ docsPath: docsPath2 }) {
-    super([
-      "Constructor arguments were provided (`args`), but a constructor parameters (`inputs`) were not found on the ABI.",
-      "Make sure you are using the correct ABI, and that the `inputs` attribute on the constructor exists."
-    ].join("\n"), {
-      docsPath: docsPath2,
-      name: "AbiConstructorParamsNotFoundError"
-    });
-  }
-}
-class AbiDecodingDataSizeTooSmallError extends BaseError$1 {
-  constructor({ data, params, size: size2 }) {
-    super([`Data size of ${size2} bytes is too small for given parameters.`].join("\n"), {
-      metaMessages: [
-        `Params: (${formatAbiParams(params, { includeName: true })})`,
-        `Data:   ${data} (${size2} bytes)`
-      ],
-      name: "AbiDecodingDataSizeTooSmallError"
-    });
-    Object.defineProperty(this, "data", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "params", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "size", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    this.data = data;
-    this.params = params;
-    this.size = size2;
-  }
-}
-class AbiDecodingZeroDataError extends BaseError$1 {
-  constructor() {
-    super('Cannot decode zero data ("0x") with ABI parameters.', {
-      name: "AbiDecodingZeroDataError"
-    });
-  }
-}
-class AbiEncodingArrayLengthMismatchError extends BaseError$1 {
-  constructor({ expectedLength, givenLength, type }) {
-    super([
-      `ABI encoding array length mismatch for type ${type}.`,
-      `Expected length: ${expectedLength}`,
-      `Given length: ${givenLength}`
-    ].join("\n"), { name: "AbiEncodingArrayLengthMismatchError" });
-  }
-}
-class AbiEncodingBytesSizeMismatchError extends BaseError$1 {
-  constructor({ expectedSize, value }) {
-    super(`Size of bytes "${value}" (bytes${size(value)}) does not match expected size (bytes${expectedSize}).`, { name: "AbiEncodingBytesSizeMismatchError" });
-  }
-}
-class AbiEncodingLengthMismatchError extends BaseError$1 {
-  constructor({ expectedLength, givenLength }) {
-    super([
-      "ABI encoding params/values length mismatch.",
-      `Expected length (params): ${expectedLength}`,
-      `Given length (values): ${givenLength}`
-    ].join("\n"), { name: "AbiEncodingLengthMismatchError" });
-  }
-}
-class AbiErrorSignatureNotFoundError extends BaseError$1 {
-  constructor(signature, { docsPath: docsPath2 }) {
-    super([
-      `Encoded error signature "${signature}" not found on ABI.`,
-      "Make sure you are using the correct ABI and that the error exists on it.",
-      `You can look up the decoded signature here: https://openchain.xyz/signatures?query=${signature}.`
-    ].join("\n"), {
-      docsPath: docsPath2,
-      name: "AbiErrorSignatureNotFoundError"
-    });
-    Object.defineProperty(this, "signature", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    this.signature = signature;
-  }
-}
-class AbiEventSignatureEmptyTopicsError extends BaseError$1 {
-  constructor({ docsPath: docsPath2 }) {
-    super("Cannot extract event signature from empty topics.", {
-      docsPath: docsPath2,
-      name: "AbiEventSignatureEmptyTopicsError"
-    });
-  }
-}
-class AbiEventSignatureNotFoundError extends BaseError$1 {
-  constructor(signature, { docsPath: docsPath2 }) {
-    super([
-      `Encoded event signature "${signature}" not found on ABI.`,
-      "Make sure you are using the correct ABI and that the event exists on it.",
-      `You can look up the signature here: https://openchain.xyz/signatures?query=${signature}.`
-    ].join("\n"), {
-      docsPath: docsPath2,
-      name: "AbiEventSignatureNotFoundError"
-    });
-  }
-}
-class AbiEventNotFoundError extends BaseError$1 {
-  constructor(eventName, { docsPath: docsPath2 } = {}) {
-    super([
-      `Event ${eventName ? `"${eventName}" ` : ""}not found on ABI.`,
-      "Make sure you are using the correct ABI and that the event exists on it."
-    ].join("\n"), {
-      docsPath: docsPath2,
-      name: "AbiEventNotFoundError"
-    });
-  }
-}
-class AbiFunctionNotFoundError extends BaseError$1 {
-  constructor(functionName, { docsPath: docsPath2 } = {}) {
-    super([
-      `Function ${functionName ? `"${functionName}" ` : ""}not found on ABI.`,
-      "Make sure you are using the correct ABI and that the function exists on it."
-    ].join("\n"), {
-      docsPath: docsPath2,
-      name: "AbiFunctionNotFoundError"
-    });
-  }
-}
-class AbiFunctionOutputsNotFoundError extends BaseError$1 {
-  constructor(functionName, { docsPath: docsPath2 }) {
-    super([
-      `Function "${functionName}" does not contain any \`outputs\` on ABI.`,
-      "Cannot decode function result without knowing what the parameter types are.",
-      "Make sure you are using the correct ABI and that the function exists on it."
-    ].join("\n"), {
-      docsPath: docsPath2,
-      name: "AbiFunctionOutputsNotFoundError"
-    });
-  }
-}
-class AbiItemAmbiguityError extends BaseError$1 {
-  constructor(x, y) {
-    super("Found ambiguous types in overloaded ABI items.", {
-      metaMessages: [
-        `\`${x.type}\` in \`${formatAbiItem$1(x.abiItem)}\`, and`,
-        `\`${y.type}\` in \`${formatAbiItem$1(y.abiItem)}\``,
-        "",
-        "These types encode differently and cannot be distinguished at runtime.",
-        "Remove one of the ambiguous items in the ABI."
-      ],
-      name: "AbiItemAmbiguityError"
-    });
-  }
-}
-class BytesSizeMismatchError extends BaseError$1 {
-  constructor({ expectedSize, givenSize }) {
-    super(`Expected bytes${expectedSize}, got bytes${givenSize}.`, {
-      name: "BytesSizeMismatchError"
-    });
-  }
-}
-class DecodeLogDataMismatch extends BaseError$1 {
-  constructor({ abiItem, data, params, size: size2 }) {
-    super([
-      `Data size of ${size2} bytes is too small for non-indexed event parameters.`
-    ].join("\n"), {
-      metaMessages: [
-        `Params: (${formatAbiParams(params, { includeName: true })})`,
-        `Data:   ${data} (${size2} bytes)`
-      ],
-      name: "DecodeLogDataMismatch"
-    });
-    Object.defineProperty(this, "abiItem", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "data", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "params", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "size", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    this.abiItem = abiItem;
-    this.data = data;
-    this.params = params;
-    this.size = size2;
-  }
-}
-class DecodeLogTopicsMismatch extends BaseError$1 {
-  constructor({ abiItem, param }) {
-    super([
-      `Expected a topic for indexed event parameter${param.name ? ` "${param.name}"` : ""} on event "${formatAbiItem$1(abiItem, { includeName: true })}".`
-    ].join("\n"), { name: "DecodeLogTopicsMismatch" });
-    Object.defineProperty(this, "abiItem", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    this.abiItem = abiItem;
-  }
-}
-class InvalidAbiEncodingTypeError extends BaseError$1 {
-  constructor(type, { docsPath: docsPath2 }) {
-    super([
-      `Type "${type}" is not a valid encoding type.`,
-      "Please provide a valid ABI type."
-    ].join("\n"), { docsPath: docsPath2, name: "InvalidAbiEncodingType" });
-  }
-}
-class InvalidAbiDecodingTypeError extends BaseError$1 {
-  constructor(type, { docsPath: docsPath2 }) {
-    super([
-      `Type "${type}" is not a valid decoding type.`,
-      "Please provide a valid ABI type."
-    ].join("\n"), { docsPath: docsPath2, name: "InvalidAbiDecodingType" });
-  }
-}
-class InvalidArrayError extends BaseError$1 {
-  constructor(value) {
-    super([`Value "${value}" is not a valid array.`].join("\n"), {
-      name: "InvalidArrayError"
-    });
-  }
-}
-class InvalidDefinitionTypeError extends BaseError$1 {
-  constructor(type) {
-    super([
-      `"${type}" is not a valid definition type.`,
-      'Valid types: "function", "event", "error"'
-    ].join("\n"), { name: "InvalidDefinitionTypeError" });
-  }
-}
-function concat(values) {
-  if (typeof values[0] === "string")
-    return concatHex(values);
-  return concatBytes(values);
-}
-function concatBytes(values) {
-  let length = 0;
-  for (const arr of values) {
-    length += arr.length;
-  }
-  const result = new Uint8Array(length);
-  let offset = 0;
-  for (const arr of values) {
-    result.set(arr, offset);
-    offset += arr.length;
-  }
-  return result;
-}
-function concatHex(values) {
-  return `0x${values.reduce((acc, x) => acc + x.replace("0x", ""), "")}`;
-}
-function slice(value, start, end, { strict } = {}) {
-  if (isHex(value, { strict: false }))
-    return sliceHex(value, start, end, {
-      strict
-    });
-  return sliceBytes(value, start, end, {
-    strict
-  });
-}
-function assertStartOffset(value, start) {
-  if (typeof start === "number" && start > 0 && start > size(value) - 1)
-    throw new SliceOffsetOutOfBoundsError({
-      offset: start,
-      position: "start",
-      size: size(value)
-    });
-}
-function assertEndOffset(value, start, end) {
-  if (typeof start === "number" && typeof end === "number" && size(value) !== end - start) {
-    throw new SliceOffsetOutOfBoundsError({
-      offset: end,
-      position: "end",
-      size: size(value)
-    });
-  }
-}
-function sliceBytes(value_, start, end, { strict } = {}) {
-  assertStartOffset(value_, start);
-  const value = value_.slice(start, end);
-  if (strict)
-    assertEndOffset(value, start, end);
-  return value;
-}
-function sliceHex(value_, start, end, { strict } = {}) {
-  assertStartOffset(value_, start);
-  const value = `0x${value_.replace("0x", "").slice((start ?? 0) * 2, (end ?? value_.length) * 2)}`;
-  if (strict)
-    assertEndOffset(value, start, end);
-  return value;
-}
-const bytesRegex$1 = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
-const integerRegex$1 = /^(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)?$/;
-function encodeAbiParameters(params, values) {
-  if (params.length !== values.length)
-    throw new AbiEncodingLengthMismatchError({
-      expectedLength: params.length,
-      givenLength: values.length
-    });
-  const preparedParams = prepareParams({
-    params,
-    values
-  });
-  const data = encodeParams(preparedParams);
-  if (data.length === 0)
-    return "0x";
-  return data;
-}
-function prepareParams({ params, values }) {
-  const preparedParams = [];
-  for (let i = 0; i < params.length; i++) {
-    preparedParams.push(prepareParam({ param: params[i], value: values[i] }));
-  }
-  return preparedParams;
-}
-function prepareParam({ param, value }) {
-  const arrayComponents = getArrayComponents(param.type);
-  if (arrayComponents) {
-    const [length, type] = arrayComponents;
-    return encodeArray(value, { length, param: { ...param, type } });
-  }
-  if (param.type === "tuple") {
-    return encodeTuple(value, {
-      param
-    });
-  }
-  if (param.type === "address") {
-    return encodeAddress(value);
-  }
-  if (param.type === "bool") {
-    return encodeBool(value);
-  }
-  if (param.type.startsWith("uint") || param.type.startsWith("int")) {
-    const signed = param.type.startsWith("int");
-    const [, , size2 = "256"] = integerRegex$1.exec(param.type) ?? [];
-    return encodeNumber(value, {
-      signed,
-      size: Number(size2)
-    });
-  }
-  if (param.type.startsWith("bytes")) {
-    return encodeBytes(value, { param });
-  }
-  if (param.type === "string") {
-    return encodeString(value);
-  }
-  throw new InvalidAbiEncodingTypeError(param.type, {
-    docsPath: "/docs/contract/encodeAbiParameters"
-  });
-}
-function encodeParams(preparedParams) {
-  let staticSize = 0;
-  for (let i = 0; i < preparedParams.length; i++) {
-    const { dynamic, encoded } = preparedParams[i];
-    if (dynamic)
-      staticSize += 32;
-    else
-      staticSize += size(encoded);
-  }
-  const staticParams = [];
-  const dynamicParams = [];
-  let dynamicSize = 0;
-  for (let i = 0; i < preparedParams.length; i++) {
-    const { dynamic, encoded } = preparedParams[i];
-    if (dynamic) {
-      staticParams.push(numberToHex(staticSize + dynamicSize, { size: 32 }));
-      dynamicParams.push(encoded);
-      dynamicSize += size(encoded);
-    } else {
-      staticParams.push(encoded);
-    }
-  }
-  return concat([...staticParams, ...dynamicParams]);
-}
-function encodeAddress(value) {
-  if (!isAddress(value))
-    throw new InvalidAddressError({ address: value });
-  return { dynamic: false, encoded: padHex(value.toLowerCase()) };
-}
-function encodeArray(value, { length, param }) {
-  const dynamic = length === null;
-  if (!Array.isArray(value))
-    throw new InvalidArrayError(value);
-  if (!dynamic && value.length !== length)
-    throw new AbiEncodingArrayLengthMismatchError({
-      expectedLength: length,
-      givenLength: value.length,
-      type: `${param.type}[${length}]`
-    });
-  let dynamicChild = false;
-  const preparedParams = [];
-  for (let i = 0; i < value.length; i++) {
-    const preparedParam = prepareParam({ param, value: value[i] });
-    if (preparedParam.dynamic)
-      dynamicChild = true;
-    preparedParams.push(preparedParam);
-  }
-  if (dynamic || dynamicChild) {
-    const data = encodeParams(preparedParams);
-    if (dynamic) {
-      const length2 = numberToHex(preparedParams.length, { size: 32 });
-      return {
-        dynamic: true,
-        encoded: preparedParams.length > 0 ? concat([length2, data]) : length2
-      };
-    }
-    if (dynamicChild)
-      return { dynamic: true, encoded: data };
-  }
-  return {
-    dynamic: false,
-    encoded: concat(preparedParams.map(({ encoded }) => encoded))
-  };
-}
-function encodeBytes(value, { param }) {
-  const [, paramSize] = param.type.split("bytes");
-  const bytesSize = size(value);
-  if (!paramSize) {
-    let value_ = value;
-    if (bytesSize % 32 !== 0)
-      value_ = padHex(value_, {
-        dir: "right",
-        size: Math.ceil((value.length - 2) / 2 / 32) * 32
-      });
-    return {
-      dynamic: true,
-      encoded: concat([padHex(numberToHex(bytesSize, { size: 32 })), value_])
-    };
-  }
-  if (bytesSize !== Number.parseInt(paramSize))
-    throw new AbiEncodingBytesSizeMismatchError({
-      expectedSize: Number.parseInt(paramSize),
-      value
-    });
-  return { dynamic: false, encoded: padHex(value, { dir: "right" }) };
-}
-function encodeBool(value) {
-  if (typeof value !== "boolean")
-    throw new BaseError$1(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
-  return { dynamic: false, encoded: padHex(boolToHex(value)) };
-}
-function encodeNumber(value, { signed, size: size2 = 256 }) {
-  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: numberToHex(value, {
-      size: 32,
-      signed
-    })
-  };
-}
-function encodeString(value) {
-  const hexValue = stringToHex(value);
-  const partsLength = Math.ceil(size(hexValue) / 32);
-  const parts = [];
-  for (let i = 0; i < partsLength; i++) {
-    parts.push(padHex(slice(hexValue, i * 32, (i + 1) * 32), {
-      dir: "right"
-    }));
-  }
-  return {
-    dynamic: true,
-    encoded: concat([
-      padHex(numberToHex(size(hexValue), { size: 32 })),
-      ...parts
-    ])
-  };
-}
-function encodeTuple(value, { param }) {
-  let dynamic = false;
-  const preparedParams = [];
-  for (let i = 0; i < param.components.length; i++) {
-    const param_ = param.components[i];
-    const index = Array.isArray(value) ? i : param_.name;
-    const preparedParam = prepareParam({
-      param: param_,
-      value: value[index]
-    });
-    preparedParams.push(preparedParam);
-    if (preparedParam.dynamic)
-      dynamic = true;
-  }
-  return {
-    dynamic,
-    encoded: dynamic ? encodeParams(preparedParams) : concat(preparedParams.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;
-}
-const docsPath$2 = "/docs/contract/encodeDeployData";
-function encodeDeployData(parameters) {
-  const { abi, args, bytecode } = parameters;
-  if (!args || args.length === 0)
-    return bytecode;
-  const description = abi.find((x) => "type" in x && x.type === "constructor");
-  if (!description)
-    throw new AbiConstructorNotFoundError({ docsPath: docsPath$2 });
-  if (!("inputs" in description))
-    throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath$2 });
-  if (!description.inputs || description.inputs.length === 0)
-    throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath$2 });
-  const data = encodeAbiParameters(description.inputs, args);
-  return concatHex([bytecode, data]);
-}
-class NegativeOffsetError extends BaseError$1 {
-  constructor({ offset }) {
-    super(`Offset \`${offset}\` cannot be negative.`, {
-      name: "NegativeOffsetError"
-    });
-  }
-}
-class PositionOutOfBoundsError extends BaseError$1 {
-  constructor({ length, position }) {
-    super(`Position \`${position}\` is out of bounds (\`0 < position < ${length}\`).`, { name: "PositionOutOfBoundsError" });
-  }
-}
-class RecursiveReadLimitExceededError extends BaseError$1 {
-  constructor({ count, limit }) {
-    super(`Recursive read limit of \`${limit}\` exceeded (recursive read count: \`${count}\`).`, { name: "RecursiveReadLimitExceededError" });
-  }
-}
-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 createCursor(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 ChainDoesNotSupportContract extends BaseError$1 {
-  constructor({ blockNumber, chain, contract }) {
-    super(`Chain "${chain.name}" does not support contract "${contract.name}".`, {
-      metaMessages: [
-        "This could be due to any of the following:",
-        ...blockNumber && contract.blockCreated && contract.blockCreated > blockNumber ? [
-          `- The contract "${contract.name}" was not deployed until block ${contract.blockCreated} (current block ${blockNumber}).`
-        ] : [
-          `- The chain does not have the contract "${contract.name}" configured.`
-        ]
-      ],
-      name: "ChainDoesNotSupportContract"
-    });
-  }
-}
-class ClientChainNotConfiguredError extends BaseError$1 {
-  constructor() {
-    super("No chain was provided to the Client.", {
-      name: "ClientChainNotConfiguredError"
-    });
-  }
-}
-class InvalidChainIdError extends BaseError$1 {
-  constructor({ chainId }) {
-    super(typeof chainId === "number" ? `Chain ID "${chainId}" is invalid.` : "Chain ID is invalid.", { name: "InvalidChainIdError" });
-  }
-}
-const etherUnits = {
-  gwei: 9,
-  wei: 18
-};
-const gweiUnits = {
-  ether: -9,
-  wei: 9
-};
-function formatUnits(value, decimals) {
-  let display = value.toString();
-  const negative = display.startsWith("-");
-  if (negative)
-    display = display.slice(1);
-  display = display.padStart(decimals, "0");
-  let [integer, fraction] = [
-    display.slice(0, display.length - decimals),
-    display.slice(display.length - decimals)
-  ];
-  fraction = fraction.replace(/(0+)$/, "");
-  return `${negative ? "-" : ""}${integer || "0"}${fraction ? `.${fraction}` : ""}`;
-}
-function formatGwei(wei, unit = "wei") {
-  return formatUnits(wei, gweiUnits[unit]);
-}
-class ExecutionRevertedError extends BaseError$1 {
-  constructor({ cause, message } = {}) {
-    var _a;
-    const reason = (_a = message == null ? void 0 : message.replace("execution reverted: ", "")) == null ? void 0 : _a.replace("execution reverted", "");
-    super(`Execution reverted ${reason ? `with reason: ${reason}` : "for an unknown reason"}.`, {
-      cause,
-      name: "ExecutionRevertedError"
-    });
-  }
-}
-Object.defineProperty(ExecutionRevertedError, "code", {
-  enumerable: true,
-  configurable: true,
-  writable: true,
-  value: 3
-});
-Object.defineProperty(ExecutionRevertedError, "nodeMessage", {
-  enumerable: true,
-  configurable: true,
-  writable: true,
-  value: /execution reverted/
-});
-class FeeCapTooHighError extends BaseError$1 {
-  constructor({ cause, maxFeePerGas } = {}) {
-    super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}) cannot be higher than the maximum allowed value (2^256-1).`, {
-      cause,
-      name: "FeeCapTooHighError"
-    });
-  }
-}
-Object.defineProperty(FeeCapTooHighError, "nodeMessage", {
-  enumerable: true,
-  configurable: true,
-  writable: true,
-  value: /max fee per gas higher than 2\^256-1|fee cap higher than 2\^256-1/
-});
-class FeeCapTooLowError extends BaseError$1 {
-  constructor({ cause, maxFeePerGas } = {}) {
-    super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)}` : ""} gwei) cannot be lower than the block base fee.`, {
-      cause,
-      name: "FeeCapTooLowError"
-    });
-  }
-}
-Object.defineProperty(FeeCapTooLowError, "nodeMessage", {
-  enumerable: true,
-  configurable: true,
-  writable: true,
-  value: /max fee per gas less than block base fee|fee cap less than block base fee|transaction is outdated/
-});
-class NonceTooHighError extends BaseError$1 {
-  constructor({ cause, nonce } = {}) {
-    super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is higher than the next one expected.`, { cause, name: "NonceTooHighError" });
-  }
-}
-Object.defineProperty(NonceTooHighError, "nodeMessage", {
-  enumerable: true,
-  configurable: true,
-  writable: true,
-  value: /nonce too high/
-});
-class NonceTooLowError extends BaseError$1 {
-  constructor({ cause, nonce } = {}) {
-    super([
-      `Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is lower than the current nonce of the account.`,
-      "Try increasing the nonce or find the latest nonce with `getTransactionCount`."
-    ].join("\n"), { cause, name: "NonceTooLowError" });
-  }
-}
-Object.defineProperty(NonceTooLowError, "nodeMessage", {
-  enumerable: true,
-  configurable: true,
-  writable: true,
-  value: /nonce too low|transaction already imported|already known/
-});
-class NonceMaxValueError extends BaseError$1 {
-  constructor({ cause, nonce } = {}) {
-    super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}exceeds the maximum allowed nonce.`, { cause, name: "NonceMaxValueError" });
-  }
-}
-Object.defineProperty(NonceMaxValueError, "nodeMessage", {
-  enumerable: true,
-  configurable: true,
-  writable: true,
-  value: /nonce has max value/
-});
-class InsufficientFundsError extends BaseError$1 {
-  constructor({ cause } = {}) {
-    super([
-      "The total cost (gas * gas fee + value) of executing this transaction exceeds the balance of the account."
-    ].join("\n"), {
-      cause,
-      metaMessages: [
-        "This error could arise when the account does not have enough funds to:",
-        " - pay for the total gas fee,",
-        " - pay for the value to send.",
-        " ",
-        "The cost of the transaction is calculated as `gas * gas fee + value`, where:",
-        " - `gas` is the amount of gas needed for transaction to execute,",
-        " - `gas fee` is the gas fee,",
-        " - `value` is the amount of ether to send to the recipient."
-      ],
-      name: "InsufficientFundsError"
-    });
-  }
-}
-Object.defineProperty(InsufficientFundsError, "nodeMessage", {
-  enumerable: true,
-  configurable: true,
-  writable: true,
-  value: /insufficient funds|exceeds transaction sender account balance/
-});
-class IntrinsicGasTooHighError extends BaseError$1 {
-  constructor({ cause, gas } = {}) {
-    super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction exceeds the limit allowed for the block.`, {
-      cause,
-      name: "IntrinsicGasTooHighError"
-    });
-  }
-}
-Object.defineProperty(IntrinsicGasTooHighError, "nodeMessage", {
-  enumerable: true,
-  configurable: true,
-  writable: true,
-  value: /intrinsic gas too high|gas limit reached/
-});
-class IntrinsicGasTooLowError extends BaseError$1 {
-  constructor({ cause, gas } = {}) {
-    super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction is too low.`, {
-      cause,
-      name: "IntrinsicGasTooLowError"
-    });
-  }
-}
-Object.defineProperty(IntrinsicGasTooLowError, "nodeMessage", {
-  enumerable: true,
-  configurable: true,
-  writable: true,
-  value: /intrinsic gas too low/
-});
-class TransactionTypeNotSupportedError extends BaseError$1 {
-  constructor({ cause }) {
-    super("The transaction type is not supported for this chain.", {
-      cause,
-      name: "TransactionTypeNotSupportedError"
-    });
-  }
-}
-Object.defineProperty(TransactionTypeNotSupportedError, "nodeMessage", {
-  enumerable: true,
-  configurable: true,
-  writable: true,
-  value: /transaction type not valid/
-});
-class TipAboveFeeCapError extends BaseError$1 {
-  constructor({ cause, maxPriorityFeePerGas, maxFeePerGas } = {}) {
-    super([
-      `The provided tip (\`maxPriorityFeePerGas\`${maxPriorityFeePerGas ? ` = ${formatGwei(maxPriorityFeePerGas)} gwei` : ""}) cannot be higher than the fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}).`
-    ].join("\n"), {
-      cause,
-      name: "TipAboveFeeCapError"
-    });
-  }
-}
-Object.defineProperty(TipAboveFeeCapError, "nodeMessage", {
-  enumerable: true,
-  configurable: true,
-  writable: true,
-  value: /max priority fee per gas higher than max fee per gas|tip higher than fee cap/
-});
-class UnknownNodeError extends BaseError$1 {
-  constructor({ cause }) {
-    super(`An error occurred while executing: ${cause == null ? void 0 : cause.shortMessage}`, {
-      cause,
-      name: "UnknownNodeError"
-    });
-  }
-}
-function formatEther(wei, unit = "wei") {
-  return formatUnits(wei, etherUnits[unit]);
-}
-function prettyPrint(args) {
-  const entries = Object.entries(args).map(([key, value]) => {
-    if (value === void 0 || value === false)
-      return null;
-    return [key, value];
-  }).filter(Boolean);
-  const maxLength = entries.reduce((acc, [key]) => Math.max(acc, key.length), 0);
-  return entries.map(([key, value]) => `  ${`${key}:`.padEnd(maxLength + 1)}  ${value}`).join("\n");
-}
-class FeeConflictError extends BaseError$1 {
-  constructor() {
-    super([
-      "Cannot specify both a `gasPrice` and a `maxFeePerGas`/`maxPriorityFeePerGas`.",
-      "Use `maxFeePerGas`/`maxPriorityFeePerGas` for EIP-1559 compatible networks, and `gasPrice` for others."
-    ].join("\n"), { name: "FeeConflictError" });
-  }
-}
-class InvalidLegacyVError extends BaseError$1 {
-  constructor({ v }) {
-    super(`Invalid \`v\` value "${v}". Expected 27 or 28.`, {
-      name: "InvalidLegacyVError"
-    });
-  }
-}
-class InvalidSerializableTransactionError extends BaseError$1 {
-  constructor({ transaction }) {
-    super("Cannot infer a transaction type from provided transaction.", {
-      metaMessages: [
-        "Provided Transaction:",
-        "{",
-        prettyPrint(transaction),
-        "}",
-        "",
-        "To infer the type, either provide:",
-        "- a `type` to the Transaction, or",
-        "- an EIP-1559 Transaction with `maxFeePerGas`, or",
-        "- an EIP-2930 Transaction with `gasPrice` & `accessList`, or",
-        "- an EIP-4844 Transaction with `blobs`, `blobVersionedHashes`, `sidecars`, or",
-        "- an EIP-7702 Transaction with `authorizationList`, or",
-        "- a Legacy Transaction with `gasPrice`"
-      ],
-      name: "InvalidSerializableTransactionError"
-    });
-  }
-}
-class InvalidStorageKeySizeError extends BaseError$1 {
-  constructor({ storageKey }) {
-    super(`Size for storage key "${storageKey}" is invalid. Expected 32 bytes. Got ${Math.floor((storageKey.length - 2) / 2)} bytes.`, { name: "InvalidStorageKeySizeError" });
-  }
-}
-class TransactionNotFoundError extends BaseError$1 {
-  constructor({ blockHash, blockNumber, blockTag, hash: hash2, index }) {
-    let identifier = "Transaction";
-    if (blockTag && index !== void 0)
-      identifier = `Transaction at block time "${blockTag}" at index "${index}"`;
-    if (blockHash && index !== void 0)
-      identifier = `Transaction at block hash "${blockHash}" at index "${index}"`;
-    if (blockNumber && index !== void 0)
-      identifier = `Transaction at block number "${blockNumber}" at index "${index}"`;
-    if (hash2)
-      identifier = `Transaction with hash "${hash2}"`;
-    super(`${identifier} could not be found.`, {
-      name: "TransactionNotFoundError"
-    });
-  }
-}
-class TransactionReceiptNotFoundError extends BaseError$1 {
-  constructor({ hash: hash2 }) {
-    super(`Transaction receipt with hash "${hash2}" could not be found. The Transaction may not be processed on a block yet.`, {
-      name: "TransactionReceiptNotFoundError"
-    });
-  }
-}
-class WaitForTransactionReceiptTimeoutError extends BaseError$1 {
-  constructor({ hash: hash2 }) {
-    super(`Timed out while waiting for transaction with hash "${hash2}" to be confirmed.`, { name: "WaitForTransactionReceiptTimeoutError" });
-  }
-}
-function getNodeError(err, args) {
-  const message = (err.details || "").toLowerCase();
-  const executionRevertedError = err instanceof BaseError$1 ? err.walk((e) => (e == null ? void 0 : e.code) === ExecutionRevertedError.code) : err;
-  if (executionRevertedError instanceof BaseError$1)
-    return new ExecutionRevertedError({
-      cause: err,
-      message: executionRevertedError.details
-    });
-  if (ExecutionRevertedError.nodeMessage.test(message))
-    return new ExecutionRevertedError({
-      cause: err,
-      message: err.details
-    });
-  if (FeeCapTooHighError.nodeMessage.test(message))
-    return new FeeCapTooHighError({
-      cause: err,
-      maxFeePerGas: args == null ? void 0 : args.maxFeePerGas
-    });
-  if (FeeCapTooLowError.nodeMessage.test(message))
-    return new FeeCapTooLowError({
-      cause: err,
-      maxFeePerGas: args == null ? void 0 : args.maxFeePerGas
-    });
-  if (NonceTooHighError.nodeMessage.test(message))
-    return new NonceTooHighError({ cause: err, nonce: args == null ? void 0 : args.nonce });
-  if (NonceTooLowError.nodeMessage.test(message))
-    return new NonceTooLowError({ cause: err, nonce: args == null ? void 0 : args.nonce });
-  if (NonceMaxValueError.nodeMessage.test(message))
-    return new NonceMaxValueError({ cause: err, nonce: args == null ? void 0 : args.nonce });
-  if (InsufficientFundsError.nodeMessage.test(message))
-    return new InsufficientFundsError({ cause: err });
-  if (IntrinsicGasTooHighError.nodeMessage.test(message))
-    return new IntrinsicGasTooHighError({ cause: err, gas: args == null ? void 0 : args.gas });
-  if (IntrinsicGasTooLowError.nodeMessage.test(message))
-    return new IntrinsicGasTooLowError({ cause: err, gas: args == null ? void 0 : args.gas });
-  if (TransactionTypeNotSupportedError.nodeMessage.test(message))
-    return new TransactionTypeNotSupportedError({ cause: err });
-  if (TipAboveFeeCapError.nodeMessage.test(message))
-    return new TipAboveFeeCapError({
-      cause: err,
-      maxFeePerGas: args == null ? void 0 : args.maxFeePerGas,
-      maxPriorityFeePerGas: args == null ? void 0 : args.maxPriorityFeePerGas
-    });
-  return new UnknownNodeError({
-    cause: err
-  });
-}
-function extract(value_, { format }) {
-  if (!format)
-    return {};
-  const value = {};
-  function extract_(formatted2) {
-    const keys = Object.keys(formatted2);
-    for (const key of keys) {
-      if (key in value_)
-        value[key] = value_[key];
-      if (formatted2[key] && typeof formatted2[key] === "object" && !Array.isArray(formatted2[key]))
-        extract_(formatted2[key]);
-    }
-  }
-  const formatted = format(value_ || {});
-  extract_(formatted);
-  return value;
-}
-function defineFormatter(type, format) {
-  return ({ exclude, format: overrides }) => {
-    return {
-      exclude,
-      format: (args) => {
-        const formatted = format(args);
-        if (exclude) {
-          for (const key of exclude) {
-            delete formatted[key];
-          }
-        }
-        return {
-          ...formatted,
-          ...overrides(args)
-        };
-      },
-      type
-    };
-  };
-}
-const rpcTransactionType = {
-  legacy: "0x0",
-  eip2930: "0x1",
-  eip1559: "0x2",
-  eip4844: "0x3",
-  eip7702: "0x4"
-};
-function formatTransactionRequest(request) {
-  const rpcRequest = {};
-  if (typeof request.authorizationList !== "undefined")
-    rpcRequest.authorizationList = formatAuthorizationList(request.authorizationList);
-  if (typeof request.accessList !== "undefined")
-    rpcRequest.accessList = request.accessList;
-  if (typeof request.blobVersionedHashes !== "undefined")
-    rpcRequest.blobVersionedHashes = request.blobVersionedHashes;
-  if (typeof request.blobs !== "undefined") {
-    if (typeof request.blobs[0] !== "string")
-      rpcRequest.blobs = request.blobs.map((x) => bytesToHex(x));
-    else
-      rpcRequest.blobs = request.blobs;
-  }
-  if (typeof request.data !== "undefined")
-    rpcRequest.data = request.data;
-  if (typeof request.from !== "undefined")
-    rpcRequest.from = request.from;
-  if (typeof request.gas !== "undefined")
-    rpcRequest.gas = numberToHex(request.gas);
-  if (typeof request.gasPrice !== "undefined")
-    rpcRequest.gasPrice = numberToHex(request.gasPrice);
-  if (typeof request.maxFeePerBlobGas !== "undefined")
-    rpcRequest.maxFeePerBlobGas = numberToHex(request.maxFeePerBlobGas);
-  if (typeof request.maxFeePerGas !== "undefined")
-    rpcRequest.maxFeePerGas = numberToHex(request.maxFeePerGas);
-  if (typeof request.maxPriorityFeePerGas !== "undefined")
-    rpcRequest.maxPriorityFeePerGas = numberToHex(request.maxPriorityFeePerGas);
-  if (typeof request.nonce !== "undefined")
-    rpcRequest.nonce = numberToHex(request.nonce);
-  if (typeof request.to !== "undefined")
-    rpcRequest.to = request.to;
-  if (typeof request.type !== "undefined")
-    rpcRequest.type = rpcTransactionType[request.type];
-  if (typeof request.value !== "undefined")
-    rpcRequest.value = numberToHex(request.value);
-  return rpcRequest;
-}
-const defineTransactionRequest = /* @__PURE__ */ defineFormatter("transactionRequest", formatTransactionRequest);
-function formatAuthorizationList(authorizationList) {
-  return authorizationList.map((authorization) => ({
-    address: authorization.contractAddress,
-    r: authorization.r,
-    s: authorization.s,
-    chainId: numberToHex(authorization.chainId),
-    nonce: numberToHex(authorization.nonce),
-    ...typeof authorization.yParity !== "undefined" ? { yParity: numberToHex(authorization.yParity) } : {},
-    ...typeof authorization.v !== "undefined" && typeof authorization.yParity === "undefined" ? { v: numberToHex(authorization.v) } : {}
-  }));
-}
-function getAction(client, actionFn, name) {
-  const action_implicit = client[actionFn.name];
-  if (typeof action_implicit === "function")
-    return action_implicit;
-  const action_explicit = client[name];
-  if (typeof action_explicit === "function")
-    return action_explicit;
-  return (params) => actionFn(client, params);
-}
-const maxUint16 = 2n ** 16n - 1n;
-const maxUint256 = 2n ** 256n - 1n;
-function assertRequest(args) {
-  const { account: account_, gasPrice, maxFeePerGas, maxPriorityFeePerGas, to } = args;
-  const account = account_ ? parseAccount(account_) : void 0;
-  if (account && !isAddress(account.address))
-    throw new InvalidAddressError({ address: account.address });
-  if (to && !isAddress(to))
-    throw new InvalidAddressError({ address: to });
-  if (typeof gasPrice !== "undefined" && (typeof maxFeePerGas !== "undefined" || typeof maxPriorityFeePerGas !== "undefined"))
-    throw new FeeConflictError();
-  if (maxFeePerGas && maxFeePerGas > maxUint256)
-    throw new FeeCapTooHighError({ maxFeePerGas });
-  if (maxPriorityFeePerGas && maxFeePerGas && maxPriorityFeePerGas > maxFeePerGas)
-    throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
-}
-class AccountStateConflictError extends BaseError$1 {
-  constructor({ address }) {
-    super(`State for account "${address}" is set multiple times.`, {
-      name: "AccountStateConflictError"
-    });
-  }
-}
-class StateAssignmentConflictError extends BaseError$1 {
-  constructor() {
-    super("state and stateDiff are set on the same account.", {
-      name: "StateAssignmentConflictError"
-    });
-  }
-}
-function prettyStateMapping(stateMapping) {
-  return stateMapping.reduce((pretty, { slot, value }) => {
-    return `${pretty}        ${slot}: ${value}
-`;
-  }, "");
-}
-function prettyStateOverride(stateOverride) {
-  return stateOverride.reduce((pretty, { address, ...state }) => {
-    let val = `${pretty}    ${address}:
-`;
-    if (state.nonce)
-      val += `      nonce: ${state.nonce}
-`;
-    if (state.balance)
-      val += `      balance: ${state.balance}
-`;
-    if (state.code)
-      val += `      code: ${state.code}
-`;
-    if (state.state) {
-      val += "      state:\n";
-      val += prettyStateMapping(state.state);
-    }
-    if (state.stateDiff) {
-      val += "      stateDiff:\n";
-      val += prettyStateMapping(state.stateDiff);
-    }
-    return val;
-  }, "  State Override:\n").slice(0, -1);
-}
-function serializeStateMapping(stateMapping) {
-  if (!stateMapping || stateMapping.length === 0)
-    return void 0;
-  return stateMapping.reduce((acc, { slot, value }) => {
-    if (slot.length !== 66)
-      throw new InvalidBytesLengthError({
-        size: slot.length,
-        targetSize: 66,
-        type: "hex"
-      });
-    if (value.length !== 66)
-      throw new InvalidBytesLengthError({
-        size: value.length,
-        targetSize: 66,
-        type: "hex"
-      });
-    acc[slot] = value;
-    return acc;
-  }, {});
-}
-function serializeAccountStateOverride(parameters) {
-  const { balance, nonce, state, stateDiff, code } = parameters;
-  const rpcAccountStateOverride = {};
-  if (code !== void 0)
-    rpcAccountStateOverride.code = code;
-  if (balance !== void 0)
-    rpcAccountStateOverride.balance = numberToHex(balance);
-  if (nonce !== void 0)
-    rpcAccountStateOverride.nonce = numberToHex(nonce);
-  if (state !== void 0)
-    rpcAccountStateOverride.state = serializeStateMapping(state);
-  if (stateDiff !== void 0) {
-    if (rpcAccountStateOverride.state)
-      throw new StateAssignmentConflictError();
-    rpcAccountStateOverride.stateDiff = serializeStateMapping(stateDiff);
-  }
-  return rpcAccountStateOverride;
-}
-function serializeStateOverride(parameters) {
-  if (!parameters)
-    return void 0;
-  const rpcStateOverride = {};
-  for (const { address, ...accountState } of parameters) {
-    if (!isAddress(address, { strict: false }))
-      throw new InvalidAddressError({ address });
-    if (rpcStateOverride[address])
-      throw new AccountStateConflictError({ address });
-    rpcStateOverride[address] = serializeAccountStateOverride(accountState);
-  }
-  return rpcStateOverride;
-}
-const multicall3Abi = [
-  {
-    inputs: [
-      {
-        components: [
-          {
-            name: "target",
-            type: "address"
-          },
-          {
-            name: "allowFailure",
-            type: "bool"
-          },
-          {
-            name: "callData",
-            type: "bytes"
-          }
-        ],
-        name: "calls",
-        type: "tuple[]"
-      }
-    ],
-    name: "aggregate3",
-    outputs: [
-      {
-        components: [
-          {
-            name: "success",
-            type: "bool"
-          },
-          {
-            name: "returnData",
-            type: "bytes"
-          }
-        ],
-        name: "returnData",
-        type: "tuple[]"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
-  }
-];
-const universalResolverErrors = [
-  {
-    inputs: [],
-    name: "ResolverNotFound",
-    type: "error"
-  },
-  {
-    inputs: [],
-    name: "ResolverWildcardNotSupported",
-    type: "error"
-  },
-  {
-    inputs: [],
-    name: "ResolverNotContract",
-    type: "error"
-  },
-  {
-    inputs: [
-      {
-        name: "returnData",
-        type: "bytes"
-      }
-    ],
-    name: "ResolverError",
-    type: "error"
-  },
-  {
-    inputs: [
-      {
-        components: [
-          {
-            name: "status",
-            type: "uint16"
-          },
-          {
-            name: "message",
-            type: "string"
-          }
-        ],
-        name: "errors",
-        type: "tuple[]"
-      }
-    ],
-    name: "HttpError",
-    type: "error"
-  }
-];
-const universalResolverResolveAbi = [
-  ...universalResolverErrors,
-  {
-    name: "resolve",
-    type: "function",
-    stateMutability: "view",
-    inputs: [
-      { name: "name", type: "bytes" },
-      { name: "data", type: "bytes" }
-    ],
-    outputs: [
-      { name: "", type: "bytes" },
-      { name: "address", type: "address" }
-    ]
-  },
-  {
-    name: "resolve",
-    type: "function",
-    stateMutability: "view",
-    inputs: [
-      { name: "name", type: "bytes" },
-      { name: "data", type: "bytes" },
-      { name: "gateways", type: "string[]" }
-    ],
-    outputs: [
-      { name: "", type: "bytes" },
-      { name: "address", type: "address" }
-    ]
-  }
-];
-const universalResolverReverseAbi = [
-  ...universalResolverErrors,
-  {
-    name: "reverse",
-    type: "function",
-    stateMutability: "view",
-    inputs: [{ type: "bytes", name: "reverseName" }],
-    outputs: [
-      { type: "string", name: "resolvedName" },
-      { type: "address", name: "resolvedAddress" },
-      { type: "address", name: "reverseResolver" },
-      { type: "address", name: "resolver" }
-    ]
-  },
-  {
-    name: "reverse",
-    type: "function",
-    stateMutability: "view",
-    inputs: [
-      { type: "bytes", name: "reverseName" },
-      { type: "string[]", name: "gateways" }
-    ],
-    outputs: [
-      { type: "string", name: "resolvedName" },
-      { type: "address", name: "resolvedAddress" },
-      { type: "address", name: "reverseResolver" },
-      { type: "address", name: "resolver" }
-    ]
-  }
-];
-const textResolverAbi = [
-  {
-    name: "text",
-    type: "function",
-    stateMutability: "view",
-    inputs: [
-      { name: "name", type: "bytes32" },
-      { name: "key", type: "string" }
-    ],
-    outputs: [{ name: "", type: "string" }]
-  }
-];
-const addressResolverAbi = [
-  {
-    name: "addr",
-    type: "function",
-    stateMutability: "view",
-    inputs: [{ name: "name", type: "bytes32" }],
-    outputs: [{ name: "", type: "address" }]
-  },
-  {
-    name: "addr",
-    type: "function",
-    stateMutability: "view",
-    inputs: [
-      { name: "name", type: "bytes32" },
-      { name: "coinType", type: "uint256" }
-    ],
-    outputs: [{ name: "", type: "bytes" }]
-  }
-];
-const universalSignatureValidatorAbi = [
-  {
-    inputs: [
-      {
-        name: "_signer",
-        type: "address"
-      },
-      {
-        name: "_hash",
-        type: "bytes32"
-      },
-      {
-        name: "_signature",
-        type: "bytes"
-      }
-    ],
-    stateMutability: "nonpayable",
-    type: "constructor"
-  },
-  {
-    inputs: [
-      {
-        name: "_signer",
-        type: "address"
-      },
-      {
-        name: "_hash",
-        type: "bytes32"
-      },
-      {
-        name: "_signature",
-        type: "bytes"
-      }
-    ],
-    outputs: [
-      {
-        type: "bool"
-      }
-    ],
-    stateMutability: "nonpayable",
-    type: "function",
-    name: "isValidSig"
-  }
-];
-function bytesToBigInt(bytes, opts = {}) {
-  if (typeof opts.size !== "undefined")
-    assertSize(bytes, { size: opts.size });
-  const hex = bytesToHex(bytes, opts);
-  return hexToBigInt(hex, opts);
-}
-function bytesToBool(bytes_, opts = {}) {
-  let bytes = bytes_;
-  if (typeof opts.size !== "undefined") {
-    assertSize(bytes, { size: opts.size });
-    bytes = trim(bytes);
-  }
-  if (bytes.length > 1 || bytes[0] > 1)
-    throw new InvalidBytesBooleanError(bytes);
-  return Boolean(bytes[0]);
-}
-function bytesToNumber(bytes, opts = {}) {
-  if (typeof opts.size !== "undefined")
-    assertSize(bytes, { size: opts.size });
-  const hex = bytesToHex(bytes, opts);
-  return hexToNumber(hex, opts);
-}
-function bytesToString(bytes_, opts = {}) {
-  let bytes = bytes_;
-  if (typeof opts.size !== "undefined") {
-    assertSize(bytes, { size: opts.size });
-    bytes = trim(bytes, { dir: "right" });
-  }
-  return new TextDecoder().decode(bytes);
-}
-function decodeAbiParameters(params, data) {
-  const bytes = typeof data === "string" ? hexToBytes(data) : data;
-  const cursor = createCursor(bytes);
-  if (size(bytes) === 0 && params.length > 0)
-    throw new AbiDecodingZeroDataError();
-  if (size(data) && size(data) < 32)
-    throw new AbiDecodingDataSizeTooSmallError({
-      data: typeof data === "string" ? data : bytesToHex(data),
-      params,
-      size: size(data)
-    });
-  let consumed = 0;
-  const values = [];
-  for (let i = 0; i < params.length; ++i) {
-    const param = params[i];
-    cursor.setPosition(consumed);
-    const [data2, consumed_] = decodeParameter(cursor, param, {
-      staticPosition: 0
-    });
-    consumed += consumed_;
-    values.push(data2);
-  }
-  return values;
-}
-function decodeParameter(cursor, param, { staticPosition }) {
-  const arrayComponents = getArrayComponents(param.type);
-  if (arrayComponents) {
-    const [length, type] = arrayComponents;
-    return decodeArray(cursor, { ...param, type }, { length, staticPosition });
-  }
-  if (param.type === "tuple")
-    return decodeTuple(cursor, param, { staticPosition });
-  if (param.type === "address")
-    return decodeAddress(cursor);
-  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 InvalidAbiDecodingTypeError(param.type, {
-    docsPath: "/docs/contract/decodeAbiParameters"
-  });
-}
-const sizeOfLength = 32;
-const sizeOfOffset = 32;
-function decodeAddress(cursor) {
-  const value = cursor.readBytes(32);
-  return [checksumAddress(bytesToHex(sliceBytes(value, -20))), 32];
-}
-function decodeArray(cursor, param, { length, staticPosition }) {
-  if (!length) {
-    const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
-    const start = staticPosition + offset;
-    const startOfData = start + sizeOfLength;
-    cursor.setPosition(start);
-    const length2 = bytesToNumber(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, {
-        staticPosition: startOfData
-      });
-      consumed2 += consumed_;
-      value2.push(data);
-    }
-    cursor.setPosition(staticPosition + 32);
-    return [value2, 32];
-  }
-  if (hasDynamicChild(param)) {
-    const offset = bytesToNumber(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, {
-        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, {
-      staticPosition: staticPosition + consumed
-    });
-    consumed += consumed_;
-    value.push(data);
-  }
-  return [value, consumed];
-}
-function decodeBool(cursor) {
-  return [bytesToBool(cursor.readBytes(32), { size: 32 }), 32];
-}
-function decodeBytes(cursor, param, { staticPosition }) {
-  const [_, size2] = param.type.split("bytes");
-  if (!size2) {
-    const offset = bytesToNumber(cursor.readBytes(32));
-    cursor.setPosition(staticPosition + offset);
-    const length = bytesToNumber(cursor.readBytes(32));
-    if (length === 0) {
-      cursor.setPosition(staticPosition + 32);
-      return ["0x", 32];
-    }
-    const data = cursor.readBytes(length);
-    cursor.setPosition(staticPosition + 32);
-    return [bytesToHex(data), 32];
-  }
-  const value = bytesToHex(cursor.readBytes(Number.parseInt(size2), 32));
-  return [value, 32];
-}
-function decodeNumber(cursor, param) {
-  const signed = param.type.startsWith("int");
-  const size2 = Number.parseInt(param.type.split("int")[1] || "256");
-  const value = cursor.readBytes(32);
-  return [
-    size2 > 48 ? bytesToBigInt(value, { signed }) : bytesToNumber(value, { signed }),
-    32
-  ];
-}
-function decodeTuple(cursor, param, { staticPosition }) {
-  const hasUnnamedChild = param.components.length === 0 || param.components.some(({ name }) => !name);
-  const value = hasUnnamedChild ? [] : {};
-  let consumed = 0;
-  if (hasDynamicChild(param)) {
-    const offset = bytesToNumber(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, {
-        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, {
-      staticPosition
-    });
-    value[hasUnnamedChild ? i : component == null ? void 0 : component.name] = data;
-    consumed += consumed_;
-  }
-  return [value, consumed];
-}
-function decodeString(cursor, { staticPosition }) {
-  const offset = bytesToNumber(cursor.readBytes(32));
-  const start = staticPosition + offset;
-  cursor.setPosition(start);
-  const length = bytesToNumber(cursor.readBytes(32));
-  if (length === 0) {
-    cursor.setPosition(staticPosition + 32);
-    return ["", 32];
-  }
-  const data = cursor.readBytes(length, 32);
-  const value = bytesToString(trim(data));
-  cursor.setPosition(staticPosition + 32);
-  return [value, 32];
-}
-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 hash = (value) => keccak256(toBytes(value));
-function hashSignature(sig) {
-  return hash(sig);
-}
-const version = "1.0.8";
-class BaseError extends Error {
-  constructor(shortMessage, args = {}) {
-    var _a;
-    const details = args.cause instanceof BaseError ? args.cause.details : ((_a = args.cause) == null ? void 0 : _a.message) ? args.cause.message : args.details;
-    const docsPath2 = args.cause instanceof BaseError ? args.cause.docsPath || args.docsPath : args.docsPath;
-    const message = [
-      shortMessage || "An error occurred.",
-      "",
-      ...args.metaMessages ? [...args.metaMessages, ""] : [],
-      ...docsPath2 ? [`Docs: https://abitype.dev${docsPath2}`] : [],
-      ...details ? [`Details: ${details}`] : [],
-      `Version: abitype@${version}`
-    ].join("\n");
-    super(message);
-    Object.defineProperty(this, "details", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "docsPath", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "metaMessages", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "shortMessage", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "AbiTypeError"
-    });
-    if (args.cause)
-      this.cause = args.cause;
-    this.details = details;
-    this.docsPath = docsPath2;
-    this.metaMessages = args.metaMessages;
-    this.shortMessage = shortMessage;
-  }
-}
-function execTyped(regex, string) {
-  const match = regex.exec(string);
-  return match == null ? void 0 : match.groups;
-}
-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 isTupleRegex = /^\(.+?\).*?$/;
-const tupleRegex = /^tuple(?<array>(\[(\d*)\])*)$/;
-function formatAbiParameter(abiParameter) {
-  let type = abiParameter.type;
-  if (tupleRegex.test(abiParameter.type) && "components" in abiParameter) {
-    type = "(";
-    const length = abiParameter.components.length;
-    for (let i = 0; i < length; i++) {
-      const component = abiParameter.components[i];
-      type += formatAbiParameter(component);
-      if (i < length - 1)
-        type += ", ";
-    }
-    const result = execTyped(tupleRegex, abiParameter.type);
-    type += `)${(result == null ? void 0 : result.array) ?? ""}`;
-    return formatAbiParameter({
-      ...abiParameter,
-      type
-    });
-  }
-  if ("indexed" in abiParameter && abiParameter.indexed)
-    type = `${type} indexed`;
-  if (abiParameter.name)
-    return `${type} ${abiParameter.name}`;
-  return type;
-}
-function formatAbiParameters(abiParameters) {
-  let params = "";
-  const length = abiParameters.length;
-  for (let i = 0; i < length; i++) {
-    const abiParameter = abiParameters[i];
-    params += formatAbiParameter(abiParameter);
-    if (i !== length - 1)
-      params += ", ";
-  }
-  return params;
-}
-function formatAbiItem(abiItem) {
-  var _a;
-  if (abiItem.type === "function")
-    return `function ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability && abiItem.stateMutability !== "nonpayable" ? ` ${abiItem.stateMutability}` : ""}${((_a = abiItem.outputs) == null ? void 0 : _a.length) ? ` returns (${formatAbiParameters(abiItem.outputs)})` : ""}`;
-  if (abiItem.type === "event")
-    return `event ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
-  if (abiItem.type === "error")
-    return `error ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
-  if (abiItem.type === "constructor")
-    return `constructor(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability === "payable" ? " payable" : ""}`;
-  if (abiItem.type === "fallback")
-    return `fallback() external${abiItem.stateMutability === "payable" ? " payable" : ""}`;
-  return "receive() external payable";
-}
-const errorSignatureRegex = /^error (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
-function isErrorSignature(signature) {
-  return errorSignatureRegex.test(signature);
-}
-function execErrorSignature(signature) {
-  return execTyped(errorSignatureRegex, signature);
-}
-const eventSignatureRegex = /^event (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
-function isEventSignature(signature) {
-  return eventSignatureRegex.test(signature);
-}
-function execEventSignature(signature) {
-  return execTyped(eventSignatureRegex, signature);
-}
-const functionSignatureRegex = /^function (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)(?: (?<scope>external|public{1}))?(?: (?<stateMutability>pure|view|nonpayable|payable{1}))?(?: returns\s?\((?<returns>.*?)\))?$/;
-function isFunctionSignature(signature) {
-  return functionSignatureRegex.test(signature);
-}
-function execFunctionSignature(signature) {
-  return execTyped(functionSignatureRegex, signature);
-}
-const structSignatureRegex = /^struct (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*) \{(?<properties>.*?)\}$/;
-function isStructSignature(signature) {
-  return structSignatureRegex.test(signature);
-}
-function execStructSignature(signature) {
-  return execTyped(structSignatureRegex, signature);
-}
-const constructorSignatureRegex = /^constructor\((?<parameters>.*?)\)(?:\s(?<stateMutability>payable{1}))?$/;
-function isConstructorSignature(signature) {
-  return constructorSignatureRegex.test(signature);
-}
-function execConstructorSignature(signature) {
-  return execTyped(constructorSignatureRegex, signature);
-}
-const fallbackSignatureRegex = /^fallback\(\) external(?:\s(?<stateMutability>payable{1}))?$/;
-function isFallbackSignature(signature) {
-  return fallbackSignatureRegex.test(signature);
-}
-function execFallbackSignature(signature) {
-  return execTyped(fallbackSignatureRegex, signature);
-}
-const receiveSignatureRegex = /^receive\(\) external payable$/;
-function isReceiveSignature(signature) {
-  return receiveSignatureRegex.test(signature);
-}
-const eventModifiers = /* @__PURE__ */ new Set(["indexed"]);
-const functionModifiers = /* @__PURE__ */ new Set([
-  "calldata",
-  "memory",
-  "storage"
-]);
-class InvalidAbiItemError extends BaseError {
-  constructor({ signature }) {
-    super("Failed to parse ABI item.", {
-      details: `parseAbiItem(${JSON.stringify(signature, null, 2)})`,
-      docsPath: "/api/human#parseabiitem-1"
-    });
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "InvalidAbiItemError"
-    });
-  }
-}
-class UnknownTypeError extends BaseError {
-  constructor({ type }) {
-    super("Unknown type.", {
-      metaMessages: [
-        `Type "${type}" is not a valid ABI type. Perhaps you forgot to include a struct signature?`
-      ]
-    });
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "UnknownTypeError"
-    });
-  }
-}
-class UnknownSolidityTypeError extends BaseError {
-  constructor({ type }) {
-    super("Unknown type.", {
-      metaMessages: [`Type "${type}" is not a valid ABI type.`]
-    });
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "UnknownSolidityTypeError"
-    });
-  }
-}
-class InvalidParameterError extends BaseError {
-  constructor({ param }) {
-    super("Invalid ABI parameter.", {
-      details: param
-    });
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "InvalidParameterError"
-    });
-  }
-}
-class SolidityProtectedKeywordError extends BaseError {
-  constructor({ param, name }) {
-    super("Invalid ABI parameter.", {
-      details: param,
-      metaMessages: [
-        `"${name}" is a protected Solidity keyword. More info: https://docs.soliditylang.org/en/latest/cheatsheet.html`
-      ]
-    });
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "SolidityProtectedKeywordError"
-    });
-  }
-}
-class InvalidModifierError extends BaseError {
-  constructor({ param, type, modifier }) {
-    super("Invalid ABI parameter.", {
-      details: param,
-      metaMessages: [
-        `Modifier "${modifier}" not allowed${type ? ` in "${type}" type` : ""}.`
-      ]
-    });
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "InvalidModifierError"
-    });
-  }
-}
-class InvalidFunctionModifierError extends BaseError {
-  constructor({ param, type, modifier }) {
-    super("Invalid ABI parameter.", {
-      details: param,
-      metaMessages: [
-        `Modifier "${modifier}" not allowed${type ? ` in "${type}" type` : ""}.`,
-        `Data location can only be specified for array, struct, or mapping types, but "${modifier}" was given.`
-      ]
-    });
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "InvalidFunctionModifierError"
-    });
-  }
-}
-class InvalidAbiTypeParameterError extends BaseError {
-  constructor({ abiParameter }) {
-    super("Invalid ABI parameter.", {
-      details: JSON.stringify(abiParameter, null, 2),
-      metaMessages: ["ABI parameter type is invalid."]
-    });
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "InvalidAbiTypeParameterError"
-    });
-  }
-}
-class InvalidSignatureError extends BaseError {
-  constructor({ signature, type }) {
-    super(`Invalid ${type} signature.`, {
-      details: signature
-    });
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "InvalidSignatureError"
-    });
-  }
-}
-class UnknownSignatureError extends BaseError {
-  constructor({ signature }) {
-    super("Unknown signature.", {
-      details: signature
-    });
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "UnknownSignatureError"
-    });
-  }
-}
-class InvalidStructSignatureError extends BaseError {
-  constructor({ signature }) {
-    super("Invalid struct signature.", {
-      details: signature,
-      metaMessages: ["No properties exist."]
-    });
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "InvalidStructSignatureError"
-    });
-  }
-}
-class CircularReferenceError extends BaseError {
-  constructor({ type }) {
-    super("Circular reference detected.", {
-      metaMessages: [`Struct "${type}" is a circular reference.`]
-    });
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "CircularReferenceError"
-    });
-  }
-}
-class InvalidParenthesisError extends BaseError {
-  constructor({ current, depth }) {
-    super("Unbalanced parentheses.", {
-      metaMessages: [
-        `"${current.trim()}" has too many ${depth > 0 ? "opening" : "closing"} parentheses.`
-      ],
-      details: `Depth "${depth}"`
-    });
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: "InvalidParenthesisError"
-    });
-  }
-}
-function getParameterCacheKey(param, type, structs) {
-  let structKey = "";
-  if (structs)
-    for (const struct of Object.entries(structs)) {
-      if (!struct)
-        continue;
-      let propertyKey = "";
-      for (const property of struct[1]) {
-        propertyKey += `[${property.type}${property.name ? `:${property.name}` : ""}]`;
-      }
-      structKey += `(${struct[0]}{${propertyKey}})`;
-    }
-  if (type)
-    return `${type}:${param}${structKey}`;
-  return param;
-}
-const parameterCache = /* @__PURE__ */ new Map([
-  // Unnamed
-  ["address", { type: "address" }],
-  ["bool", { type: "bool" }],
-  ["bytes", { type: "bytes" }],
-  ["bytes32", { type: "bytes32" }],
-  ["int", { type: "int256" }],
-  ["int256", { type: "int256" }],
-  ["string", { type: "string" }],
-  ["uint", { type: "uint256" }],
-  ["uint8", { type: "uint8" }],
-  ["uint16", { type: "uint16" }],
-  ["uint24", { type: "uint24" }],
-  ["uint32", { type: "uint32" }],
-  ["uint64", { type: "uint64" }],
-  ["uint96", { type: "uint96" }],
-  ["uint112", { type: "uint112" }],
-  ["uint160", { type: "uint160" }],
-  ["uint192", { type: "uint192" }],
-  ["uint256", { type: "uint256" }],
-  // Named
-  ["address owner", { type: "address", name: "owner" }],
-  ["address to", { type: "address", name: "to" }],
-  ["bool approved", { type: "bool", name: "approved" }],
-  ["bytes _data", { type: "bytes", name: "_data" }],
-  ["bytes data", { type: "bytes", name: "data" }],
-  ["bytes signature", { type: "bytes", name: "signature" }],
-  ["bytes32 hash", { type: "bytes32", name: "hash" }],
-  ["bytes32 r", { type: "bytes32", name: "r" }],
-  ["bytes32 root", { type: "bytes32", name: "root" }],
-  ["bytes32 s", { type: "bytes32", name: "s" }],
-  ["string name", { type: "string", name: "name" }],
-  ["string symbol", { type: "string", name: "symbol" }],
-  ["string tokenURI", { type: "string", name: "tokenURI" }],
-  ["uint tokenId", { type: "uint256", name: "tokenId" }],
-  ["uint8 v", { type: "uint8", name: "v" }],
-  ["uint256 balance", { type: "uint256", name: "balance" }],
-  ["uint256 tokenId", { type: "uint256", name: "tokenId" }],
-  ["uint256 value", { type: "uint256", name: "value" }],
-  // Indexed
-  [
-    "event:address indexed from",
-    { type: "address", name: "from", indexed: true }
-  ],
-  ["event:address indexed to", { type: "address", name: "to", indexed: true }],
-  [
-    "event:uint indexed tokenId",
-    { type: "uint256", name: "tokenId", indexed: true }
-  ],
-  [
-    "event:uint256 indexed tokenId",
-    { type: "uint256", name: "tokenId", indexed: true }
-  ]
-]);
-function parseSignature(signature, structs = {}) {
-  if (isFunctionSignature(signature))
-    return parseFunctionSignature(signature, structs);
-  if (isEventSignature(signature))
-    return parseEventSignature(signature, structs);
-  if (isErrorSignature(signature))
-    return parseErrorSignature(signature, structs);
-  if (isConstructorSignature(signature))
-    return parseConstructorSignature(signature, structs);
-  if (isFallbackSignature(signature))
-    return parseFallbackSignature(signature);
-  if (isReceiveSignature(signature))
-    return {
-      type: "receive",
-      stateMutability: "payable"
-    };
-  throw new UnknownSignatureError({ signature });
-}
-function parseFunctionSignature(signature, structs = {}) {
-  const match = execFunctionSignature(signature);
-  if (!match)
-    throw new InvalidSignatureError({ signature, type: "function" });
-  const inputParams = splitParameters(match.parameters);
-  const inputs = [];
-  const inputLength = inputParams.length;
-  for (let i = 0; i < inputLength; i++) {
-    inputs.push(parseAbiParameter(inputParams[i], {
-      modifiers: functionModifiers,
-      structs,
-      type: "function"
-    }));
-  }
-  const outputs = [];
-  if (match.returns) {
-    const outputParams = splitParameters(match.returns);
-    const outputLength = outputParams.length;
-    for (let i = 0; i < outputLength; i++) {
-      outputs.push(parseAbiParameter(outputParams[i], {
-        modifiers: functionModifiers,
-        structs,
-        type: "function"
-      }));
-    }
-  }
-  return {
-    name: match.name,
-    type: "function",
-    stateMutability: match.stateMutability ?? "nonpayable",
-    inputs,
-    outputs
-  };
-}
-function parseEventSignature(signature, structs = {}) {
-  const match = execEventSignature(signature);
-  if (!match)
-    throw new InvalidSignatureError({ signature, type: "event" });
-  const params = splitParameters(match.parameters);
-  const abiParameters = [];
-  const length = params.length;
-  for (let i = 0; i < length; i++)
-    abiParameters.push(parseAbiParameter(params[i], {
-      modifiers: eventModifiers,
-      structs,
-      type: "event"
-    }));
-  return { name: match.name, type: "event", inputs: abiParameters };
-}
-function parseErrorSignature(signature, structs = {}) {
-  const match = execErrorSignature(signature);
-  if (!match)
-    throw new InvalidSignatureError({ signature, type: "error" });
-  const params = splitParameters(match.parameters);
-  const abiParameters = [];
-  const length = params.length;
-  for (let i = 0; i < length; i++)
-    abiParameters.push(parseAbiParameter(params[i], { structs, type: "error" }));
-  return { name: match.name, type: "error", inputs: abiParameters };
-}
-function parseConstructorSignature(signature, structs = {}) {
-  const match = execConstructorSignature(signature);
-  if (!match)
-    throw new InvalidSignatureError({ signature, type: "constructor" });
-  const params = splitParameters(match.parameters);
-  const abiParameters = [];
-  const length = params.length;
-  for (let i = 0; i < length; i++)
-    abiParameters.push(parseAbiParameter(params[i], { structs, type: "constructor" }));
-  return {
-    type: "constructor",
-    stateMutability: match.stateMutability ?? "nonpayable",
-    inputs: abiParameters
-  };
-}
-function parseFallbackSignature(signature) {
-  const match = execFallbackSignature(signature);
-  if (!match)
-    throw new InvalidSignatureError({ signature, type: "fallback" });
-  return {
-    type: "fallback",
-    stateMutability: match.stateMutability ?? "nonpayable"
-  };
-}
-const abiParameterWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
-const abiParameterWithTupleRegex = /^\((?<type>.+?)\)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
-const dynamicIntegerRegex = /^u?int$/;
-function parseAbiParameter(param, options) {
-  var _a, _b;
-  const parameterCacheKey = getParameterCacheKey(param, options == null ? void 0 : options.type, options == null ? void 0 : options.structs);
-  if (parameterCache.has(parameterCacheKey))
-    return parameterCache.get(parameterCacheKey);
-  const isTuple = isTupleRegex.test(param);
-  const match = execTyped(isTuple ? abiParameterWithTupleRegex : abiParameterWithoutTupleRegex, param);
-  if (!match)
-    throw new InvalidParameterError({ param });
-  if (match.name && isSolidityKeyword(match.name))
-    throw new SolidityProtectedKeywordError({ param, name: match.name });
-  const name = match.name ? { name: match.name } : {};
-  const indexed = match.modifier === "indexed" ? { indexed: true } : {};
-  const structs = (options == null ? void 0 : options.structs) ?? {};
-  let type;
-  let components = {};
-  if (isTuple) {
-    type = "tuple";
-    const params = splitParameters(match.type);
-    const components_ = [];
-    const length = params.length;
-    for (let i = 0; i < length; i++) {
-      components_.push(parseAbiParameter(params[i], { structs }));
-    }
-    components = { components: components_ };
-  } else if (match.type in structs) {
-    type = "tuple";
-    components = { components: structs[match.type] };
-  } else if (dynamicIntegerRegex.test(match.type)) {
-    type = `${match.type}256`;
-  } else {
-    type = match.type;
-    if (!((options == null ? void 0 : options.type) === "struct") && !isSolidityType(type))
-      throw new UnknownSolidityTypeError({ type });
-  }
-  if (match.modifier) {
-    if (!((_b = (_a = options == null ? void 0 : options.modifiers) == null ? void 0 : _a.has) == null ? void 0 : _b.call(_a, match.modifier)))
-      throw new InvalidModifierError({
-        param,
-        type: options == null ? void 0 : options.type,
-        modifier: match.modifier
-      });
-    if (functionModifiers.has(match.modifier) && !isValidDataLocation(type, !!match.array))
-      throw new InvalidFunctionModifierError({
-        param,
-        type: options == null ? void 0 : options.type,
-        modifier: match.modifier
-      });
-  }
-  const abiParameter = {
-    type: `${type}${match.array ?? ""}`,
-    ...name,
-    ...indexed,
-    ...components
-  };
-  parameterCache.set(parameterCacheKey, abiParameter);
-  return abiParameter;
-}
-function splitParameters(params, result = [], current = "", depth = 0) {
-  const length = params.trim().length;
-  for (let i = 0; i < length; i++) {
-    const char = params[i];
-    const tail = params.slice(i + 1);
-    switch (char) {
-      case ",":
-        return depth === 0 ? splitParameters(tail, [...result, current.trim()]) : splitParameters(tail, result, `${current}${char}`, depth);
-      case "(":
-        return splitParameters(tail, result, `${current}${char}`, depth + 1);
-      case ")":
-        return splitParameters(tail, result, `${current}${char}`, depth - 1);
-      default:
-        return splitParameters(tail, result, `${current}${char}`, depth);
-    }
-  }
-  if (current === "")
-    return result;
-  if (depth !== 0)
-    throw new InvalidParenthesisError({ current, depth });
-  result.push(current.trim());
-  return result;
-}
-function isSolidityType(type) {
-  return type === "address" || type === "bool" || type === "function" || type === "string" || bytesRegex.test(type) || integerRegex.test(type);
-}
-const protectedKeywordsRegex = /^(?:after|alias|anonymous|apply|auto|byte|calldata|case|catch|constant|copyof|default|defined|error|event|external|false|final|function|immutable|implements|in|indexed|inline|internal|let|mapping|match|memory|mutable|null|of|override|partial|private|promise|public|pure|reference|relocatable|return|returns|sizeof|static|storage|struct|super|supports|switch|this|true|try|typedef|typeof|var|view|virtual)$/;
-function isSolidityKeyword(name) {
-  return name === "address" || name === "bool" || name === "function" || name === "string" || name === "tuple" || bytesRegex.test(name) || integerRegex.test(name) || protectedKeywordsRegex.test(name);
-}
-function isValidDataLocation(type, isArray) {
-  return isArray || type === "bytes" || type === "string" || type === "tuple";
-}
-function parseStructs(signatures) {
-  const shallowStructs = {};
-  const signaturesLength = signatures.length;
-  for (let i = 0; i < signaturesLength; i++) {
-    const signature = signatures[i];
-    if (!isStructSignature(signature))
-      continue;
-    const match = execStructSignature(signature);
-    if (!match)
-      throw new InvalidSignatureError({ signature, type: "struct" });
-    const properties = match.properties.split(";");
-    const components = [];
-    const propertiesLength = properties.length;
-    for (let k = 0; k < propertiesLength; k++) {
-      const property = properties[k];
-      const trimmed = property.trim();
-      if (!trimmed)
-        continue;
-      const abiParameter = parseAbiParameter(trimmed, {
-        type: "struct"
-      });
-      components.push(abiParameter);
-    }
-    if (!components.length)
-      throw new InvalidStructSignatureError({ signature });
-    shallowStructs[match.name] = components;
-  }
-  const resolvedStructs = {};
-  const entries = Object.entries(shallowStructs);
-  const entriesLength = entries.length;
-  for (let i = 0; i < entriesLength; i++) {
-    const [name, parameters] = entries[i];
-    resolvedStructs[name] = resolveStructs(parameters, shallowStructs);
-  }
-  return resolvedStructs;
-}
-const typeWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?$/;
-function resolveStructs(abiParameters, structs, ancestors = /* @__PURE__ */ new Set()) {
-  const components = [];
-  const length = abiParameters.length;
-  for (let i = 0; i < length; i++) {
-    const abiParameter = abiParameters[i];
-    const isTuple = isTupleRegex.test(abiParameter.type);
-    if (isTuple)
-      components.push(abiParameter);
-    else {
-      const match = execTyped(typeWithoutTupleRegex, abiParameter.type);
-      if (!(match == null ? void 0 : match.type))
-        throw new InvalidAbiTypeParameterError({ abiParameter });
-      const { array, type } = match;
-      if (type in structs) {
-        if (ancestors.has(type))
-          throw new CircularReferenceError({ type });
-        components.push({
-          ...abiParameter,
-          type: `tuple${array ?? ""}`,
-          components: resolveStructs(structs[type] ?? [], structs, /* @__PURE__ */ new Set([...ancestors, type]))
-        });
-      } else {
-        if (isSolidityType(type))
-          components.push(abiParameter);
-        else
-          throw new UnknownTypeError({ type });
-      }
-    }
-  }
-  return components;
-}
-function parseAbi(signatures) {
-  const structs = parseStructs(signatures);
-  const abi = [];
-  const length = signatures.length;
-  for (let i = 0; i < length; i++) {
-    const signature = signatures[i];
-    if (isStructSignature(signature))
-      continue;
-    abi.push(parseSignature(signature, structs));
-  }
-  return abi;
-}
-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", ""].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;
-}
-const toSignature = (def) => {
-  const def_ = (() => {
-    if (typeof def === "string")
-      return def;
-    return formatAbiItem(def);
-  })();
-  return normalizeSignature(def_);
-};
-function toSignatureHash(fn) {
-  return hashSignature(toSignature(fn));
-}
-const toEventSelector = toSignatureHash;
-const toFunctionSelector = (fn) => slice(toSignatureHash(fn), 0, 4);
-function getAbiItem(parameters) {
-  const { abi, args = [], name } = parameters;
-  const isSelector = isHex(name, { strict: false });
-  const abiItems = abi.filter((abiItem) => {
-    if (isSelector) {
-      if (abiItem.type === "function")
-        return toFunctionSelector(abiItem) === name;
-      if (abiItem.type === "event")
-        return toEventSelector(abiItem) === name;
-      return false;
-    }
-    return "name" in abiItem && abiItem.name === name;
-  });
-  if (abiItems.length === 0)
-    return void 0;
-  if (abiItems.length === 1)
-    return abiItems[0];
-  let matchedAbiItem = void 0;
-  for (const abiItem of abiItems) {
-    if (!("inputs" in abiItem))
-      continue;
-    if (!args || args.length === 0) {
-      if (!abiItem.inputs || abiItem.inputs.length === 0)
-        return abiItem;
-      continue;
-    }
-    if (!abiItem.inputs)
-      continue;
-    if (abiItem.inputs.length === 0)
-      continue;
-    if (abiItem.inputs.length !== args.length)
-      continue;
-    const matched = args.every((arg, index) => {
-      const abiParameter = "inputs" in abiItem && abiItem.inputs[index];
-      if (!abiParameter)
-        return false;
-      return isArgOfType(arg, abiParameter);
-    });
-    if (matched) {
-      if (matchedAbiItem && "inputs" in matchedAbiItem && matchedAbiItem.inputs) {
-        const ambiguousTypes = getAmbiguousTypes(abiItem.inputs, matchedAbiItem.inputs, args);
-        if (ambiguousTypes)
-          throw new AbiItemAmbiguityError({
-            abiItem,
-            type: ambiguousTypes[0]
-          }, {
-            abiItem: matchedAbiItem,
-            type: ambiguousTypes[1]
-          });
-      }
-      matchedAbiItem = abiItem;
-    }
-  }
-  if (matchedAbiItem)
-    return matchedAbiItem;
-  return abiItems[0];
-}
-function isArgOfType(arg, abiParameter) {
-  const argType = typeof arg;
-  const abiParameterType = abiParameter.type;
-  switch (abiParameterType) {
-    case "address":
-      return isAddress(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 isAddress(args[parameterIndex], { strict: false });
-      if (types.includes("address") && types.includes("bytes"))
-        return isAddress(args[parameterIndex], { strict: false });
-      return false;
-    })();
-    if (ambiguous)
-      return types;
-  }
-  return;
-}
-const docsPath$1 = "/docs/contract/decodeFunctionResult";
-function decodeFunctionResult(parameters) {
-  const { abi, args, functionName, data } = parameters;
-  let abiItem = abi[0];
-  if (functionName) {
-    const item = getAbiItem({ abi, args, name: functionName });
-    if (!item)
-      throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath$1 });
-    abiItem = item;
-  }
-  if (abiItem.type !== "function")
-    throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath$1 });
-  if (!abiItem.outputs)
-    throw new AbiFunctionOutputsNotFoundError(abiItem.name, { docsPath: docsPath$1 });
-  const values = decodeAbiParameters(abiItem.outputs, data);
-  if (values && values.length > 1)
-    return values;
-  if (values && values.length === 1)
-    return values[0];
-  return void 0;
-}
-const docsPath = "/docs/contract/encodeFunctionData";
-function prepareEncodeFunctionData(parameters) {
-  const { abi, args, functionName } = parameters;
-  let abiItem = abi[0];
-  if (functionName) {
-    const item = getAbiItem({
-      abi,
-      args,
-      name: functionName
-    });
-    if (!item)
-      throw new AbiFunctionNotFoundError(functionName, { docsPath });
-    abiItem = item;
-  }
-  if (abiItem.type !== "function")
-    throw new AbiFunctionNotFoundError(void 0, { docsPath });
-  return {
-    abi: [abiItem],
-    functionName: toFunctionSelector(formatAbiItem$1(abiItem))
-  };
-}
-function encodeFunctionData(parameters) {
-  const { args } = parameters;
-  const { abi, functionName } = (() => {
-    var _a;
-    if (parameters.abi.length === 1 && ((_a = parameters.functionName) == null ? void 0 : _a.startsWith("0x")))
-      return parameters;
-    return prepareEncodeFunctionData(parameters);
-  })();
-  const abiItem = abi[0];
-  const signature = functionName;
-  const data = "inputs" in abiItem && abiItem.inputs ? encodeAbiParameters(abiItem.inputs, args ?? []) : void 0;
-  return concatHex([signature, data ?? "0x"]);
-}
-function getChainContractAddress({ blockNumber, chain, contract: name }) {
-  var _a;
-  const contract = (_a = chain == null ? void 0 : chain.contracts) == null ? void 0 : _a[name];
-  if (!contract)
-    throw new ChainDoesNotSupportContract({
-      chain,
-      contract: { name }
-    });
-  if (blockNumber && contract.blockCreated && contract.blockCreated > blockNumber)
-    throw new ChainDoesNotSupportContract({
-      blockNumber,
-      chain,
-      contract: {
-        name,
-        blockCreated: contract.blockCreated
-      }
-    });
-  return contract.address;
-}
-const panicReasons = {
-  1: "An `assert` condition failed.",
-  17: "Arithmetic operation resulted in underflow or overflow.",
-  18: "Division or modulo by zero (e.g. `5 / 0` or `23 % 0`).",
-  33: "Attempted to convert to an invalid type.",
-  34: "Attempted to access a storage byte array that is incorrectly encoded.",
-  49: "Performed `.pop()` on an empty array",
-  50: "Array index is out of bounds.",
-  65: "Allocated too much memory or created an array which is too large.",
-  81: "Attempted to call a zero-initialized variable of internal function type."
-};
-const solidityError = {
-  inputs: [
-    {
-      name: "message",
-      type: "string"
-    }
-  ],
-  name: "Error",
-  type: "error"
-};
-const solidityPanic = {
-  inputs: [
-    {
-      name: "reason",
-      type: "uint256"
-    }
-  ],
-  name: "Panic",
-  type: "error"
-};
-function decodeErrorResult(parameters) {
-  const { abi, data } = parameters;
-  const signature = slice(data, 0, 4);
-  if (signature === "0x")
-    throw new AbiDecodingZeroDataError();
-  const abi_ = [...abi || [], solidityError, solidityPanic];
-  const abiItem = abi_.find((x) => x.type === "error" && signature === toFunctionSelector(formatAbiItem$1(x)));
-  if (!abiItem)
-    throw new AbiErrorSignatureNotFoundError(signature, {
-      docsPath: "/docs/contract/decodeErrorResult"
-    });
-  return {
-    abiItem,
-    args: "inputs" in abiItem && abiItem.inputs && abiItem.inputs.length > 0 ? decodeAbiParameters(abiItem.inputs, slice(data, 4)) : void 0,
-    errorName: abiItem.name
-  };
-}
-function formatAbiItemWithArgs({ abiItem, args, includeFunctionName = true, includeName = false }) {
-  if (!("name" in abiItem))
-    return;
-  if (!("inputs" in abiItem))
-    return;
-  if (!abiItem.inputs)
-    return;
-  return `${includeFunctionName ? abiItem.name : ""}(${abiItem.inputs.map((input, i) => `${includeName && input.name ? `${input.name}: ` : ""}${typeof args[i] === "object" ? stringify(args[i]) : args[i]}`).join(", ")})`;
-}
-class CallExecutionError extends BaseError$1 {
-  constructor(cause, { account: account_, docsPath: docsPath2, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, stateOverride }) {
-    var _a;
-    const account = account_ ? parseAccount(account_) : void 0;
-    let prettyArgs = prettyPrint({
-      from: account == null ? void 0 : account.address,
-      to,
-      value: typeof value !== "undefined" && `${formatEther(value)} ${((_a = chain == null ? void 0 : chain.nativeCurrency) == null ? void 0 : _a.symbol) || "ETH"}`,
-      data,
-      gas,
-      gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
-      maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
-      maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
-      nonce
-    });
-    if (stateOverride) {
-      prettyArgs += `
-${prettyStateOverride(stateOverride)}`;
-    }
-    super(cause.shortMessage, {
-      cause,
-      docsPath: docsPath2,
-      metaMessages: [
-        ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
-        "Raw Call Arguments:",
-        prettyArgs
-      ].filter(Boolean),
-      name: "CallExecutionError"
-    });
-    Object.defineProperty(this, "cause", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    this.cause = cause;
-  }
-}
-class ContractFunctionExecutionError extends BaseError$1 {
-  constructor(cause, { abi, args, contractAddress, docsPath: docsPath2, functionName, sender }) {
-    const abiItem = getAbiItem({ abi, args, name: functionName });
-    const formattedArgs = abiItem ? formatAbiItemWithArgs({
-      abiItem,
-      args,
-      includeFunctionName: false,
-      includeName: false
-    }) : void 0;
-    const functionWithParams = abiItem ? formatAbiItem$1(abiItem, { includeName: true }) : void 0;
-    const prettyArgs = prettyPrint({
-      address: contractAddress && getContractAddress(contractAddress),
-      function: functionWithParams,
-      args: formattedArgs && formattedArgs !== "()" && `${[...Array((functionName == null ? void 0 : functionName.length) ?? 0).keys()].map(() => " ").join("")}${formattedArgs}`,
-      sender
-    });
-    super(cause.shortMessage || `An unknown error occurred while executing the contract function "${functionName}".`, {
-      cause,
-      docsPath: docsPath2,
-      metaMessages: [
-        ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
-        prettyArgs && "Contract Call:",
-        prettyArgs
-      ].filter(Boolean),
-      name: "ContractFunctionExecutionError"
-    });
-    Object.defineProperty(this, "abi", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "args", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "cause", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "contractAddress", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "formattedArgs", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "functionName", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "sender", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    this.abi = abi;
-    this.args = args;
-    this.cause = cause;
-    this.contractAddress = contractAddress;
-    this.functionName = functionName;
-    this.sender = sender;
-  }
-}
-class ContractFunctionRevertedError extends BaseError$1 {
-  constructor({ abi, data, functionName, message }) {
-    let cause;
-    let decodedData = void 0;
-    let metaMessages;
-    let reason;
-    if (data && data !== "0x") {
-      try {
-        decodedData = decodeErrorResult({ abi, data });
-        const { abiItem, errorName, args: errorArgs } = decodedData;
-        if (errorName === "Error") {
-          reason = errorArgs[0];
-        } else if (errorName === "Panic") {
-          const [firstArg] = errorArgs;
-          reason = panicReasons[firstArg];
-        } else {
-          const errorWithParams = abiItem ? formatAbiItem$1(abiItem, { includeName: true }) : void 0;
-          const formattedArgs = abiItem && errorArgs ? formatAbiItemWithArgs({
-            abiItem,
-            args: errorArgs,
-            includeFunctionName: false,
-            includeName: false
-          }) : void 0;
-          metaMessages = [
-            errorWithParams ? `Error: ${errorWithParams}` : "",
-            formattedArgs && formattedArgs !== "()" ? `       ${[...Array((errorName == null ? void 0 : errorName.length) ?? 0).keys()].map(() => " ").join("")}${formattedArgs}` : ""
-          ];
-        }
-      } catch (err) {
-        cause = err;
-      }
-    } else if (message)
-      reason = message;
-    let signature;
-    if (cause instanceof AbiErrorSignatureNotFoundError) {
-      signature = cause.signature;
-      metaMessages = [
-        `Unable to decode signature "${signature}" as it was not found on the provided ABI.`,
-        "Make sure you are using the correct ABI and that the error exists on it.",
-        `You can look up the decoded signature here: https://openchain.xyz/signatures?query=${signature}.`
-      ];
-    }
-    super(reason && reason !== "execution reverted" || signature ? [
-      `The contract function "${functionName}" reverted with the following ${signature ? "signature" : "reason"}:`,
-      reason || signature
-    ].join("\n") : `The contract function "${functionName}" reverted.`, {
-      cause,
-      metaMessages,
-      name: "ContractFunctionRevertedError"
-    });
-    Object.defineProperty(this, "data", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "raw", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "reason", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "signature", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    this.data = decodedData;
-    this.raw = data;
-    this.reason = reason;
-    this.signature = signature;
-  }
-}
-class ContractFunctionZeroDataError extends BaseError$1 {
-  constructor({ functionName }) {
-    super(`The contract function "${functionName}" returned no data ("0x").`, {
-      metaMessages: [
-        "This could be due to any of the following:",
-        `  - The contract does not have the function "${functionName}",`,
-        "  - The parameters passed to the contract function may be invalid, or",
-        "  - The address is not a contract."
-      ],
-      name: "ContractFunctionZeroDataError"
-    });
-  }
-}
-class CounterfactualDeploymentFailedError extends BaseError$1 {
-  constructor({ factory }) {
-    super(`Deployment for counterfactual contract call failed${factory ? ` for factory "${factory}".` : ""}`, {
-      metaMessages: [
-        "Please ensure:",
-        "- The `factory` is a valid contract deployment factory (ie. Create2 Factory, ERC-4337 Factory, etc).",
-        "- The `factoryData` is a valid encoded function call for contract deployment function on the factory."
-      ],
-      name: "CounterfactualDeploymentFailedError"
-    });
-  }
-}
-class RawContractError extends BaseError$1 {
-  constructor({ data, message }) {
-    super(message || "", { name: "RawContractError" });
-    Object.defineProperty(this, "code", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: 3
-    });
-    Object.defineProperty(this, "data", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    this.data = data;
-  }
-}
-function isNullUniversalResolverError(err, callType) {
-  var _a, _b, _c, _d, _e, _f;
-  if (!(err instanceof BaseError$1))
-    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) === "ResolverNotFound")
-    return true;
-  if (((_b = cause.data) == null ? void 0 : _b.errorName) === "ResolverWildcardNotSupported")
-    return true;
-  if (((_c = cause.data) == null ? void 0 : _c.errorName) === "ResolverNotContract")
-    return true;
-  if (((_d = cause.data) == null ? void 0 : _d.errorName) === "ResolverError")
-    return true;
-  if (((_e = cause.data) == null ? void 0 : _e.errorName) === "HttpError")
-    return true;
-  if ((_f = cause.reason) == null ? void 0 : _f.includes("Wildcard on non-extended resolvers is not supported"))
-    return true;
-  if (callType === "reverse" && cause.reason === panicReasons[50])
-    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(stringToBytes(labels[i]), "bytes");
-    result = keccak256(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(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;
-}
-const EXECUTION_REVERTED_ERROR_CODE = 3;
-function getContractError(err, { abi, address, args, docsPath: docsPath2, functionName, sender }) {
-  const error = err instanceof RawContractError ? err : err instanceof BaseError$1 ? err.walk((err2) => "data" in err2) || err.walk() : {};
-  const { code, data, details, message, shortMessage } = error;
-  const cause = (() => {
-    if (err instanceof AbiDecodingZeroDataError)
-      return new ContractFunctionZeroDataError({ functionName });
-    if ([EXECUTION_REVERTED_ERROR_CODE, InternalRpcError.code].includes(code) && (data || details || message || shortMessage)) {
-      return new ContractFunctionRevertedError({
-        abi,
-        data: typeof data === "object" ? data.data : data,
-        functionName,
-        message: error instanceof RpcRequestError ? details : shortMessage ?? message
-      });
-    }
-    return err;
-  })();
-  return new ContractFunctionExecutionError(cause, {
-    abi,
-    args,
-    contractAddress: address,
-    docsPath: docsPath2,
-    functionName,
-    sender
-  });
-}
-const aggregate3Signature = "0x82ad56cb";
-const deploylessCallViaBytecodeBytecode = "0x608060405234801561001057600080fd5b5060405161018e38038061018e83398101604081905261002f91610124565b6000808351602085016000f59050803b61004857600080fd5b6000808351602085016000855af16040513d6000823e81610067573d81fd5b3d81f35b634e487b7160e01b600052604160045260246000fd5b600082601f83011261009257600080fd5b81516001600160401b038111156100ab576100ab61006b565b604051601f8201601f19908116603f011681016001600160401b03811182821017156100d9576100d961006b565b6040528181528382016020018510156100f157600080fd5b60005b82811015610110576020818601810151838301820152016100f4565b506000918101602001919091529392505050565b6000806040838503121561013757600080fd5b82516001600160401b0381111561014d57600080fd5b61015985828601610081565b602085015190935090506001600160401b0381111561017757600080fd5b61018385828601610081565b915050925092905056fe";
-const deploylessCallViaFactoryBytecode = "0x608060405234801561001057600080fd5b506040516102c03803806102c083398101604081905261002f916101e6565b836001600160a01b03163b6000036100e457600080836001600160a01b03168360405161005c9190610270565b6000604051808303816000865af19150503d8060008114610099576040519150601f19603f3d011682016040523d82523d6000602084013e61009e565b606091505b50915091508115806100b857506001600160a01b0386163b155b156100e1578060405163101bb98d60e01b81526004016100d8919061028c565b60405180910390fd5b50505b6000808451602086016000885af16040513d6000823e81610103573d81fd5b3d81f35b80516001600160a01b038116811461011e57600080fd5b919050565b634e487b7160e01b600052604160045260246000fd5b60005b8381101561015457818101518382015260200161013c565b50506000910152565b600082601f83011261016e57600080fd5b81516001600160401b0381111561018757610187610123565b604051601f8201601f19908116603f011681016001600160401b03811182821017156101b5576101b5610123565b6040528181528382016020018510156101cd57600080fd5b6101de826020830160208701610139565b949350505050565b600080600080608085870312156101fc57600080fd5b61020585610107565b60208601519094506001600160401b0381111561022157600080fd5b61022d8782880161015d565b93505061023c60408601610107565b60608601519092506001600160401b0381111561025857600080fd5b6102648782880161015d565b91505092959194509250565b60008251610282818460208701610139565b9190910192915050565b60208152600082518060208401526102ab816040850160208701610139565b601f01601f1916919091016040019291505056fe";
-const universalSignatureValidatorByteCode = "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";
-function getCallError(err, { docsPath: docsPath2, ...args }) {
-  const cause = (() => {
-    const cause2 = getNodeError(err, args);
-    if (cause2 instanceof UnknownNodeError)
-      return err;
-    return cause2;
-  })();
-  return new CallExecutionError(cause, {
-    docsPath: docsPath2,
-    ...args
-  });
-}
-async function call(client, args) {
-  var _a, _b, _c, _d;
-  const { account: account_ = client.account, batch = Boolean((_a = client.batch) == null ? void 0 : _a.multicall), blockNumber, blockTag = "latest", accessList, blobs, code, data: data_, factory, factoryData, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, stateOverride, ...rest } = args;
-  const account = account_ ? parseAccount(account_) : void 0;
-  if (code && (factory || factoryData))
-    throw new BaseError$1("Cannot provide both `code` & `factory`/`factoryData` as parameters.");
-  if (code && to)
-    throw new BaseError$1("Cannot provide both `code` & `to` as parameters.");
-  const deploylessCallViaBytecode = code && data_;
-  const deploylessCallViaFactory = factory && factoryData && to && data_;
-  const deploylessCall = deploylessCallViaBytecode || deploylessCallViaFactory;
-  const data = (() => {
-    if (deploylessCallViaBytecode)
-      return toDeploylessCallViaBytecodeData({
-        code,
-        data: data_
-      });
-    if (deploylessCallViaFactory)
-      return toDeploylessCallViaFactoryData({
-        data: data_,
-        factory,
-        factoryData,
-        to
-      });
-    return data_;
-  })();
-  try {
-    assertRequest(args);
-    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
-    const block = blockNumberHex || blockTag;
-    const rpcStateOverride = serializeStateOverride(stateOverride);
-    const chainFormat = (_d = (_c = (_b = client.chain) == null ? void 0 : _b.formatters) == null ? void 0 : _c.transactionRequest) == null ? void 0 : _d.format;
-    const format = chainFormat || formatTransactionRequest;
-    const request = format({
-      // Pick out extra data that might exist on the chain's transaction request type.
-      ...extract(rest, { format: chainFormat }),
-      from: account == null ? void 0 : account.address,
-      accessList,
-      blobs,
-      data,
-      gas,
-      gasPrice,
-      maxFeePerBlobGas,
-      maxFeePerGas,
-      maxPriorityFeePerGas,
-      nonce,
-      to: deploylessCall ? void 0 : to,
-      value
-    });
-    if (batch && shouldPerformMulticall({ request }) && !rpcStateOverride) {
-      try {
-        return await scheduleMulticall(client, {
-          ...request,
-          blockNumber,
-          blockTag
-        });
-      } catch (err) {
-        if (!(err instanceof ClientChainNotConfiguredError) && !(err instanceof ChainDoesNotSupportContract))
-          throw err;
-      }
-    }
-    const response = await client.request({
-      method: "eth_call",
-      params: rpcStateOverride ? [
-        request,
-        block,
-        rpcStateOverride
-      ] : [request, block]
-    });
-    if (response === "0x")
-      return { data: void 0 };
-    return { data: response };
-  } catch (err) {
-    const data2 = getRevertErrorData(err);
-    const { offchainLookup, offchainLookupSignature } = await __vitePreload(async () => {
-      const { offchainLookup: offchainLookup2, offchainLookupSignature: offchainLookupSignature2 } = await import("./ccip-BLPIQK-p.js");
-      return { offchainLookup: offchainLookup2, offchainLookupSignature: offchainLookupSignature2 };
-    }, true ? __vite__mapDeps([0,1,2,3,4,5]) : void 0);
-    if (client.ccipRead !== false && (data2 == null ? void 0 : data2.slice(0, 10)) === offchainLookupSignature && to)
-      return { data: await offchainLookup(client, { data: data2, to }) };
-    if (deploylessCall && (data2 == null ? void 0 : data2.slice(0, 10)) === "0x101bb98d")
-      throw new CounterfactualDeploymentFailedError({ factory });
-    throw getCallError(err, {
-      ...args,
-      account,
-      chain: client.chain
-    });
-  }
-}
-function shouldPerformMulticall({ request }) {
-  const { data, to, ...request_ } = request;
-  if (!data)
-    return false;
-  if (data.startsWith(aggregate3Signature))
-    return false;
-  if (!to)
-    return false;
-  if (Object.values(request_).filter((x) => typeof x !== "undefined").length > 0)
-    return false;
-  return true;
-}
-async function scheduleMulticall(client, args) {
-  var _a;
-  const { batchSize = 1024, wait = 0 } = typeof ((_a = client.batch) == null ? void 0 : _a.multicall) === "object" ? client.batch.multicall : {};
-  const { blockNumber, blockTag = "latest", data, multicallAddress: multicallAddress_, to } = args;
-  let multicallAddress = multicallAddress_;
-  if (!multicallAddress) {
-    if (!client.chain)
-      throw new ClientChainNotConfiguredError();
-    multicallAddress = getChainContractAddress({
-      blockNumber,
-      chain: client.chain,
-      contract: "multicall3"
-    });
-  }
-  const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
-  const block = blockNumberHex || blockTag;
-  const { schedule } = createBatchScheduler({
-    id: `${client.uid}.${block}`,
-    wait,
-    shouldSplitBatch(args2) {
-      const size2 = args2.reduce((size3, { data: data2 }) => size3 + (data2.length - 2), 0);
-      return size2 > batchSize * 2;
-    },
-    fn: async (requests) => {
-      const calls = requests.map((request) => ({
-        allowFailure: true,
-        callData: request.data,
-        target: request.to
-      }));
-      const calldata = encodeFunctionData({
-        abi: multicall3Abi,
-        args: [calls],
-        functionName: "aggregate3"
-      });
-      const data2 = await client.request({
-        method: "eth_call",
-        params: [
-          {
-            data: calldata,
-            to: multicallAddress
-          },
-          block
-        ]
-      });
-      return decodeFunctionResult({
-        abi: multicall3Abi,
-        args: [calls],
-        functionName: "aggregate3",
-        data: data2 || "0x"
-      });
-    }
-  });
-  const [{ returnData, success }] = await schedule({ data, to });
-  if (!success)
-    throw new RawContractError({ data: returnData });
-  if (returnData === "0x")
-    return { data: void 0 };
-  return { data: returnData };
-}
-function toDeploylessCallViaBytecodeData(parameters) {
-  const { code, data } = parameters;
-  return encodeDeployData({
-    abi: parseAbi(["constructor(bytes, bytes)"]),
-    bytecode: deploylessCallViaBytecodeBytecode,
-    args: [code, data]
-  });
-}
-function toDeploylessCallViaFactoryData(parameters) {
-  const { data, factory, factoryData, to } = parameters;
-  return encodeDeployData({
-    abi: parseAbi(["constructor(address, bytes, address, bytes)"]),
-    bytecode: deploylessCallViaFactoryBytecode,
-    args: [to, data, factory, factoryData]
-  });
-}
-function getRevertErrorData(err) {
-  var _a;
-  if (!(err instanceof BaseError$1))
-    return void 0;
-  const error = err.walk();
-  return typeof (error == null ? void 0 : error.data) === "object" ? (_a = error.data) == null ? void 0 : _a.data : error.data;
-}
-async function readContract(client, parameters) {
-  const { abi, address, args, functionName, ...rest } = parameters;
-  const calldata = encodeFunctionData({
-    abi,
-    args,
-    functionName
-  });
-  try {
-    const { data } = await getAction(client, call, "call")({
-      ...rest,
-      data: calldata,
-      to: address
-    });
-    return decodeFunctionResult({
-      abi,
-      args,
-      functionName,
-      data: data || "0x"
-    });
-  } catch (error) {
-    throw getContractError(error, {
-      abi,
-      address,
-      args,
-      docsPath: "/docs/contract/readContract",
-      functionName
-    });
-  }
-}
-class EnsAvatarInvalidMetadataError extends BaseError$1 {
-  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$1 {
-  constructor({ reason }) {
-    super(`ENS NFT avatar URI is invalid. ${reason}`, {
-      name: "EnsAvatarInvalidNftUriError"
-    });
-  }
-}
-class EnsAvatarUriResolutionError extends BaseError$1 {
-  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$1 {
-  constructor({ namespace }) {
-    super(`ENS NFT avatar namespace "${namespace}" is not supported. Must be "erc721" or "erc1155".`, { name: "EnsAvatarUnsupportedNamespaceError" });
-  }
-}
-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 (!globalThis.hasOwnProperty("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),
-    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, { blockNumber, blockTag, name, key, gatewayUrls, strict, universalResolverAddress: universalResolverAddress_ }) {
-  let universalResolverAddress = universalResolverAddress_;
-  if (!universalResolverAddress) {
-    if (!client.chain)
-      throw new Error("client chain not configured. universalResolverAddress is required.");
-    universalResolverAddress = getChainContractAddress({
-      blockNumber,
-      chain: client.chain,
-      contract: "ensUniversalResolver"
-    });
-  }
-  try {
-    const readContractParameters = {
-      address: universalResolverAddress,
-      abi: universalResolverResolveAbi,
-      functionName: "resolve",
-      args: [
-        toHex(packetToBytes(name)),
-        encodeFunctionData({
-          abi: textResolverAbi,
-          functionName: "text",
-          args: [namehash(name), key]
-        })
-      ],
-      blockNumber,
-      blockTag
-    };
-    const readContractAction = getAction(client, readContract, "readContract");
-    const res = gatewayUrls ? await readContractAction({
-      ...readContractParameters,
-      args: [...readContractParameters.args, gatewayUrls]
-    }) : 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, "resolve"))
-      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, { address, blockNumber, blockTag, gatewayUrls, strict, universalResolverAddress: universalResolverAddress_ }) {
-  let universalResolverAddress = universalResolverAddress_;
-  if (!universalResolverAddress) {
-    if (!client.chain)
-      throw new Error("client chain not configured. universalResolverAddress is required.");
-    universalResolverAddress = getChainContractAddress({
-      blockNumber,
-      chain: client.chain,
-      contract: "ensUniversalResolver"
-    });
-  }
-  const reverseNode = `${address.toLowerCase().substring(2)}.addr.reverse`;
-  try {
-    const readContractParameters = {
-      address: universalResolverAddress,
-      abi: universalResolverReverseAbi,
-      functionName: "reverse",
-      args: [toHex(packetToBytes(reverseNode))],
-      blockNumber,
-      blockTag
-    };
-    const readContractAction = getAction(client, readContract, "readContract");
-    const [name, resolvedAddress] = gatewayUrls ? await readContractAction({
-      ...readContractParameters,
-      args: [...readContractParameters.args, gatewayUrls]
-    }) : await readContractAction(readContractParameters);
-    if (address.toLowerCase() !== resolvedAddress.toLowerCase())
-      return null;
-    return name;
-  } catch (err) {
-    if (strict)
-      throw err;
-    if (isNullUniversalResolverError(err, "reverse"))
-      return null;
-    throw err;
-  }
-}
-export {
-  maxUint256 as $,
-  getAbiItem as A,
-  AbiEventNotFoundError as B,
-  formatAbiItem$1 as C,
-  toEventSelector as D,
-  encodeAbiParameters as E,
-  getContractError as F,
-  AbiEventSignatureEmptyTopicsError as G,
-  AbiEventSignatureNotFoundError as H,
-  InvalidSerializableTransactionError as I,
-  DecodeLogTopicsMismatch as J,
-  decodeAbiParameters as K,
-  AbiDecodingDataSizeTooSmallError as L,
-  DecodeLogDataMismatch as M,
-  TransactionReceiptNotFoundError as N,
-  multicall3Abi as O,
-  PositionOutOfBoundsError as P,
-  AbiDecodingZeroDataError as Q,
-  RawContractError as R,
-  formatAbiItem as S,
-  TransactionNotFoundError as T,
-  UnknownNodeError as U,
-  concat as V,
-  integerRegex$1 as W,
-  bytesRegex$1 as X,
-  BytesSizeMismatchError as Y,
-  sliceHex as Z,
-  InvalidChainIdError as _,
-  concatHex as a,
-  FeeCapTooHighError as a0,
-  TipAboveFeeCapError as a1,
-  slice as a2,
-  InvalidStorageKeySizeError as a3,
-  InvalidLegacyVError as a4,
-  deploylessCallViaBytecodeBytecode as a5,
-  WaitForTransactionReceiptTimeoutError as a6,
-  call as a7,
-  universalSignatureValidatorAbi as a8,
-  encodeDeployData as a9,
-  universalSignatureValidatorByteCode as aa,
-  CallExecutionError as ab,
-  getEnsText as ac,
-  getEnsName as ad,
-  getEnsAvatar as ae,
-  maxUint16 as af,
-  defineTransactionRequest as ag,
-  decodeErrorResult as ah,
-  formatEther as b,
-  createCursor as c,
-  defineFormatter as d,
-  getNodeError as e,
-  formatGwei as f,
-  getAction as g,
-  assertRequest as h,
-  formatTransactionRequest as i,
-  extract as j,
-  parseSignature as k,
-  parseStructs as l,
-  isStructSignature as m,
-  InvalidAbiItemError as n,
-  getChainContractAddress as o,
-  prettyPrint as p,
-  encodeFunctionData as q,
-  namehash as r,
-  serializeStateOverride as s,
-  addressResolverAbi as t,
-  packetToBytes as u,
-  universalResolverResolveAbi as v,
-  readContract as w,
-  decodeFunctionResult as x,
-  isNullUniversalResolverError as y,
-  getCallError as z
-};