viem 0.0.1-alpha.8 → 0.0.1-cjs.10

package/dist/chunk-5ZBNF5WM.js

@@ -0,0 +1,2616 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// package.json
+var package_default = {
+  name: "viem",
+  description: "TypeScript (& JavaScript) Interface for Ethereum",
+  version: "0.0.1-alpha.9",
+  scripts: {
+    anvil: "source .env && anvil --fork-url $VITE_ANVIL_FORK_URL --fork-block-number $VITE_ANVIL_BLOCK_NUMBER --block-time $VITE_ANVIL_BLOCK_TIME",
+    bench: "vitest bench --no-threads",
+    "bench:ci": "CI=true vitest bench --no-threads",
+    build: "tsup",
+    changeset: "changeset",
+    "changeset:release": "pnpm build && changeset publish",
+    "changeset:version": "changeset version && pnpm install --lockfile-only",
+    dev: "DEV=true tsup",
+    "dev:docs": "pnpm -r --filter site dev",
+    format: "rome format src/ test/ --write",
+    lint: "rome check .",
+    "lint:fix": "pnpm lint --apply-suggested",
+    playground: "pnpm --filter playground-dev dev",
+    "playground:benchmark": "pnpm --filter playground-benchmark dev",
+    postinstall: "pnpm dev",
+    preinstall: "npx only-allow pnpm",
+    prepare: "npx simple-git-hooks",
+    test: "vitest dev --coverage --no-threads",
+    "test:ci": "CI=true vitest --coverage --no-threads",
+    "test:ui": "vitest dev --ui --no-threads",
+    typecheck: "tsc --noEmit"
+  },
+  files: [
+    "/actions",
+    "/chains",
+    "/dist",
+    "/clients",
+    "/types",
+    "/utils",
+    "/window"
+  ],
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      module: "./dist/index.mjs",
+      default: "./dist/index.js"
+    },
+    "./actions": {
+      types: "./dist/actions/index.d.ts",
+      module: "./dist/actions/index.mjs",
+      default: "./dist/actions/index.js"
+    },
+    "./chains": {
+      types: "./dist/chains.d.ts",
+      module: "./dist/chains.mjs",
+      default: "./dist/chains.js"
+    },
+    "./clients": {
+      types: "./dist/clients/index.d.ts",
+      module: "./dist/clients/index.mjs",
+      default: "./dist/clients/index.js"
+    },
+    "./utils": {
+      types: "./dist/utils/index.d.ts",
+      module: "./dist/utils/index.mjs",
+      default: "./dist/utils/index.js"
+    },
+    "./window": {
+      types: "./dist/window.d.ts",
+      module: "./dist/window.mjs",
+      default: "./dist/window.js"
+    },
+    "./package.json": "./package.json"
+  },
+  main: "dist/index.js",
+  module: "dist/index.mjs",
+  types: "dist/index.d.ts",
+  sideEffects: false,
+  dependencies: {
+    "@noble/hashes": "^1.1.2",
+    "@wagmi/chains": "^0.1.0",
+    abitype: "^0.2.5"
+  },
+  devDependencies: {
+    "@actions/core": "^1.10.0",
+    "@actions/github": "^5.1.1",
+    "@changesets/changelog-github": "^0.4.5",
+    "@changesets/cli": "^2.23.2",
+    "@testing-library/jest-dom": "^5.16.5",
+    "@types/dedent": "^0.7.0",
+    "@types/fs-extra": "^9.0.13",
+    "@types/node": "^17.0.45",
+    "@vitest/coverage-c8": "^0.24.3",
+    "@vitest/ui": "^0.19.1",
+    bundlewatch: "^0.3.3",
+    dedent: "^0.7.0",
+    esbuild: "^0.16.12",
+    "esbuild-register": "^3.4.2",
+    "essential-eth": "^0.6.2",
+    ethers: "^5.7.2",
+    execa: "^6.1.0",
+    "fs-extra": "^10.1.0",
+    jsdom: "^20.0.0",
+    rome: "^11.0.0",
+    "simple-git-hooks": "^2.8.1",
+    tsup: "^6.5.0",
+    typescript: "^4.9.3",
+    vite: "^3.0.4",
+    vitest: "^0.25.2",
+    web3: "^1.8.1"
+  },
+  license: "MIT",
+  repository: "wagmi-dev/viem",
+  authors: [
+    "awkweb.eth",
+    "jxom.eth"
+  ],
+  keywords: [
+    "eth",
+    "ethereum",
+    "dapps",
+    "wallet",
+    "web3"
+  ],
+  "simple-git-hooks": {
+    "pre-commit": "pnpm format & pnpm lint:fix"
+  },
+  pnpm: {
+    patchedDependencies: {
+      "vitepress@1.0.0-alpha.34": "patches/vitepress@1.0.0-alpha.34.patch"
+    }
+  }
+};
+
+// src/utils/stringify.ts
+function stringify(value) {
+  return JSON.stringify(
+    value,
+    (_, value2) => typeof value2 === "bigint" ? value2.toString() : value2
+  );
+}
+
+// src/errors/base.ts
+var version = process.env.TEST ? "1.0.2" : package_default.version;
+var BaseError = class extends Error {
+  constructor(humanMessage, args = {}) {
+    const details = args.cause instanceof BaseError ? args.cause.details : _optionalChain([args, 'access', _2 => _2.cause, 'optionalAccess', _3 => _3.message]) ? args.cause.message : args.details;
+    const docsPath5 = args.cause instanceof BaseError ? args.cause.docsPath || args.docsPath : args.docsPath;
+    const message = [
+      humanMessage,
+      ...docsPath5 ? ["", `Docs: https://viem.sh${docsPath5}`] : [],
+      "",
+      ...details ? [`Details: ${details}`] : [],
+      `Version: viem@${version}`,
+      ...args.cause && !(args.cause instanceof BaseError) && Object.keys(args.cause).length > 0 ? [`Internal Error: ${stringify(args.cause)}`] : []
+    ].join("\n");
+    super(message);
+    __publicField(this, "humanMessage");
+    __publicField(this, "details");
+    __publicField(this, "docsPath");
+    __publicField(this, "name", "ViemError");
+    if (args.cause)
+      this.cause = args.cause;
+    this.details = details;
+    this.docsPath = docsPath5;
+    this.humanMessage = humanMessage;
+  }
+};
+
+// src/errors/abi.ts
+var AbiConstructorNotFoundError = class extends BaseError {
+  constructor({ docsPath: docsPath5 }) {
+    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: docsPath5
+      }
+    );
+    __publicField(this, "name", "AbiConstructorNotFoundError");
+  }
+};
+var AbiConstructorParamsNotFoundError = class extends BaseError {
+  constructor({ docsPath: docsPath5 }) {
+    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: docsPath5
+      }
+    );
+    __publicField(this, "name", "AbiConstructorParamsNotFoundError");
+  }
+};
+var AbiDecodingDataSizeInvalidError = class extends BaseError {
+  constructor(size2) {
+    super(
+      [
+        `Data size of ${size2} bytes is invalid.`,
+        "Size must be in increments of 32 bytes (size % 32 === 0)."
+      ].join("\n")
+    );
+    __publicField(this, "name", "AbiDecodingDataSizeInvalidError");
+  }
+};
+var AbiDecodingZeroDataError = class extends BaseError {
+  constructor() {
+    super('Cannot decode zero data ("0x") with ABI parameters.');
+    __publicField(this, "name", "AbiDecodingZeroDataError");
+  }
+};
+var AbiEncodingArrayLengthMismatchError = class extends BaseError {
+  constructor({
+    expectedLength,
+    givenLength,
+    type
+  }) {
+    super(
+      [
+        `ABI encoding array length mismatch for type ${type}.`,
+        `Expected length: ${expectedLength}`,
+        `Given length: ${givenLength}`
+      ].join("\n")
+    );
+    __publicField(this, "name", "AbiEncodingArrayLengthMismatchError");
+  }
+};
+var AbiEncodingLengthMismatchError = class extends BaseError {
+  constructor({
+    expectedLength,
+    givenLength
+  }) {
+    super(
+      [
+        "ABI encoding params/values length mismatch.",
+        `Expected length (params): ${expectedLength}`,
+        `Given length (values): ${givenLength}`
+      ].join("\n")
+    );
+    __publicField(this, "name", "AbiEncodingLengthMismatchError");
+  }
+};
+var AbiErrorInputsNotFoundError = class extends BaseError {
+  constructor(errorName, { docsPath: docsPath5 }) {
+    super(
+      [
+        `Arguments (\`args\`) were provided to "${errorName}", but "${errorName}" on the ABI does not contain any parameters (\`inputs\`).`,
+        "Cannot encode error result without knowing what the parameter types are.",
+        "Make sure you are using the correct ABI and that the inputs exist on it."
+      ].join("\n"),
+      {
+        docsPath: docsPath5
+      }
+    );
+    __publicField(this, "name", "AbiErrorInputsNotFoundError");
+  }
+};
+var AbiErrorNotFoundError = class extends BaseError {
+  constructor(errorName, { docsPath: docsPath5 }) {
+    super(
+      [
+        `Error "${errorName}" not found on ABI.`,
+        "Make sure you are using the correct ABI and that the error exists on it."
+      ].join("\n"),
+      {
+        docsPath: docsPath5
+      }
+    );
+    __publicField(this, "name", "AbiErrorNotFoundError");
+  }
+};
+var AbiErrorSignatureNotFoundError = class extends BaseError {
+  constructor(signature, { docsPath: docsPath5 }) {
+    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 signature "${signature}" here: https://sig.eth.samczsun.com/.`
+      ].join("\n"),
+      {
+        docsPath: docsPath5
+      }
+    );
+    __publicField(this, "name", "AbiErrorSignatureNotFoundError");
+  }
+};
+var AbiEventNotFoundError = class extends BaseError {
+  constructor(eventName, { docsPath: docsPath5 }) {
+    super(
+      [
+        `Event "${eventName}" not found on ABI.`,
+        "Make sure you are using the correct ABI and that the event exists on it."
+      ].join("\n"),
+      {
+        docsPath: docsPath5
+      }
+    );
+    __publicField(this, "name", "AbiEventNotFoundError");
+  }
+};
+var AbiFunctionNotFoundError = class extends BaseError {
+  constructor(functionName, { docsPath: docsPath5 }) {
+    super(
+      [
+        `Function "${functionName}" not found on ABI.`,
+        "Make sure you are using the correct ABI and that the function exists on it."
+      ].join("\n"),
+      {
+        docsPath: docsPath5
+      }
+    );
+    __publicField(this, "name", "AbiFunctionNotFoundError");
+  }
+};
+var AbiFunctionOutputsNotFoundError = class extends BaseError {
+  constructor(functionName, { docsPath: docsPath5 }) {
+    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: docsPath5
+      }
+    );
+    __publicField(this, "name", "AbiFunctionOutputsNotFoundError");
+  }
+};
+var AbiFunctionSignatureNotFoundError = class extends BaseError {
+  constructor(signature, { docsPath: docsPath5 }) {
+    super(
+      [
+        `Encoded function signature "${signature}" not found on ABI.`,
+        "Make sure you are using the correct ABI and that the function exists on it.",
+        `You can look up the signature "${signature}" here: https://sig.eth.samczsun.com/.`
+      ].join("\n"),
+      {
+        docsPath: docsPath5
+      }
+    );
+    __publicField(this, "name", "AbiFunctionSignatureNotFoundError");
+  }
+};
+var InvalidAbiEncodingTypeError = class extends BaseError {
+  constructor(type, { docsPath: docsPath5 }) {
+    super(
+      [
+        `Type "${type}" is not a valid encoding type.`,
+        "Please provide a valid ABI type."
+      ].join("\n"),
+      { docsPath: docsPath5 }
+    );
+    __publicField(this, "name", "InvalidAbiEncodingType");
+  }
+};
+var InvalidAbiDecodingTypeError = class extends BaseError {
+  constructor(type, { docsPath: docsPath5 }) {
+    super(
+      [
+        `Type "${type}" is not a valid decoding type.`,
+        "Please provide a valid ABI type."
+      ].join("\n"),
+      { docsPath: docsPath5 }
+    );
+    __publicField(this, "name", "InvalidAbiDecodingType");
+  }
+};
+var InvalidArrayError = class extends BaseError {
+  constructor(value) {
+    super([`Value "${value}" is not a valid array.`].join("\n"));
+    __publicField(this, "name", "InvalidArrayError");
+  }
+};
+var InvalidDefinitionTypeError = class extends BaseError {
+  constructor(type) {
+    super(
+      [
+        `"${type}" is not a valid definition type.`,
+        'Valid types: "function", "event", "error"'
+      ].join("\n")
+    );
+    __publicField(this, "name", "InvalidDefinitionTypeError");
+  }
+};
+
+// src/errors/address.ts
+var InvalidAddressError = class extends BaseError {
+  constructor({ address }) {
+    super(`Address "${address}" is invalid.`);
+    __publicField(this, "name", "InvalidAddressError");
+  }
+};
+
+// src/errors/block.ts
+var BlockNotFoundError = class extends BaseError {
+  constructor({
+    blockHash,
+    blockNumber
+  }) {
+    let identifier = "Block";
+    if (blockHash)
+      identifier = `Block at hash "${blockHash}"`;
+    if (blockNumber)
+      identifier = `Block at number "${blockNumber}"`;
+    super(`${identifier} could not be found.`);
+    __publicField(this, "name", "BlockNotFoundError");
+  }
+};
+
+// src/errors/contract.ts
+var ContractMethodExecutionError = class extends BaseError {
+  constructor(message, {
+    abi,
+    args,
+    cause,
+    contractAddress,
+    formattedArgs,
+    functionName,
+    functionWithParams,
+    sender
+  } = {}) {
+    super(
+      [
+        message,
+        " ",
+        sender && `Sender:    ${sender}`,
+        contractAddress && `Contract:  ${process.env.TEST ? "0x0000000000000000000000000000000000000000" : contractAddress}`,
+        functionWithParams && `Function:  ${functionWithParams}`,
+        formattedArgs && `Arguments: ${[...Array(_nullishCoalesce(_optionalChain([functionName, 'optionalAccess', _4 => _4.length]), () => ( 0))).keys()].map(() => " ").join("")}${formattedArgs}`
+      ].filter(Boolean).join("\n"),
+      {
+        cause
+      }
+    );
+    __publicField(this, "abi");
+    __publicField(this, "args");
+    __publicField(this, "contractAddress");
+    __publicField(this, "formattedArgs");
+    __publicField(this, "functionName");
+    __publicField(this, "reason");
+    __publicField(this, "sender");
+    __publicField(this, "name", "ContractMethodExecutionError");
+    if (message)
+      this.reason = message;
+    this.abi = abi;
+    this.args = args;
+    this.contractAddress = contractAddress;
+    this.functionName = functionName;
+    this.sender = sender;
+  }
+};
+var ContractMethodZeroDataError = class extends BaseError {
+  constructor({
+    abi,
+    args,
+    cause,
+    contractAddress,
+    functionName,
+    functionWithParams
+  } = {}) {
+    super(
+      [
+        `The contract method "${functionName}" returned no data ("0x"). 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.",
+        " ",
+        contractAddress && `Contract: ${process.env.TEST ? "0x0000000000000000000000000000000000000000" : contractAddress}`,
+        functionWithParams && `Function: ${functionWithParams}`,
+        functionWithParams && `        > "0x"`
+      ].filter(Boolean).join("\n"),
+      {
+        cause
+      }
+    );
+    __publicField(this, "abi");
+    __publicField(this, "args");
+    __publicField(this, "contractAddress");
+    __publicField(this, "functionName");
+    __publicField(this, "functionWithParams");
+    __publicField(this, "name", "ContractMethodZeroDataError");
+    this.abi = abi;
+    this.args = args;
+    this.contractAddress = contractAddress;
+    this.functionName = functionName;
+  }
+};
+
+// src/errors/data.ts
+var SizeExceedsPaddingSizeError = class extends BaseError {
+  constructor({
+    size: size2,
+    targetSize,
+    type
+  }) {
+    super(
+      `${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size2}) exceeds padding size (${targetSize}).`
+    );
+    __publicField(this, "name", "SizeExceedsPaddingSizeError");
+  }
+};
+
+// src/errors/encoding.ts
+var DataLengthTooLongError = class extends BaseError {
+  constructor({ consumed, length }) {
+    super(
+      `Consumed bytes (${consumed}) is shorter than data length (${length - 1}).`
+    );
+    __publicField(this, "name", "DataLengthTooLongError");
+  }
+};
+var DataLengthTooShortError = class extends BaseError {
+  constructor({ length, dataLength }) {
+    super(
+      `Data length (${dataLength - 1}) is shorter than prefix length (${length - 1}).`
+    );
+    __publicField(this, "name", "DataLengthTooShortError");
+  }
+};
+var InvalidBytesBooleanError = class extends BaseError {
+  constructor(bytes) {
+    super(
+      `Bytes value "${bytes}" is not a valid boolean. The bytes array must contain a single byte of either a 0 or 1 value.`
+    );
+    __publicField(this, "name", "InvalidBytesBooleanError");
+  }
+};
+var InvalidHexBooleanError = class extends BaseError {
+  constructor(hex) {
+    super(
+      `Hex value "${hex}" is not a valid boolean. The hex value must be "0x0" (false) or "0x1" (true).`
+    );
+    __publicField(this, "name", "InvalidHexBooleanError");
+  }
+};
+var InvalidHexValueError = class extends BaseError {
+  constructor(value) {
+    super(
+      `Hex value "${value}" is an odd length (${value.length}). It must be an even length.`
+    );
+    __publicField(this, "name", "InvalidHexValueError");
+  }
+};
+var OffsetOutOfBoundsError = class extends BaseError {
+  constructor({ nextOffset, offset }) {
+    super(
+      `Next offset (${nextOffset}) is greater than previous offset + consumed bytes (${offset})`
+    );
+    __publicField(this, "name", "OffsetOutOfBoundsError");
+  }
+};
+
+// src/errors/log.ts
+var FilterTypeNotSupportedError = class extends BaseError {
+  constructor(type) {
+    super(`Filter type "${type}" is not supported.`);
+    __publicField(this, "name", "FilterTypeNotSupportedError");
+  }
+};
+
+// src/errors/request.ts
+var RequestError = class extends BaseError {
+  constructor(err, { docsPath: docsPath5, humanMessage }) {
+    super(humanMessage, {
+      cause: err,
+      docsPath: docsPath5
+    });
+    this.name = err.name;
+  }
+};
+var RpcRequestError = class extends RequestError {
+  constructor(err, { docsPath: docsPath5, humanMessage }) {
+    super(err, { docsPath: docsPath5, humanMessage });
+    __publicField(this, "code");
+    this.code = err.code;
+    this.name = err.name;
+  }
+};
+var ParseRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, {
+      humanMessage: "Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text."
+    });
+    __publicField(this, "name", "ParseRpcError");
+    __publicField(this, "code", -32700);
+  }
+};
+var InvalidRequestRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { humanMessage: "JSON is not a valid request object." });
+    __publicField(this, "name", "InvalidRequestRpcError");
+    __publicField(this, "code", -32600);
+  }
+};
+var MethodNotFoundRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, {
+      humanMessage: "The method does not exist / is not available."
+    });
+    __publicField(this, "name", "MethodNotFoundRpcError");
+    __publicField(this, "code", -32601);
+  }
+};
+var InvalidParamsRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, {
+      humanMessage: [
+        "Invalid parameters were provided to the RPC method.",
+        "Double check you have provided the correct parameters."
+      ].join("\n")
+    });
+    __publicField(this, "name", "InvalidParamsRpcError");
+    __publicField(this, "code", -32602);
+  }
+};
+var InternalRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { humanMessage: "An internal error was received." });
+    __publicField(this, "name", "InternalRpcError");
+    __publicField(this, "code", -32603);
+  }
+};
+var InvalidInputRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, {
+      humanMessage: [
+        "Missing or invalid parameters.",
+        "Double check you have provided the correct parameters."
+      ].join("\n")
+    });
+    __publicField(this, "name", "InvalidInputRpcError");
+    __publicField(this, "code", -32e3);
+  }
+};
+var ResourceNotFoundRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { humanMessage: "Requested resource not found." });
+    __publicField(this, "name", "ResourceNotFoundRpcError");
+    __publicField(this, "code", -32001);
+  }
+};
+var ResourceUnavailableRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { humanMessage: "Requested resource not available." });
+    __publicField(this, "name", "ResourceUnavailableRpcError");
+    __publicField(this, "code", -32002);
+  }
+};
+var TransactionRejectedRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { humanMessage: "Transaction creation failed." });
+    __publicField(this, "name", "TransactionRejectedRpcError");
+    __publicField(this, "code", -32003);
+  }
+};
+var MethodNotSupportedRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { humanMessage: "Method is not implemented." });
+    __publicField(this, "name", "MethodNotSupportedRpcError");
+    __publicField(this, "code", -32004);
+  }
+};
+var LimitExceededRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { humanMessage: "Request exceeds defined limit." });
+    __publicField(this, "name", "LimitExceededRpcError");
+    __publicField(this, "code", -32005);
+  }
+};
+var JsonRpcVersionUnsupportedError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, {
+      humanMessage: "Version of JSON-RPC protocol is not supported."
+    });
+    __publicField(this, "name", "JsonRpcVersionUnsupportedError");
+    __publicField(this, "code", -32006);
+  }
+};
+var UnknownRpcError = class extends RequestError {
+  constructor(err) {
+    super(err, {
+      humanMessage: "An unknown RPC error occurred."
+    });
+    __publicField(this, "name", "UnknownRpcError");
+  }
+};
+
+// src/errors/rpc.ts
+var HttpRequestError = class extends BaseError {
+  constructor({
+    body,
+    details,
+    status,
+    url
+  }) {
+    super(
+      [
+        "HTTP request failed.",
+        "",
+        `Status: ${status}`,
+        `URL: ${url}`,
+        `Request body: ${stringify(body)}`
+      ].join("\n"),
+      {
+        details
+      }
+    );
+    __publicField(this, "name", "HttpRequestError");
+    __publicField(this, "status");
+    this.status = status;
+  }
+};
+var WebSocketRequestError = class extends BaseError {
+  constructor({
+    body,
+    details,
+    url
+  }) {
+    super(
+      [
+        "WebSocket request failed.",
+        "",
+        `URL: ${url}`,
+        `Request body: ${stringify(body)}`
+      ].join("\n"),
+      {
+        details
+      }
+    );
+    __publicField(this, "name", "WebSocketRequestError");
+  }
+};
+var RpcError = class extends BaseError {
+  constructor({
+    body,
+    error,
+    url
+  }) {
+    super(
+      [
+        "RPC Request failed.",
+        "",
+        `URL: ${url}`,
+        `Request body: ${stringify(body)}`
+      ].join("\n"),
+      {
+        cause: error,
+        details: error.message
+      }
+    );
+    __publicField(this, "code");
+    __publicField(this, "name", "RpcError");
+    this.code = error.code;
+  }
+};
+var TimeoutError = class extends BaseError {
+  constructor({
+    body,
+    url
+  }) {
+    super(
+      [
+        "The request took too long to respond.",
+        "",
+        `URL: ${url}`,
+        `Request body: ${stringify(body)}`
+      ].join("\n"),
+      {
+        details: "The request timed out."
+      }
+    );
+    __publicField(this, "name", "TimeoutError");
+  }
+};
+
+// src/errors/transaction.ts
+var InvalidGasArgumentsError = class extends BaseError {
+  constructor() {
+    super("`maxFeePerGas` cannot be less than `maxPriorityFeePerGas`");
+    __publicField(this, "name", "InvalidGasArgumentsError");
+  }
+};
+var TransactionNotFoundError = class extends BaseError {
+  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.`);
+    __publicField(this, "name", "TransactionNotFoundError");
+  }
+};
+var TransactionReceiptNotFoundError = class extends BaseError {
+  constructor({ hash: hash2 }) {
+    super(
+      `Transaction receipt with hash "${hash2}" could not be found. The Transaction may not be processed on a block yet.`
+    );
+    __publicField(this, "name", "TransactionReceiptNotFoundError");
+  }
+};
+var WaitForTransactionReceiptTimeoutError = class extends BaseError {
+  constructor({ hash: hash2 }) {
+    super(
+      `Timed out while waiting for transaction with hash "${hash2}" to be confirmed.`
+    );
+    __publicField(this, "name", "WaitForTransactionReceiptTimeoutError");
+  }
+};
+
+// src/errors/transport.ts
+var UrlRequiredError = class extends BaseError {
+  constructor() {
+    super(
+      "No URL was provided to the Transport. Please provide a valid RPC URL to the Transport.",
+      {
+        docsPath: "/docs/clients/intro"
+      }
+    );
+  }
+};
+
+// src/utils/data/concat.ts
+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", ""),
+    ""
+  )}`;
+}
+
+// src/utils/data/isBytes.ts
+function isBytes(value) {
+  if (!value)
+    return false;
+  if (typeof value !== "object")
+    return false;
+  return value.BYTES_PER_ELEMENT === 1 && value.constructor.name === "Uint8Array";
+}
+
+// src/utils/data/isHex.ts
+function isHex(value) {
+  if (!value)
+    return false;
+  if (typeof value !== "string")
+    return false;
+  return /^0x[0-9a-fA-F]*$/.test(value);
+}
+
+// src/utils/data/pad.ts
+function pad(hexOrBytes, { dir, size: size2 = 32 } = {}) {
+  if (typeof hexOrBytes === "string")
+    return padHex(hexOrBytes, { dir, size: size2 });
+  return padBytes(hexOrBytes, { dir, size: size2 });
+}
+function padHex(hex_, { dir, size: size2 = 32 } = {}) {
+  let hex = hex_.replace("0x", "");
+  if (hex.length > size2 * 2)
+    throw new SizeExceedsPaddingSizeError({
+      size: Math.ceil(hex.length / 2),
+      targetSize: size2,
+      type: "hex"
+    });
+  return `0x${hex[dir === "right" ? "padEnd" : "padStart"](
+    size2 * 2,
+    "0"
+  )}`;
+}
+function padBytes(bytes, { dir, size: size2 = 32 } = {}) {
+  if (bytes.length > size2)
+    throw new SizeExceedsPaddingSizeError({
+      size: bytes.length,
+      targetSize: size2,
+      type: "bytes"
+    });
+  const paddedBytes = new Uint8Array(size2);
+  for (let i = 0; i < size2; i++) {
+    const padEnd = dir === "right";
+    paddedBytes[padEnd ? i : size2 - i - 1] = bytes[padEnd ? i : bytes.length - i - 1];
+  }
+  return paddedBytes;
+}
+
+// src/utils/data/trim.ts
+function trim(hexOrBytes, { dir = "left" } = {}) {
+  let data = typeof hexOrBytes === "string" ? hexOrBytes.replace("0x", "") : hexOrBytes;
+  let sliceLength = 0;
+  for (let i = 0; i < data.length - 1; i++) {
+    if (data[dir === "left" ? i : data.length - i - 1].toString() === "0")
+      sliceLength++;
+    else
+      break;
+  }
+  data = dir === "left" ? data.slice(sliceLength) : data.slice(0, data.length - sliceLength);
+  if (typeof hexOrBytes === "string") {
+    if (data.length === 1 && dir === "right")
+      data = `${data}0`;
+    return `0x${data}`;
+  }
+  return data;
+}
+
+// src/utils/data/size.ts
+function size(value) {
+  if (isHex(value))
+    return Math.ceil((value.length - 2) / 2);
+  return value.length;
+}
+
+// src/utils/data/slice.ts
+function slice(value, start, end) {
+  if (isHex(value))
+    return sliceHex(value, start, end);
+  return sliceBytes(value, start, end);
+}
+function assertStartOffset(value, start) {
+  if (typeof start === "number" && start > 0 && start > size(value) - 1)
+    throw new Error(
+      `Slice starting at offset "${start}" is out-of-bounds (size: ${size(
+        value
+      )}).`
+    );
+}
+function sliceBytes(value, start, end) {
+  assertStartOffset(value, start);
+  return value.slice(start, end);
+}
+function sliceHex(value_, start, end) {
+  assertStartOffset(value_, start);
+  const value = value_.replace("0x", "").slice((_nullishCoalesce(start, () => ( 0))) * 2, (_nullishCoalesce(end, () => ( value_.length))) * 2);
+  return `0x${value}`;
+}
+
+// src/utils/encoding/encodeHex.ts
+var hexes = Array.from(
+  { length: 256 },
+  (v, i) => i.toString(16).padStart(2, "0")
+);
+function boolToHex(value) {
+  return `0x${Number(value)}`;
+}
+function bytesToHex(value) {
+  let hex = "";
+  for (let i = 0; i < value.length; i++) {
+    hex += hexes[value[i]];
+  }
+  return `0x${hex}`;
+}
+function encodeHex(value) {
+  if (typeof value === "number" || typeof value === "bigint")
+    return numberToHex(value);
+  if (typeof value === "string") {
+    return stringToHex(value);
+  }
+  if (typeof value === "boolean")
+    return boolToHex(value);
+  return bytesToHex(value);
+}
+function numberToHex(value_, opts = {}) {
+  const { signed, size: size2 } = opts;
+  let value = BigInt(value_);
+  let maxValue;
+  if (size2) {
+    if (signed)
+      maxValue = (1n << BigInt(size2) * 8n - 1n) - 1n;
+    else
+      maxValue = 2n ** (BigInt(size2) * 8n) - 1n;
+  } else if (typeof value_ === "number") {
+    maxValue = BigInt(Number.MAX_SAFE_INTEGER);
+  }
+  const minValue = typeof maxValue === "bigint" && signed ? -maxValue - 1n : 0;
+  if (maxValue && value > maxValue || value < minValue) {
+    const suffix = typeof value_ === "bigint" ? "n" : "";
+    throw new Error(
+      `Number "${value_}${suffix}" is not in safe ${size2 ? `${size2 * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${maxValue ? `(${minValue}${suffix} to ${maxValue}${suffix})` : `(above ${minValue})`}`
+    );
+  }
+  const hex = `0x${(signed && value < 0 ? (1n << BigInt(size2 * 8)) + BigInt(value) : value).toString(16)}`;
+  if (size2)
+    return pad(hex, { size: size2 });
+  return hex;
+}
+function stringToHex(value) {
+  let hex = "";
+  for (let i = 0; i < value.length; i++) {
+    hex += value.charCodeAt(i).toString(16);
+  }
+  return `0x${hex}`;
+}
+
+// src/utils/encoding/encodeBytes.ts
+var encoder = new TextEncoder();
+function boolToBytes(value) {
+  const bytes = new Uint8Array(1);
+  bytes[0] = Number(value);
+  return bytes;
+}
+function encodeBytes(value) {
+  if (typeof value === "number" || typeof value === "bigint")
+    return numberToBytes(value);
+  if (typeof value === "boolean")
+    return boolToBytes(value);
+  if (value.startsWith("0x"))
+    return hexToBytes(value);
+  return stringToBytes(value);
+}
+function hexToBytes(hex_) {
+  let hex = hex_.slice(2);
+  if (hex.length % 2)
+    hex = `0${hex}`;
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let index = 0; index < bytes.length; index++) {
+    const start = index * 2;
+    const hexByte = hex.slice(start, start + 2);
+    const byte = Number.parseInt(hexByte, 16);
+    if (Number.isNaN(byte) || byte < 0)
+      throw new Error("Invalid byte sequence");
+    bytes[index] = byte;
+  }
+  return bytes;
+}
+function numberToBytes(value, opts) {
+  const hex = numberToHex(value, opts);
+  return hexToBytes(hex);
+}
+function stringToBytes(value) {
+  return encoder.encode(value);
+}
+
+// src/utils/encoding/encodeRlp.ts
+function encodeRlp(hexOrBytes, to_) {
+  const to = to_ || "hex";
+  return format(bytesToRlp(parse(hexOrBytes)), to);
+}
+function parse(hexOrBytes) {
+  if (Array.isArray(hexOrBytes))
+    return hexOrBytes.map(parse);
+  return typeof hexOrBytes === "string" ? encodeBytes(hexOrBytes) : hexOrBytes;
+}
+function format(bytes, type = "bytes") {
+  return type === "hex" ? bytesToHex(bytes) : bytes;
+}
+function bytesToRlp(bytes) {
+  if (Array.isArray(bytes)) {
+    const encoded = concat(bytes.map(bytesToRlp));
+    return new Uint8Array([...encodeLength(encoded.length, 192), ...encoded]);
+  }
+  if (bytes.length === 1 && bytes[0] < 128)
+    return bytes;
+  return new Uint8Array([...encodeLength(bytes.length, 128), ...bytes]);
+}
+function encodeLength(length, offset) {
+  if (length < 56)
+    return [offset + length];
+  return [encodeBytes(length).length + offset + 55, ...encodeBytes(length)];
+}
+
+// src/utils/encoding/decodeHex.ts
+function decodeHex(hex, to) {
+  if (to === "number")
+    return hexToNumber(hex);
+  if (to === "bigint")
+    return hexToBigInt(hex);
+  if (to === "string")
+    return hexToString(hex);
+  if (to === "boolean")
+    return hexToBool(hex);
+  return hexToBytes(hex);
+}
+function hexToBigInt(hex, opts = {}) {
+  const { signed } = opts;
+  const value = BigInt(hex);
+  if (!signed)
+    return value;
+  const size2 = (hex.length - 2) / 2;
+  const max = (1n << BigInt(size2) * 8n - 1n) - 1n;
+  if (value <= max)
+    return value;
+  return value - BigInt(`0x${"f".padStart(size2 * 2, "f")}`) - 1n;
+}
+function hexToBool(hex) {
+  if (trim(hex) === "0x0")
+    return false;
+  if (trim(hex) === "0x1")
+    return true;
+  throw new InvalidHexBooleanError(hex);
+}
+function hexToNumber(hex, opts = {}) {
+  return Number(hexToBigInt(hex, opts));
+}
+function hexToString(hex) {
+  const bytes = hexToBytes(hex);
+  return new TextDecoder().decode(bytes);
+}
+
+// src/utils/encoding/decodeBytes.ts
+function decodeBytes(bytes, to) {
+  if (to === "number")
+    return bytesToNumber(bytes);
+  if (to === "bigint")
+    return bytesToBigint(bytes);
+  if (to === "boolean")
+    return bytesToBool(bytes);
+  if (to === "string")
+    return bytesToString(bytes);
+  return bytesToHex(bytes);
+}
+function bytesToBigint(bytes) {
+  const hex = bytesToHex(bytes);
+  return hexToBigInt(hex);
+}
+function bytesToBool(bytes) {
+  if (bytes.length > 1 || bytes[0] > 1)
+    throw new InvalidBytesBooleanError(bytes);
+  return Boolean(bytes[0]);
+}
+function bytesToNumber(bytes) {
+  const hex = bytesToHex(bytes);
+  return hexToNumber(hex);
+}
+function bytesToString(bytes) {
+  return new TextDecoder().decode(bytes);
+}
+
+// src/utils/encoding/decodeRlp.ts
+function decodeRlp(value, to) {
+  const bytes = parse2(value);
+  const [data, consumed] = rlpToBytes(bytes);
+  if (consumed < bytes.length)
+    throw new DataLengthTooLongError({
+      consumed,
+      length: bytes.length
+    });
+  return format2(data, to);
+}
+function parse2(value) {
+  if (typeof value === "string") {
+    if (value.length > 3 && value.length % 2 !== 0)
+      throw new InvalidHexValueError(value);
+    return hexToBytes(value);
+  }
+  return value;
+}
+function format2(bytes, to) {
+  if (Array.isArray(bytes))
+    return bytes.map((b) => format2(b, to));
+  return to === "hex" ? trim(bytesToHex(bytes)) : bytes;
+}
+function rlpToBytes(bytes, offset = 0) {
+  if (bytes.length === 0)
+    return [new Uint8Array([]), 0];
+  const prefix = bytes[offset];
+  if (prefix <= 127)
+    return [new Uint8Array([bytes[offset]]), 1];
+  if (prefix <= 183) {
+    const length2 = prefix - 128;
+    const offset_ = offset + 1;
+    if (offset_ + length2 > bytes.length)
+      throw new DataLengthTooShortError({
+        length: offset_ + length2,
+        dataLength: bytes.length
+      });
+    return [bytes.slice(offset_, offset_ + length2), 1 + length2];
+  }
+  if (prefix <= 191) {
+    const lengthOfLength2 = prefix - 183;
+    const offset_ = offset + 1;
+    const length2 = bytesToNumber(bytes.slice(offset_, offset_ + lengthOfLength2));
+    if (offset_ + lengthOfLength2 + length2 > bytes.length)
+      throw new DataLengthTooShortError({
+        length: lengthOfLength2 + length2,
+        dataLength: bytes.length - lengthOfLength2
+      });
+    return [
+      bytes.slice(offset_ + lengthOfLength2, offset_ + lengthOfLength2 + length2),
+      1 + lengthOfLength2 + length2
+    ];
+  }
+  let lengthOfLength = 0;
+  let length = prefix - 192;
+  if (prefix > 247) {
+    lengthOfLength = prefix - 247;
+    length = bytesToNumber(bytes.slice(offset + 1, offset + 1 + lengthOfLength));
+  }
+  let nextOffset = offset + 1 + lengthOfLength;
+  if (nextOffset > bytes.length)
+    throw new DataLengthTooShortError({
+      length: nextOffset,
+      dataLength: bytes.length
+    });
+  let consumed = 1 + lengthOfLength + length;
+  let result = [];
+  while (nextOffset < offset + consumed) {
+    const decoded = rlpToBytes(bytes, nextOffset);
+    result.push(decoded[0]);
+    nextOffset += decoded[1];
+    if (nextOffset > offset + consumed)
+      throw new OffsetOutOfBoundsError({
+        nextOffset,
+        offset: offset + consumed
+      });
+  }
+  return [result, consumed];
+}
+
+// src/utils/contract/extractFunctionParts.ts
+var paramsRegex = /((function|event)\s)?(.*)(\((.*)\))/;
+function extractFunctionParts(def) {
+  const parts = def.match(paramsRegex);
+  const type = _optionalChain([parts, 'optionalAccess', _5 => _5[2]]) || void 0;
+  const name = _optionalChain([parts, 'optionalAccess', _6 => _6[3]]);
+  const params = _optionalChain([parts, 'optionalAccess', _7 => _7[5]]) || void 0;
+  return { type, name, params };
+}
+function extractFunctionName(def) {
+  return extractFunctionParts(def).name;
+}
+function extractFunctionParams(def) {
+  const params = extractFunctionParts(def).params;
+  const splitParams = _optionalChain([params, 'optionalAccess', _8 => _8.split, 'call', _9 => _9(","), 'access', _10 => _10.map, 'call', _11 => _11((x) => x.trim().split(" "))]);
+  return _optionalChain([splitParams, 'optionalAccess', _12 => _12.map, 'call', _13 => _13((param) => ({
+    type: param[0],
+    name: param[1] === "indexed" ? param[2] : param[1],
+    ...param[1] === "indexed" ? { indexed: true } : {}
+  }))]);
+}
+function extractFunctionType(def) {
+  return extractFunctionParts(def).type;
+}
+
+// src/utils/contract/getContractError.ts
+function getContractError(err, {
+  abi,
+  address,
+  args,
+  functionName,
+  sender
+}) {
+  const { code, message } = err.cause || {};
+  const abiItem = getAbiItem({ abi, name: functionName });
+  const formattedArgs = abiItem ? formatAbiItemWithArgs({
+    abiItem,
+    args,
+    includeFunctionName: false,
+    includeName: false
+  }) : void 0;
+  const functionWithParams = abiItem ? formatAbiItemWithParams(abiItem, { includeName: true }) : void 0;
+  if (err instanceof AbiDecodingZeroDataError) {
+    return new ContractMethodZeroDataError({
+      abi,
+      args,
+      cause: err,
+      contractAddress: address,
+      functionName,
+      functionWithParams
+    });
+  }
+  if (code === 3 || _optionalChain([message, 'optionalAccess', _14 => _14.includes, 'call', _15 => _15("execution reverted")])) {
+    const message_ = _optionalChain([message, 'optionalAccess', _16 => _16.replace, 'call', _17 => _17("execution reverted: ", "")]);
+    return new ContractMethodExecutionError(message_, {
+      abi,
+      args,
+      cause: err,
+      contractAddress: address,
+      formattedArgs,
+      functionName,
+      functionWithParams,
+      sender
+    });
+  }
+  return err;
+}
+
+// src/utils/hash/keccak256.ts
+var _sha3 = require('@noble/hashes/sha3');
+function keccak256(value, to_) {
+  const to = to_ || "hex";
+  const bytes = _sha3.keccak_256.call(void 0, value);
+  if (to === "bytes")
+    return bytes;
+  return encodeHex(bytes);
+}
+
+// src/utils/hash/hashFunction.ts
+var hash = (value) => keccak256(encodeBytes(value));
+function hashFunction(def) {
+  const name = extractFunctionName(def);
+  const params = extractFunctionParams(def);
+  if (!params || params.length === 0)
+    return hash(def.replace(/ /g, ""));
+  return hash(`${name}(${params.map(({ type }) => type).join(",")})`);
+}
+
+// src/utils/hash/getEventSignature.ts
+var getEventSignature = (event) => hashFunction(event);
+
+// src/utils/hash/getFunctionSignature.ts
+var getFunctionSignature = (fn) => slice(hashFunction(fn), 0, 4);
+
+// src/utils/address/getAddress.ts
+var addressRegex = /^(0x)?[a-fA-F0-9]{40}$/;
+function checksumAddress(address_) {
+  const hexAddress = address_.substring(2).toLowerCase();
+  const hash2 = keccak256(stringToBytes(hexAddress), "bytes");
+  let address = hexAddress.split("");
+  for (let i = 0; i < 40; i += 2) {
+    if (_optionalChain([hash2, 'optionalAccess', _18 => _18[i >> 1]]) >> 4 >= 8 && address[i]) {
+      address[i] = address[i].toUpperCase();
+    }
+    if ((hash2[i >> 1] & 15) >= 8 && address[i + 1]) {
+      address[i + 1] = address[i + 1].toUpperCase();
+    }
+  }
+  return `0x${address.join("")}`;
+}
+function getAddress(address) {
+  if (!addressRegex.test(address))
+    throw new InvalidAddressError({ address });
+  return checksumAddress(address);
+}
+
+// src/utils/address/getContractAddress.ts
+function getContractAddress(opts) {
+  if (opts.opcode === "CREATE2")
+    return getCreate2Address(opts);
+  return getCreateAddress(opts);
+}
+function getCreateAddress(opts) {
+  const from = encodeBytes(getAddress(opts.from));
+  let nonce = encodeBytes(opts.nonce);
+  if (nonce[0] === 0)
+    nonce = new Uint8Array([]);
+  return getAddress(
+    `0x${keccak256(encodeRlp([from, nonce], "bytes")).slice(26)}`
+  );
+}
+function getCreate2Address(opts) {
+  const from = encodeBytes(getAddress(opts.from));
+  const salt = pad(
+    isBytes(opts.salt) ? opts.salt : encodeBytes(opts.salt),
+    { size: 32 }
+  );
+  const bytecodeHash = encodeBytes(
+    keccak256(
+      isBytes(opts.bytecode) ? opts.bytecode : encodeBytes(opts.bytecode)
+    )
+  );
+  return getAddress(
+    slice(
+      keccak256(concat([encodeBytes("0xff"), from, salt, bytecodeHash])),
+      12
+    )
+  );
+}
+
+// src/utils/address/isAddress.ts
+function isAddress(address) {
+  try {
+    return Boolean(getAddress(address));
+  } catch (e) {
+    return false;
+  }
+}
+
+// src/utils/address/isAddressEqual.ts
+function isAddressEqual(a, b) {
+  return getAddress(a) === getAddress(b);
+}
+
+// src/utils/abi/encodeAbi.ts
+function encodeAbi({
+  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
+}) {
+  let 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");
+    return encodeNumber(value, { signed });
+  }
+  if (param.type.startsWith("bytes")) {
+    return encodeBytes2(value, { param });
+  }
+  if (param.type === "string") {
+    return encodeString(value);
+  }
+  throw new InvalidAbiEncodingTypeError(param.type, {
+    docsPath: "/docs/contract/encodeAbi"
+  });
+}
+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);
+  }
+  let staticParams = [];
+  let 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) {
+  return { dynamic: false, encoded: padHex(value.toLowerCase()) };
+}
+function encodeArray(value, {
+  length,
+  param
+}) {
+  let 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;
+  let 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 encodeBytes2(value, { param }) {
+  const [_, size_] = param.type.split("bytes");
+  if (!size_)
+    return {
+      dynamic: true,
+      encoded: concat([
+        padHex(numberToHex(size(value), { size: 32 })),
+        padHex(value, { dir: "right" })
+      ])
+    };
+  return { dynamic: false, encoded: padHex(value, { dir: "right" }) };
+}
+function encodeBool(value) {
+  return { dynamic: false, encoded: padHex(boolToHex(value)) };
+}
+function encodeNumber(value, { signed }) {
+  return {
+    dynamic: false,
+    encoded: numberToHex(value, {
+      size: 32,
+      signed
+    })
+  };
+}
+function encodeString(value) {
+  return {
+    dynamic: true,
+    encoded: concat([
+      padHex(numberToHex(value.length, { size: 32 })),
+      padHex(stringToHex(value), { dir: "right" })
+    ])
+  };
+}
+function encodeTuple(value, { param }) {
+  let dynamic = false;
+  let 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);
+    dynamic = preparedParam.dynamic;
+  }
+  return {
+    dynamic,
+    encoded: dynamic ? encodeParams(preparedParams) : concat(preparedParams.map(({ encoded }) => encoded))
+  };
+}
+function getArrayComponents(type) {
+  const matches = type.match(/^(.*)\[(\d+)?\]$/);
+  return matches ? [matches[2] ? Number(matches[2]) : null, matches[1]] : void 0;
+}
+
+// src/utils/abi/decodeAbi.ts
+function decodeAbi({
+  data,
+  params
+}) {
+  if (data === "0x" && params.length > 0)
+    throw new AbiDecodingZeroDataError();
+  if (size(data) % 32 !== 0)
+    throw new AbiDecodingDataSizeInvalidError(size(data));
+  const values = decodeParams({
+    data,
+    params
+  });
+  if (values.length === 0)
+    return void 0;
+  return values;
+}
+function decodeParams({
+  data,
+  params
+}) {
+  let decodedValues = [];
+  let position = 0;
+  for (let i = 0; i < params.length; i++) {
+    const param = params[i];
+    const { consumed, value } = decodeParam({ data, param, position });
+    decodedValues.push(value);
+    position += consumed;
+  }
+  return decodedValues;
+}
+function decodeParam({
+  data,
+  param,
+  position
+}) {
+  const arrayComponents = getArrayComponents(param.type);
+  if (arrayComponents) {
+    const [length, type] = arrayComponents;
+    return decodeArray(data, {
+      length,
+      param: { ...param, type },
+      position
+    });
+  }
+  if (param.type === "tuple") {
+    return decodeTuple(data, { param, position });
+  }
+  if (param.type === "string") {
+    return decodeString(data, { position });
+  }
+  if (param.type.startsWith("bytes")) {
+    return decodeBytes2(data, { param, position });
+  }
+  let value = slice(data, position, position + 32);
+  if (param.type.startsWith("uint") || param.type.startsWith("int")) {
+    return decodeNumber(value, { param });
+  }
+  if (param.type === "address") {
+    return decodeAddress(value);
+  }
+  if (param.type === "bool") {
+    return decodeBool(value);
+  }
+  throw new InvalidAbiDecodingTypeError(param.type, {
+    docsPath: "/docs/contract/decodeAbi"
+  });
+}
+function decodeAddress(value) {
+  return { consumed: 32, value: checksumAddress(slice(value, -20)) };
+}
+function decodeArray(data, {
+  param,
+  length,
+  position
+}) {
+  if (!length) {
+    const offset = hexToNumber(slice(data, position, position + 32));
+    const length2 = hexToNumber(slice(data, offset, offset + 32));
+    let consumed2 = 0;
+    let value2 = [];
+    for (let i = 0; i < length2; ++i) {
+      const decodedChild = decodeParam({
+        data: slice(data, offset + 32),
+        param,
+        position: consumed2
+      });
+      consumed2 += decodedChild.consumed;
+      value2.push(decodedChild.value);
+    }
+    return { value: value2, consumed: 32 };
+  }
+  if (hasDynamicChild(param)) {
+    const arrayComponents = getArrayComponents(param.type);
+    const dynamicChild = !_optionalChain([arrayComponents, 'optionalAccess', _19 => _19[0]]);
+    let consumed2 = 0;
+    let value2 = [];
+    for (let i = 0; i < length; ++i) {
+      const offset = hexToNumber(slice(data, position, position + 32));
+      const decodedChild = decodeParam({
+        data: slice(data, offset),
+        param,
+        position: dynamicChild ? consumed2 : i * 32
+      });
+      consumed2 += decodedChild.consumed;
+      value2.push(decodedChild.value);
+    }
+    return { value: value2, consumed: consumed2 };
+  }
+  let consumed = 0;
+  let value = [];
+  for (let i = 0; i < length; ++i) {
+    const decodedChild = decodeParam({
+      data,
+      param,
+      position: position + consumed
+    });
+    consumed += decodedChild.consumed;
+    value.push(decodedChild.value);
+  }
+  return { value, consumed };
+}
+function decodeBool(value) {
+  return { consumed: 32, value: hexToBool(value) };
+}
+function decodeBytes2(data, { param, position }) {
+  const [_, size2] = param.type.split("bytes");
+  if (!size2) {
+    const offset = hexToNumber(slice(data, position, position + 32));
+    const length = hexToNumber(slice(data, offset, offset + 32));
+    const value2 = slice(data, offset + 32, offset + 32 + length);
+    return { consumed: 32, value: value2 };
+  }
+  const value = slice(data, position, position + parseInt(size2));
+  return { consumed: 32, value };
+}
+function decodeNumber(value, { param }) {
+  const signed = param.type.startsWith("int");
+  const size2 = parseInt(param.type.split("int")[1] || "256");
+  return {
+    consumed: 32,
+    value: size2 > 48 ? hexToBigInt(value, { signed }) : hexToNumber(value, { signed })
+  };
+}
+function decodeString(data, { position }) {
+  const offset = hexToNumber(slice(data, position, position + 32));
+  const length = hexToNumber(slice(data, offset, offset + 32));
+  const value = hexToString(
+    trim(slice(data, offset + 32, offset + 32 + length))
+  );
+  return { consumed: 32, value };
+}
+function decodeTuple(data, { param, position }) {
+  const hasUnnamedChild = param.components.length === 0 || param.components.some(({ name }) => !name);
+  let value = hasUnnamedChild ? [] : {};
+  let consumed = 0;
+  if (hasDynamicChild(param)) {
+    const offset = hexToNumber(slice(data, position, position + 32));
+    for (let i = 0; i < param.components.length; ++i) {
+      const component = param.components[i];
+      const decodedChild = decodeParam({
+        data: slice(data, offset),
+        param: component,
+        position: consumed
+      });
+      consumed += decodedChild.consumed;
+      value[hasUnnamedChild ? i : _optionalChain([component, 'optionalAccess', _20 => _20.name])] = decodedChild.value;
+    }
+    return { consumed: 32, value };
+  }
+  for (let i = 0; i < param.components.length; ++i) {
+    const component = param.components[i];
+    const decodedChild = decodeParam({
+      data,
+      param: component,
+      position: position + consumed
+    });
+    consumed += decodedChild.consumed;
+    value[hasUnnamedChild ? i : _optionalChain([component, 'optionalAccess', _21 => _21.name])] = decodedChild.value;
+  }
+  return { consumed, value };
+}
+function hasDynamicChild(param) {
+  const { type } = param;
+  if (type === "string")
+    return true;
+  if (type === "bytes")
+    return true;
+  if (type.endsWith("[]"))
+    return true;
+  if (type === "tuple")
+    return _optionalChain([param, 'access', _22 => _22.components, 'optionalAccess', _23 => _23.some, 'call', _24 => _24(hasDynamicChild)]);
+  const arrayComponents = getArrayComponents(param.type);
+  if (arrayComponents && hasDynamicChild({ ...param, type: arrayComponents[1] }))
+    return true;
+  return false;
+}
+
+// src/utils/abi/formatAbiItemWithParams.ts
+function formatAbiItemWithParams(abiItem, { includeName = false } = {}) {
+  if (abiItem.type !== "function" && abiItem.type !== "event" && abiItem.type !== "error")
+    throw new InvalidDefinitionTypeError(abiItem.type);
+  return `${abiItem.name}(${getParams(abiItem.inputs, { includeName })})`;
+}
+function getParams(params, { includeName }) {
+  if (!params)
+    return "";
+  return params.map((param) => getParam(param, { includeName })).join(includeName ? ", " : ",");
+}
+function getParam(param, { includeName }) {
+  if (param.type.startsWith("tuple")) {
+    return `(${getParams(
+      param.components,
+      { includeName }
+    )})${param.type.slice("tuple".length)}`;
+  }
+  return param.type + (includeName && param.name ? ` ${param.name}` : "");
+}
+
+// src/utils/abi/decodeErrorResult.ts
+function decodeErrorResult({ abi, data }) {
+  const signature = slice(data, 0, 4);
+  const description = abi.find(
+    (x) => signature === getFunctionSignature(formatAbiItemWithParams(x))
+  );
+  if (!description)
+    throw new AbiErrorSignatureNotFoundError(signature, {
+      docsPath: "/docs/contract/decodeErrorResult"
+    });
+  return {
+    errorName: description.name,
+    args: "inputs" in description && description.inputs && description.inputs.length > 0 ? decodeAbi({ data: slice(data, 4), params: description.inputs }) : void 0
+  };
+}
+
+// src/utils/abi/decodeFunctionData.ts
+function decodeFunctionData({ abi, data }) {
+  const signature = slice(data, 0, 4);
+  const description = abi.find(
+    (x) => signature === getFunctionSignature(formatAbiItemWithParams(x))
+  );
+  if (!description)
+    throw new AbiFunctionSignatureNotFoundError(signature, {
+      docsPath: "/docs/contract/decodeFunctionData"
+    });
+  return {
+    functionName: description.name,
+    args: "inputs" in description && description.inputs && description.inputs.length > 0 ? decodeAbi({ data: slice(data, 4), params: description.inputs }) : void 0
+  };
+}
+
+// src/utils/abi/decodeFunctionResult.ts
+var docsPath = "/docs/contract/decodeFunctionResult";
+function decodeFunctionResult({
+  abi,
+  functionName,
+  data
+}) {
+  const description = abi.find(
+    (x) => "name" in x && x.name === functionName
+  );
+  if (!description)
+    throw new AbiFunctionNotFoundError(functionName, { docsPath });
+  if (!("outputs" in description))
+    throw new AbiFunctionOutputsNotFoundError(functionName, { docsPath });
+  const values = decodeAbi({ data, params: description.outputs });
+  if (values && values.length > 1)
+    return values;
+  if (values && values.length === 1)
+    return values[0];
+  return void 0;
+}
+
+// src/utils/abi/encodeDeployData.ts
+var docsPath2 = "/docs/contract/encodeDeployData";
+function encodeDeployData({
+  abi,
+  args,
+  bytecode
+}) {
+  if (!args || args.length === 0)
+    return bytecode;
+  const description = abi.find((x) => "type" in x && x.type === "constructor");
+  if (!description)
+    throw new AbiConstructorNotFoundError({ docsPath: docsPath2 });
+  if (!("inputs" in description))
+    throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath2 });
+  if (!description.inputs || description.inputs.length === 0)
+    throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath2 });
+  const data = encodeAbi({
+    params: description.inputs,
+    values: args
+  });
+  return concatHex([bytecode, data]);
+}
+
+// src/utils/abi/getAbiItem.ts
+function getAbiItem({ abi, name }) {
+  return abi.find((x) => "name" in x && x.name === name);
+}
+
+// src/utils/abi/encodeErrorResult.ts
+var docsPath3 = "/docs/contract/encodeErrorResult";
+function encodeErrorResult({ abi, errorName, args }) {
+  const description = getAbiItem({ abi, name: errorName });
+  if (!description)
+    throw new AbiErrorNotFoundError(errorName, { docsPath: docsPath3 });
+  const definition = formatAbiItemWithParams(description);
+  const signature = getFunctionSignature(definition);
+  let data = "0x";
+  if (args && args.length > 0) {
+    if (!("inputs" in description && description.inputs))
+      throw new AbiErrorInputsNotFoundError(errorName, { docsPath: docsPath3 });
+    data = encodeAbi({ params: description.inputs, values: args });
+  }
+  return concatHex([signature, data]);
+}
+
+// src/utils/abi/encodeEventTopics.ts
+function encodeEventTopics({ abi, eventName, args }) {
+  const abiItem = getAbiItem({ abi, name: eventName });
+  if (!abiItem)
+    throw new AbiEventNotFoundError(eventName, {
+      docsPath: "/docs/contract/encodeEventTopics"
+    });
+  const definition = formatAbiItemWithParams(abiItem);
+  const signature = getEventSignature(definition);
+  let topics = [];
+  if (args && "inputs" in abiItem) {
+    const args_ = Array.isArray(args) ? args : _nullishCoalesce(_optionalChain([abiItem, 'access', _25 => _25.inputs, 'optionalAccess', _26 => _26.map, 'call', _27 => _27((x) => args[x.name])]), () => ( []));
+    topics = _nullishCoalesce(_optionalChain([abiItem, 'access', _28 => _28.inputs, 'optionalAccess', _29 => _29.filter, 'call', _30 => _30((param) => "indexed" in param && param.indexed), 'access', _31 => _31.map, 'call', _32 => _32(
+      (param, i) => Array.isArray(args_[i]) ? args_[i].map(
+        (_, j) => encodeArg({ param, value: args_[i][j] })
+      ) : args_[i] ? encodeArg({ param, value: args_[i] }) : null
+    )]), () => ( []));
+  }
+  return [signature, ...topics];
+}
+function encodeArg({
+  param,
+  value
+}) {
+  if (param.type === "string" || param.type === "bytes")
+    return keccak256(encodeBytes(value));
+  if (param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
+    throw new FilterTypeNotSupportedError(param.type);
+  return encodeAbi({ params: [param], values: [value] });
+}
+
+// src/utils/abi/encodeFunctionData.ts
+function encodeFunctionData({ abi, args, functionName }) {
+  const description = getAbiItem({ abi, name: functionName });
+  if (!description)
+    throw new AbiFunctionNotFoundError(functionName, {
+      docsPath: "/docs/contract/encodeFunctionData"
+    });
+  const definition = formatAbiItemWithParams(description);
+  const signature = getFunctionSignature(definition);
+  const data = "inputs" in description && description.inputs ? encodeAbi({
+    params: description.inputs,
+    values: _nullishCoalesce(args, () => ( []))
+  }) : void 0;
+  return concatHex([signature, _nullishCoalesce(data, () => ( "0x"))]);
+}
+
+// src/utils/abi/encodeFunctionResult.ts
+var docsPath4 = "/docs/contract/encodeFunctionResult";
+function encodeFunctionResult({
+  abi,
+  functionName,
+  result
+}) {
+  const description = abi.find((x) => "name" in x && x.name === functionName);
+  if (!description)
+    throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath4 });
+  if (!("outputs" in description))
+    throw new AbiFunctionOutputsNotFoundError(functionName, { docsPath: docsPath4 });
+  let values = Array.isArray(result) ? result : [result];
+  if (description.outputs.length === 0 && !values[0])
+    values = [];
+  return encodeAbi({ params: description.outputs, values });
+}
+
+// src/utils/abi/formatAbiItemWithArgs.ts
+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(", ")})`;
+}
+
+// src/utils/buildRequest.ts
+function buildRequest(request) {
+  return async (args) => {
+    try {
+      return await request(args);
+    } catch (err_) {
+      let err = err_;
+      if (err.code === -32700)
+        throw new ParseRpcError(err);
+      if (err.code === -32600)
+        throw new InvalidRequestRpcError(err);
+      if (err.code === -32601)
+        throw new MethodNotFoundRpcError(err);
+      if (err.code === -32602)
+        throw new InvalidParamsRpcError(err);
+      if (err.code === -32603)
+        throw new InternalRpcError(err);
+      if (err.code === -32e3)
+        throw new InvalidInputRpcError(err);
+      if (err.code === -32001)
+        throw new ResourceNotFoundRpcError(err);
+      if (err.code === -32002)
+        throw new ResourceUnavailableRpcError(err);
+      if (err.code === -32003)
+        throw new TransactionRejectedRpcError(err);
+      if (err.code === -32004)
+        throw new MethodNotSupportedRpcError(err);
+      if (err.code === -32005)
+        throw new LimitExceededRpcError(err);
+      if (err.code === -32006)
+        throw new JsonRpcVersionUnsupportedError(err);
+      if (err_ instanceof BaseError)
+        throw err_;
+      throw new UnknownRpcError(err);
+    }
+  };
+}
+
+// src/constants.ts
+var etherUnits = {
+  gwei: 9,
+  wei: 18
+};
+var gweiUnits = {
+  ether: -9,
+  wei: 9
+};
+var weiUnits = {
+  ether: -18,
+  gwei: -9
+};
+var transactionType = {
+  "0x0": "legacy",
+  "0x1": "eip2930",
+  "0x2": "eip1559"
+};
+
+// src/utils/formatters/transaction.ts
+function formatTransaction(transaction) {
+  const transaction_ = {
+    ...transaction,
+    blockNumber: transaction.blockNumber ? BigInt(transaction.blockNumber) : null,
+    gas: transaction.gas ? BigInt(transaction.gas) : void 0,
+    gasPrice: transaction.gasPrice ? BigInt(transaction.gasPrice) : void 0,
+    maxFeePerGas: transaction.maxFeePerGas ? BigInt(transaction.maxFeePerGas) : void 0,
+    maxPriorityFeePerGas: transaction.maxPriorityFeePerGas ? BigInt(transaction.maxPriorityFeePerGas) : void 0,
+    nonce: transaction.nonce ? hexToNumber(transaction.nonce) : void 0,
+    transactionIndex: transaction.transactionIndex ? Number(transaction.transactionIndex) : null,
+    type: transaction.type ? transactionType[transaction.type] : void 0,
+    value: transaction.value ? BigInt(transaction.value) : void 0,
+    v: transaction.v ? BigInt(transaction.v) : void 0
+  };
+  if (transaction_.type === "legacy") {
+    delete transaction_["accessList"];
+    delete transaction_["maxFeePerGas"];
+    delete transaction_["maxPriorityFeePerGas"];
+  }
+  if (transaction_.type === "eip2930") {
+    delete transaction_["maxFeePerGas"];
+    delete transaction_["maxPriorityFeePerGas"];
+  }
+  return transaction_;
+}
+
+// src/utils/formatters/block.ts
+function formatBlock(block) {
+  const transactions = _optionalChain([block, 'access', _33 => _33.transactions, 'optionalAccess', _34 => _34.map, 'call', _35 => _35((transaction) => {
+    if (typeof transaction === "string")
+      return transaction;
+    return formatTransaction(transaction);
+  })]);
+  return {
+    ...block,
+    baseFeePerGas: block.baseFeePerGas ? BigInt(block.baseFeePerGas) : null,
+    difficulty: block.difficulty ? BigInt(block.difficulty) : void 0,
+    gasLimit: block.gasLimit ? BigInt(block.gasLimit) : void 0,
+    gasUsed: block.gasUsed ? BigInt(block.gasUsed) : void 0,
+    number: block.number ? BigInt(block.number) : null,
+    size: block.size ? BigInt(block.size) : void 0,
+    timestamp: block.timestamp ? BigInt(block.timestamp) : void 0,
+    transactions,
+    totalDifficulty: block.totalDifficulty ? BigInt(block.totalDifficulty) : null
+  };
+}
+
+// src/utils/formatters/feeHistory.ts
+function formatFeeHistory(feeHistory) {
+  return {
+    baseFeePerGas: feeHistory.baseFeePerGas.map((value) => BigInt(value)),
+    gasUsedRatio: feeHistory.gasUsedRatio,
+    oldestBlock: BigInt(feeHistory.oldestBlock),
+    reward: _optionalChain([feeHistory, 'access', _36 => _36.reward, 'optionalAccess', _37 => _37.map, 'call', _38 => _38(
+      (reward) => reward.map((value) => BigInt(value))
+    )])
+  };
+}
+
+// src/utils/formatters/format.ts
+function format3(data, { formatter }) {
+  return formatter(data);
+}
+
+// src/utils/formatters/log.ts
+function formatLog(log) {
+  return {
+    ...log,
+    blockNumber: log.blockNumber ? BigInt(log.blockNumber) : null,
+    logIndex: log.logIndex ? BigInt(log.logIndex) : null,
+    transactionIndex: log.transactionIndex ? BigInt(log.transactionIndex) : null
+  };
+}
+
+// src/utils/formatters/transactionReceipt.ts
+var statuses = {
+  "0x0": "reverted",
+  "0x1": "success"
+};
+function formatTransactionReceipt(transactionReceipt) {
+  return {
+    ...transactionReceipt,
+    blockNumber: transactionReceipt.blockNumber ? BigInt(transactionReceipt.blockNumber) : null,
+    cumulativeGasUsed: transactionReceipt.cumulativeGasUsed ? BigInt(transactionReceipt.cumulativeGasUsed) : null,
+    effectiveGasPrice: transactionReceipt.effectiveGasPrice ? BigInt(transactionReceipt.effectiveGasPrice) : null,
+    gasUsed: transactionReceipt.gasUsed ? BigInt(transactionReceipt.gasUsed) : null,
+    logs: transactionReceipt.logs ? transactionReceipt.logs.map(formatLog) : null,
+    transactionIndex: transactionReceipt.transactionIndex ? hexToNumber(transactionReceipt.transactionIndex) : null,
+    status: transactionReceipt.status ? statuses[transactionReceipt.status] : null,
+    type: transactionReceipt.type ? transactionType[transactionReceipt.type] : null
+  };
+}
+
+// src/utils/formatters/transactionRequest.ts
+function formatTransactionRequest(transactionRequest) {
+  return {
+    ...transactionRequest,
+    gas: typeof transactionRequest.gas !== "undefined" ? numberToHex(transactionRequest.gas) : void 0,
+    gasPrice: typeof transactionRequest.gasPrice !== "undefined" ? numberToHex(transactionRequest.gasPrice) : void 0,
+    maxFeePerGas: typeof transactionRequest.maxFeePerGas !== "undefined" ? numberToHex(transactionRequest.maxFeePerGas) : void 0,
+    maxPriorityFeePerGas: typeof transactionRequest.maxPriorityFeePerGas !== "undefined" ? numberToHex(transactionRequest.maxPriorityFeePerGas) : void 0,
+    nonce: typeof transactionRequest.nonce !== "undefined" ? numberToHex(transactionRequest.nonce) : void 0,
+    value: typeof transactionRequest.value !== "undefined" ? numberToHex(transactionRequest.value) : void 0
+  };
+}
+
+// src/utils/promise/withCache.ts
+var promiseCache = /* @__PURE__ */ new Map();
+var responseCache = /* @__PURE__ */ new Map();
+function getCache(cacheKey) {
+  const buildCache = (cacheKey2, cache) => ({
+    clear: () => cache.delete(cacheKey2),
+    get: () => cache.get(cacheKey2),
+    set: (data) => cache.set(cacheKey2, data)
+  });
+  const promise = buildCache(cacheKey, promiseCache);
+  const response = buildCache(
+    cacheKey,
+    responseCache
+  );
+  return {
+    clear: () => {
+      promise.clear();
+      response.clear();
+    },
+    promise,
+    response
+  };
+}
+async function withCache(fn, { cacheKey, maxAge = Infinity }) {
+  const cache = getCache(cacheKey);
+  const response = cache.response.get();
+  if (response && maxAge > 0) {
+    const age = new Date().getTime() - response.created.getTime();
+    if (age < maxAge)
+      return response.data;
+  }
+  let promise = cache.promise.get();
+  if (!promise) {
+    promise = fn();
+    cache.promise.set(promise);
+  }
+  const data = await promise;
+  cache.promise.clear();
+  cache.response.set({ created: new Date(), data });
+  return data;
+}
+
+// src/utils/wait.ts
+async function wait(time) {
+  return new Promise((res) => setTimeout(res, time));
+}
+
+// src/utils/promise/withRetry.ts
+function withRetry(fn, {
+  delay: delay_ = 100,
+  retryCount = 2,
+  shouldRetryOnResponse = () => false,
+  shouldRetryOnError = () => false
+} = {}) {
+  return new Promise((resolve, reject) => {
+    const attemptRetry = async ({ count = 0 } = {}) => {
+      const retry = async ({ data } = {}) => {
+        const delay = typeof delay_ === "function" ? delay_({ count, data }) : delay_;
+        if (delay)
+          await wait(delay);
+        attemptRetry({ count: count + 1 });
+      };
+      try {
+        const data = await fn();
+        if (count < retryCount && await shouldRetryOnResponse({ count, data }))
+          return retry({ data });
+        resolve(data);
+      } catch (err) {
+        if (count < retryCount && await shouldRetryOnError({ count, error: err }))
+          return retry();
+        reject(err);
+      }
+    };
+    attemptRetry();
+  });
+}
+
+// src/utils/promise/withTimeout.ts
+function withTimeout(fn, {
+  errorInstance,
+  timeout,
+  signal
+}) {
+  return new Promise((resolve, reject) => {
+    ;
+    (async () => {
+      let timeoutId;
+      try {
+        const controller = new AbortController();
+        if (timeout > 0) {
+          timeoutId = setTimeout(() => {
+            if (signal) {
+              controller.abort();
+            } else {
+              reject(errorInstance);
+            }
+          }, timeout);
+        }
+        resolve(await fn({ signal: _optionalChain([controller, 'optionalAccess', _39 => _39.signal]) }));
+      } catch (err) {
+        if (err.name === "AbortError")
+          reject(errorInstance);
+        reject(err);
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    })();
+  });
+}
+
+// src/utils/rpc.ts
+var id = 0;
+async function http(url, {
+  body,
+  retryDelay = 100,
+  retryCount = 2,
+  timeout = 0
+}) {
+  const response = await withRetry(
+    () => withTimeout(
+      async ({ signal }) => {
+        const response2 = await fetch(url, {
+          headers: {
+            "Content-Type": "application/json"
+          },
+          method: "POST",
+          body: stringify({ jsonrpc: "2.0", id: id++, ...body }),
+          signal: timeout > 0 ? signal : void 0
+        });
+        return response2;
+      },
+      {
+        errorInstance: new TimeoutError({ body, url }),
+        timeout,
+        signal: true
+      }
+    ),
+    {
+      delay: ({ count, data: data2 }) => {
+        const retryAfter = _optionalChain([data2, 'optionalAccess', _40 => _40.headers, 'access', _41 => _41.get, 'call', _42 => _42("Retry-After")]);
+        if (_optionalChain([retryAfter, 'optionalAccess', _43 => _43.match, 'call', _44 => _44(/\d/)]))
+          return parseInt(retryAfter) * 1e3;
+        return ~~((Math.random() + 0.5) * (1 << count)) * retryDelay;
+      },
+      retryCount,
+      shouldRetryOnResponse: async ({ data: data2 }) => {
+        if (data2.status >= 500)
+          return true;
+        if ([408, 413, 429].includes(data2.status))
+          return true;
+        return false;
+      }
+    }
+  );
+  let data;
+  if (_optionalChain([response, 'access', _45 => _45.headers, 'access', _46 => _46.get, 'call', _47 => _47("Content-Type"), 'optionalAccess', _48 => _48.startsWith, 'call', _49 => _49("application/json")])) {
+    data = await response.json();
+  } else {
+    data = await response.text();
+  }
+  if (!response.ok) {
+    throw new HttpRequestError({
+      body,
+      details: stringify(data.error) || response.statusText,
+      status: response.status,
+      url
+    });
+  }
+  if (data.error) {
+    throw new RpcError({ body, error: data.error, url });
+  }
+  return data;
+}
+var sockets = /* @__PURE__ */ new Map();
+async function getSocket(url_) {
+  const url = new URL(url_);
+  const urlKey = url.toString();
+  let socket = sockets.get(urlKey);
+  if (socket)
+    return socket;
+  const webSocket2 = new WebSocket(url);
+  const requests = /* @__PURE__ */ new Map();
+  const subscriptions = /* @__PURE__ */ new Map();
+  const onMessage = ({ data }) => {
+    const message = JSON.parse(data);
+    const isSubscription = message.method === "eth_subscription";
+    const id2 = isSubscription ? message.params.subscription : message.id;
+    const cache = isSubscription ? subscriptions : requests;
+    const callback = cache.get(id2);
+    if (callback)
+      callback({ data });
+    if (!isSubscription)
+      cache.delete(id2);
+  };
+  const onClose = () => {
+    sockets.delete(urlKey);
+    webSocket2.removeEventListener("close", onClose);
+    webSocket2.removeEventListener("message", onMessage);
+  };
+  webSocket2.addEventListener("close", onClose);
+  webSocket2.addEventListener("message", onMessage);
+  if (webSocket2.readyState === WebSocket.CONNECTING) {
+    await new Promise((resolve, reject) => {
+      if (!webSocket2)
+        return;
+      webSocket2.onopen = resolve;
+      webSocket2.onerror = reject;
+    });
+  }
+  socket = Object.assign(webSocket2, {
+    requests,
+    subscriptions
+  });
+  sockets.set(urlKey, socket);
+  return socket;
+}
+function webSocket(socket, {
+  body,
+  onData,
+  onError
+}) {
+  if (socket.readyState === socket.CLOSED || socket.readyState === socket.CLOSING)
+    throw new WebSocketRequestError({
+      body,
+      url: socket.url,
+      details: "Socket is closed."
+    });
+  const id_ = id++;
+  const callback = ({ data }) => {
+    const message = JSON.parse(data);
+    if (typeof message.id === "number" && id_ !== message.id)
+      return;
+    if (message.error) {
+      _optionalChain([onError, 'optionalCall', _50 => _50(new RpcError({ body, error: message.error, url: socket.url }))]);
+    } else {
+      _optionalChain([onData, 'optionalCall', _51 => _51(message)]);
+    }
+    if (body.method === "eth_subscribe" && typeof message.result === "string") {
+      socket.subscriptions.set(message.result, callback);
+    }
+    if (body.method === "eth_unsubscribe") {
+      socket.subscriptions.delete(_optionalChain([body, 'access', _52 => _52.params, 'optionalAccess', _53 => _53[0]]));
+    }
+  };
+  socket.requests.set(id_, callback);
+  socket.send(JSON.stringify({ jsonrpc: "2.0", ...body, id: id_ }));
+  return socket;
+}
+async function webSocketAsync(socket, {
+  body,
+  timeout = 0
+}) {
+  return withTimeout(
+    () => new Promise(
+      (onData, onError) => rpc.webSocket(socket, {
+        body,
+        onData,
+        onError
+      })
+    ),
+    {
+      errorInstance: new TimeoutError({ body, url: socket.url }),
+      timeout
+    }
+  );
+}
+var rpc = {
+  http,
+  webSocket,
+  webSocketAsync
+};
+
+// src/utils/unit/formatUnit.ts
+function formatUnit(value, decimals) {
+  let display = value.toString();
+  const negative = display.startsWith("-");
+  if (negative)
+    display = display.slice(1);
+  let [integer, fraction] = [
+    display.slice(0, display.length - decimals),
+    display.slice(display.length - decimals)
+  ];
+  fraction = fraction.padStart(decimals, "0");
+  fraction = fraction.replace(/(0+)$/, "");
+  return `${negative ? "-" : ""}${integer || "0"}${fraction ? `.${fraction}` : ""}`;
+}
+
+// src/utils/unit/formatEther.ts
+function formatEther(wei, unit = "wei") {
+  return formatUnit(wei, etherUnits[unit]);
+}
+
+// src/utils/unit/formatGwei.ts
+function formatGwei(wei, unit = "wei") {
+  return formatUnit(wei, gweiUnits[unit]);
+}
+
+// src/utils/unit/parseUnit.ts
+function parseUnit(value, decimals) {
+  let [integer, fraction = "0"] = value.split(".");
+  const negative = integer.startsWith("-");
+  if (negative)
+    integer = integer.slice(1);
+  fraction = fraction.replace(/(0+)$/, "");
+  if (decimals === 0) {
+    integer = `${Math.round(Number(`${integer}.${fraction}`))}`;
+    fraction = "";
+  } else if (fraction.length > decimals) {
+    const [before, after] = [
+      fraction.slice(0, decimals),
+      fraction.slice(decimals)
+    ];
+    fraction = `${/^0+$/.test(before) ? before.slice(0, before.length - 1) : ""}${Math.round(Number(`${before}.${after}`))}`;
+  } else {
+    fraction = fraction.padEnd(decimals, "0");
+  }
+  return BigInt(`${negative ? "-" : ""}${integer}${fraction}`);
+}
+
+// src/utils/unit/parseEther.ts
+function parseEther(ether, unit = "wei") {
+  return parseUnit(ether, etherUnits[unit]);
+}
+
+// src/utils/unit/parseGwei.ts
+function parseGwei(ether, unit = "wei") {
+  return parseUnit(ether, gweiUnits[unit]);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.stringify = stringify; exports.BaseError = BaseError; exports.AbiConstructorNotFoundError = AbiConstructorNotFoundError; exports.AbiConstructorParamsNotFoundError = AbiConstructorParamsNotFoundError; exports.AbiDecodingDataSizeInvalidError = AbiDecodingDataSizeInvalidError; exports.AbiEncodingArrayLengthMismatchError = AbiEncodingArrayLengthMismatchError; exports.AbiEncodingLengthMismatchError = AbiEncodingLengthMismatchError; exports.AbiErrorInputsNotFoundError = AbiErrorInputsNotFoundError; exports.AbiErrorNotFoundError = AbiErrorNotFoundError; exports.AbiErrorSignatureNotFoundError = AbiErrorSignatureNotFoundError; exports.AbiEventNotFoundError = AbiEventNotFoundError; exports.AbiFunctionNotFoundError = AbiFunctionNotFoundError; exports.AbiFunctionOutputsNotFoundError = AbiFunctionOutputsNotFoundError; exports.AbiFunctionSignatureNotFoundError = AbiFunctionSignatureNotFoundError; exports.InvalidAbiEncodingTypeError = InvalidAbiEncodingTypeError; exports.InvalidAbiDecodingTypeError = InvalidAbiDecodingTypeError; exports.InvalidArrayError = InvalidArrayError; exports.InvalidDefinitionTypeError = InvalidDefinitionTypeError; exports.InvalidAddressError = InvalidAddressError; exports.BlockNotFoundError = BlockNotFoundError; exports.SizeExceedsPaddingSizeError = SizeExceedsPaddingSizeError; exports.DataLengthTooLongError = DataLengthTooLongError; exports.DataLengthTooShortError = DataLengthTooShortError; exports.InvalidBytesBooleanError = InvalidBytesBooleanError; exports.InvalidHexBooleanError = InvalidHexBooleanError; exports.InvalidHexValueError = InvalidHexValueError; exports.OffsetOutOfBoundsError = OffsetOutOfBoundsError; exports.FilterTypeNotSupportedError = FilterTypeNotSupportedError; exports.RequestError = RequestError; exports.RpcRequestError = RpcRequestError; exports.ParseRpcError = ParseRpcError; exports.InvalidRequestRpcError = InvalidRequestRpcError; exports.MethodNotFoundRpcError = MethodNotFoundRpcError; exports.InvalidParamsRpcError = InvalidParamsRpcError; exports.InternalRpcError = InternalRpcError; exports.InvalidInputRpcError = InvalidInputRpcError; exports.ResourceNotFoundRpcError = ResourceNotFoundRpcError; exports.ResourceUnavailableRpcError = ResourceUnavailableRpcError; exports.TransactionRejectedRpcError = TransactionRejectedRpcError; exports.MethodNotSupportedRpcError = MethodNotSupportedRpcError; exports.LimitExceededRpcError = LimitExceededRpcError; exports.JsonRpcVersionUnsupportedError = JsonRpcVersionUnsupportedError; exports.UnknownRpcError = UnknownRpcError; exports.isBytes = isBytes; exports.isHex = isHex; exports.pad = pad; exports.padHex = padHex; exports.padBytes = padBytes; exports.trim = trim; exports.size = size; exports.slice = slice; exports.sliceBytes = sliceBytes; exports.sliceHex = sliceHex; exports.boolToHex = boolToHex; exports.bytesToHex = bytesToHex; exports.encodeHex = encodeHex; exports.numberToHex = numberToHex; exports.stringToHex = stringToHex; exports.boolToBytes = boolToBytes; exports.encodeBytes = encodeBytes; exports.hexToBytes = hexToBytes; exports.numberToBytes = numberToBytes; exports.stringToBytes = stringToBytes; exports.encodeRlp = encodeRlp; exports.decodeHex = decodeHex; exports.hexToBigInt = hexToBigInt; exports.hexToBool = hexToBool; exports.hexToNumber = hexToNumber; exports.hexToString = hexToString; exports.decodeBytes = decodeBytes; exports.bytesToBigint = bytesToBigint; exports.bytesToBool = bytesToBool; exports.bytesToNumber = bytesToNumber; exports.bytesToString = bytesToString; exports.decodeRlp = decodeRlp; exports.extractFunctionParts = extractFunctionParts; exports.extractFunctionName = extractFunctionName; exports.extractFunctionParams = extractFunctionParams; exports.extractFunctionType = extractFunctionType; exports.getContractError = getContractError; exports.keccak256 = keccak256; exports.getEventSignature = getEventSignature; exports.getFunctionSignature = getFunctionSignature; exports.checksumAddress = checksumAddress; exports.getAddress = getAddress; exports.getContractAddress = getContractAddress; exports.getCreateAddress = getCreateAddress; exports.getCreate2Address = getCreate2Address; exports.isAddress = isAddress; exports.isAddressEqual = isAddressEqual; exports.encodeAbi = encodeAbi; exports.decodeAbi = decodeAbi; exports.formatAbiItemWithParams = formatAbiItemWithParams; exports.decodeErrorResult = decodeErrorResult; exports.decodeFunctionData = decodeFunctionData; exports.decodeFunctionResult = decodeFunctionResult; exports.encodeDeployData = encodeDeployData; exports.getAbiItem = getAbiItem; exports.encodeErrorResult = encodeErrorResult; exports.encodeEventTopics = encodeEventTopics; exports.encodeFunctionData = encodeFunctionData; exports.encodeFunctionResult = encodeFunctionResult; exports.formatAbiItemWithArgs = formatAbiItemWithArgs; exports.buildRequest = buildRequest; exports.etherUnits = etherUnits; exports.gweiUnits = gweiUnits; exports.weiUnits = weiUnits; exports.transactionType = transactionType; exports.formatTransaction = formatTransaction; exports.formatBlock = formatBlock; exports.formatFeeHistory = formatFeeHistory; exports.format = format3; exports.formatLog = formatLog; exports.formatTransactionReceipt = formatTransactionReceipt; exports.formatTransactionRequest = formatTransactionRequest; exports.getCache = getCache; exports.withCache = withCache; exports.wait = wait; exports.getSocket = getSocket; exports.rpc = rpc; exports.formatUnit = formatUnit; exports.formatEther = formatEther; exports.formatGwei = formatGwei; exports.parseUnit = parseUnit; exports.parseEther = parseEther; exports.parseGwei = parseGwei; exports.HttpRequestError = HttpRequestError; exports.WebSocketRequestError = WebSocketRequestError; exports.RpcError = RpcError; exports.TimeoutError = TimeoutError; exports.InvalidGasArgumentsError = InvalidGasArgumentsError; exports.TransactionNotFoundError = TransactionNotFoundError; exports.TransactionReceiptNotFoundError = TransactionReceiptNotFoundError; exports.WaitForTransactionReceiptTimeoutError = WaitForTransactionReceiptTimeoutError; exports.UrlRequiredError = UrlRequiredError;