viem 0.0.1-alpha.2 → 0.0.1-alpha.20

package/dist/{chunk-3EOU525X.js → chunk-5Q6FSUU2.mjs}

@@ -8,10 +8,10 @@ var __publicField = (obj, key, value) => {
 // package.json
 var package_default = {
   name: "viem",
-  description: "TypeScript (& JavaScript) Interface for Ethereum",
-  version: "0.0.1-alpha.2",
+  description: "TypeScript Interface for Ethereum",
+  version: "0.0.1-alpha.20",
   scripts: {
-    anvil: "source .env && anvil --fork-url $ANVIL_FORK_URL --fork-block-number $VITE_ANVIL_BLOCK_NUMBER --block-time $VITE_ANVIL_BLOCK_TIME",
+    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",
@@ -27,10 +27,12 @@ var package_default = {
     "playground:benchmark": "pnpm --filter playground-benchmark dev",
     postinstall: "pnpm dev",
     preinstall: "npx only-allow pnpm",
+    prepublishOnly: "pnpm ts-node scripts/generate-package-json.ts",
     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",
+    "ts-node": "node --loader esbuild-register/loader -r esbuild-register",
     typecheck: "tsc --noEmit"
   },
   files: [
@@ -38,6 +40,7 @@ var package_default = {
     "/chains",
     "/dist",
     "/clients",
+    "/src",
     "/types",
     "/utils",
     "/window"
@@ -45,38 +48,54 @@ var package_default = {
   exports: {
     ".": {
       types: "./dist/index.d.ts",
+      module: "./dist/index.mjs",
       default: "./dist/index.js"
     },
-    "./actions": {
-      types: "./dist/actions/index.d.ts",
-      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"
     },
+    "./public": {
+      types: "./dist/public.d.ts",
+      module: "./dist/public.mjs",
+      default: "./dist/public.js"
+    },
+    "./test": {
+      types: "./dist/test.d.ts",
+      module: "./dist/test.mjs",
+      default: "./dist/test.js"
+    },
     "./utils": {
       types: "./dist/utils/index.d.ts",
+      module: "./dist/utils/index.mjs",
       default: "./dist/utils/index.js"
     },
+    "./wallet": {
+      types: "./dist/wallet.d.ts",
+      module: "./dist/wallet.mjs",
+      default: "./dist/wallet.js"
+    },
     "./window": {
       types: "./dist/window.d.ts",
+      module: "./dist/window.mjs",
       default: "./dist/window.js"
     },
     "./package.json": "./package.json"
   },
-  type: "module",
   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"
+    "@wagmi/chains": "~0.2.6",
+    abitype: "~0.2.5"
   },
   devDependencies: {
     "@actions/core": "^1.10.0",
@@ -129,30 +148,706 @@ var package_default = {
   }
 };
 
-// src/utils/BaseError.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 : args.cause?.message ? args.cause.message : args.details;
-    const docsPath = args.cause instanceof BaseError ? args.cause.docsPath || args.docsPath : args.docsPath;
-    const message = [
-      humanMessage,
-      ...docsPath ? ["", `Docs: https://viem.sh${docsPath}`] : [],
-      "",
-      ...details ? [`Details: ${details}`] : [],
-      `Version: viem@${version}`,
-      ...args.cause && !(args.cause instanceof BaseError) && Object.keys(args.cause).length > 0 ? [`Internal Error: ${JSON.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 = docsPath;
-    this.humanMessage = humanMessage;
+// 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 : args.cause?.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(functionName?.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"
+      }
+    );
   }
 };
 
@@ -233,18 +928,6 @@ function padBytes(bytes, { dir, size: size2 = 32 } = {}) {
   }
   return paddedBytes;
 }
-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/utils/data/trim.ts
 function trim(hexOrBytes, { dir = "left" } = {}) {
@@ -457,14 +1140,6 @@ function hexToString(hex) {
   const bytes = hexToBytes(hex);
   return new TextDecoder().decode(bytes);
 }
-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");
-  }
-};
 
 // src/utils/encoding/decodeBytes.ts
 function decodeBytes(bytes, to) {
@@ -494,14 +1169,6 @@ function bytesToNumber(bytes) {
 function bytesToString(bytes) {
   return new TextDecoder().decode(bytes);
 }
-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");
-  }
-};
 
 // src/utils/encoding/decodeRlp.ts
 function decodeRlp(value, to) {
@@ -583,40 +1250,8 @@ function rlpToBytes(bytes, offset = 0) {
   }
   return [result, consumed];
 }
-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 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/utils/solidity.ts
+// src/utils/contract/extractFunctionParts.ts
 var paramsRegex = /((function|event)\s)?(.*)(\((.*)\))/;
 function extractFunctionParts(def) {
   const parts = def.match(paramsRegex);
@@ -641,6 +1276,49 @@ 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 ? formatAbiItem(abiItem, { includeName: true }) : void 0;
+  if (err instanceof AbiDecodingZeroDataError) {
+    return new ContractMethodZeroDataError({
+      abi,
+      args,
+      cause: err,
+      contractAddress: address,
+      functionName,
+      functionWithParams
+    });
+  }
+  if (code === 3 || message?.includes("execution reverted")) {
+    const message_ = message?.replace("execution reverted: ", "");
+    return new ContractMethodExecutionError(message_, {
+      abi,
+      args,
+      cause: err,
+      contractAddress: address,
+      formattedArgs,
+      functionName,
+      functionWithParams,
+      sender
+    });
+  }
+  return err;
+}
+
 // src/utils/hash/keccak256.ts
 import { keccak_256 } from "@noble/hashes/sha3";
 function keccak256(value, to_) {
@@ -674,10 +1352,10 @@ function checksumAddress(address_) {
   const hash2 = keccak256(stringToBytes(hexAddress), "bytes");
   let address = hexAddress.split("");
   for (let i = 0; i < 40; i += 2) {
-    if (hash2?.[i >> 1] >> 4 >= 8) {
+    if (hash2?.[i >> 1] >> 4 >= 8 && address[i]) {
       address[i] = address[i].toUpperCase();
     }
-    if ((hash2[i >> 1] & 15) >= 8) {
+    if ((hash2[i >> 1] & 15) >= 8 && address[i + 1]) {
       address[i + 1] = address[i + 1].toUpperCase();
     }
   }
@@ -688,12 +1366,6 @@ function getAddress(address) {
     throw new InvalidAddressError({ address });
   return checksumAddress(address);
 }
-var InvalidAddressError = class extends BaseError {
-  constructor({ address }) {
-    super(`Address "${address}" is invalid.`);
-    __publicField(this, "name", "InvalidAddressError");
-  }
-};
 
 // src/utils/address/getContractAddress.ts
 function getContractAddress(opts) {
@@ -756,7 +1428,7 @@ function encodeAbi({
   const preparedParams = prepareParams({ params, values });
   const data = encodeParams(preparedParams);
   if (data.length === 0)
-    return void 0;
+    return "0x";
   return data;
 }
 function prepareParams({
@@ -799,7 +1471,9 @@ function prepareParam({
   if (param.type === "string") {
     return encodeString(value);
   }
-  throw new InvalidAbiEncodingTypeError(param.type);
+  throw new InvalidAbiEncodingTypeError(param.type, {
+    docsPath: "/docs/contract/encodeAbi"
+  });
 }
 function encodeParams(preparedParams) {
   let staticSize = 0;
@@ -825,6 +1499,9 @@ function encodeParams(preparedParams) {
   }
   return concat([...staticParams, ...dynamicParams]);
 }
+function encodeAddress(value) {
+  return { dynamic: false, encoded: padHex(value.toLowerCase()) };
+}
 function encodeArray(value, {
   length,
   param
@@ -863,27 +1540,6 @@ function encodeArray(value, {
     encoded: concat(preparedParams.map(({ encoded }) => encoded))
   };
 }
-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 encodeAddress(value) {
-  return { dynamic: false, encoded: padHex(value.toLowerCase()) };
-}
 function encodeBytes2(value, { param }) {
   const [_, size_] = param.type.split("bytes");
   if (!size_)
@@ -897,91 +1553,65 @@ function encodeBytes2(value, { param }) {
   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 getArrayComponents(type) {
-  const matches = type.match(/^(.*)\[(\d+)?\]$/);
-  return matches ? [matches[2] ? Number(matches[2]) : null, matches[1]] : void 0;
-}
-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 InvalidAbiEncodingTypeError = class extends BaseError {
-  constructor(type) {
-    super(
-      [
-        `Type "${type}" is not a valid encoding type.`,
-        "Please provide a valid ABI type."
-      ].join("\n"),
-      { docsPath: "/docs/contract/encodeAbi#params" }
-    );
-    __publicField(this, "name", "InvalidAbiEncodingType");
-  }
-};
-var InvalidArrayError = class extends BaseError {
-  constructor(value) {
-    super([`Value "${value}" is not a valid array.`].join("\n"));
-    __publicField(this, "name", "InvalidArrayError");
+  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));
-  return decodeParams({
+  const values = decodeParams({
     data,
     params
   });
+  if (values.length === 0)
+    return void 0;
+  return values;
 }
 function decodeParams({
   data,
@@ -1030,7 +1660,12 @@ function decodeParam({
   if (param.type === "bool") {
     return decodeBool(value);
   }
-  throw new InvalidAbiDecodingTypeError(param.type);
+  throw new InvalidAbiDecodingTypeError(param.type, {
+    docsPath: "/docs/contract/decodeAbi"
+  });
+}
+function decodeAddress(value) {
+  return { consumed: 32, value: checksumAddress(slice(value, -20)) };
 }
 function decodeArray(data, {
   param,
@@ -1083,9 +1718,6 @@ function decodeArray(data, {
   }
   return { value, consumed };
 }
-function decodeAddress(value) {
-  return { consumed: 32, value: checksumAddress(trim(value)) };
-}
 function decodeBool(value) {
   return { consumed: 32, value: hexToBool(value) };
 }
@@ -1161,277 +1793,283 @@ function hasDynamicChild(param) {
     return true;
   return false;
 }
-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 InvalidAbiDecodingTypeError = class extends BaseError {
-  constructor(type) {
-    super(
-      [
-        `Type "${type}" is not a valid decoding type.`,
-        "Please provide a valid ABI type."
-      ].join("\n"),
-      { docsPath: "/docs/contract/decodeAbi#params" }
-    );
-    __publicField(this, "name", "InvalidAbiDecodingType");
-  }
-};
 
-// src/utils/abi/getDefinition.ts
-function getDefinition(description) {
-  if (description.type !== "function" && description.type !== "event" && description.type !== "error")
-    throw new InvalidDefinitionTypeError(description.type);
-  return `${description.name}(${getParams(description.inputs)})`;
+// src/utils/abi/formatAbiItem.ts
+function formatAbiItem(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) {
+function getParams(params, { includeName }) {
   if (!params)
     return "";
-  return params.map(getParam).join(",");
+  return params.map((param) => getParam(param, { includeName })).join(includeName ? ", " : ",");
 }
-function getParam(param) {
+function getParam(param, { includeName }) {
   if (param.type.startsWith("tuple")) {
     return `(${getParams(
-      param.components
+      param.components,
+      { includeName }
     )})${param.type.slice("tuple".length)}`;
   }
-  return param.type;
+  return param.type + (includeName && param.name ? ` ${param.name}` : "");
 }
-var InvalidDefinitionTypeError = class extends BaseError {
-  constructor(type) {
-    super(
-      [
-        `"${type}" is not a valid definition type.`,
-        'Valid types: "function", "event", "error"'
-      ].join("\n"),
-      {
-        docsPath: "/docs/contract/getDefinition"
-      }
-    );
-  }
-};
 
-// src/utils/abi/encodeFunctionParams.ts
-function encodeFunctionParams({
-  abi,
-  args,
-  functionName
-}) {
-  const description = abi.find((x) => "name" in x && x.name === functionName);
+// src/utils/abi/decodeErrorResult.ts
+function decodeErrorResult({ abi, data }) {
+  const signature = slice(data, 0, 4);
+  const description = abi.find(
+    (x) => signature === getFunctionSignature(formatAbiItem(x))
+  );
   if (!description)
-    throw new AbiFunctionNotFoundError(functionName);
-  const definition = getDefinition(description);
-  const signature = getFunctionSignature(definition);
-  const data = "inputs" in description && description.inputs ? encodeAbi({
-    params: description.inputs,
-    values: args ?? []
-  }) : void 0;
-  return concatHex([signature, data ?? "0x"]);
+    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
+  };
 }
-var AbiFunctionNotFoundError = class extends BaseError {
-  constructor(functionName) {
-    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: "/docs/contract/encodeFunctionParams"
-      }
-    );
-  }
-};
 
-// 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/utils/abi/decodeFunctionData.ts
+function decodeFunctionData({ abi, data }) {
+  const signature = slice(data, 0, 4);
+  const description = abi.find(
+    (x) => signature === getFunctionSignature(formatAbiItem(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
   };
 }
-var RequestError = class extends BaseError {
-  constructor(err, { docsPath, humanMessage }) {
-    super(humanMessage, {
-      cause: err,
-      docsPath
-    });
-    this.name = err.name;
-  }
-};
-var RpcRequestError = class extends RequestError {
-  constructor(err, { docsPath, humanMessage }) {
-    super(err, { docsPath, 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);
+
+// 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 = formatAbiItem(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 });
   }
-};
-var JsonRpcVersionUnsupportedError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, {
-      humanMessage: "Version of JSON-RPC protocol is not supported."
+  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"
     });
-    __publicField(this, "name", "JsonRpcVersionUnsupportedError");
-    __publicField(this, "code", -32006);
-  }
-};
-var UnknownRpcError = class extends RequestError {
-  constructor(err) {
-    super(err, {
-      humanMessage: "An unknown RPC error occurred."
+  const definition = formatAbiItem(abiItem);
+  const signature = getEventSignature(definition);
+  let topics = [];
+  if (args && "inputs" in abiItem) {
+    const args_ = Array.isArray(args) ? args : abiItem.inputs?.map((x) => args[x.name]) ?? [];
+    topics = abiItem.inputs?.filter((param) => "indexed" in param && param.indexed).map(
+      (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"
     });
-    __publicField(this, "name", "UnknownRpcError");
-  }
-};
+  const definition = formatAbiItem(description);
+  const signature = getFunctionSignature(definition);
+  const data = "inputs" in description && description.inputs ? encodeAbi({
+    params: description.inputs,
+    values: args ?? []
+  }) : void 0;
+  return concatHex([signature, data ?? "0x"]);
+}
 
-// src/constants.ts
-var etherUnits = {
-  gwei: 9,
-  wei: 18
-};
-var gweiUnits = {
-  ether: -9,
-  wei: 9
-};
-var weiUnits = {
-  ether: -18,
-  gwei: -9
-};
+// 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/utils/chain.ts
+function defineChain(chain) {
+  return chain;
+}
+
+// src/utils/formatters/format.ts
+function format3(data, { formatter }) {
+  return formatter(data);
+}
+function defineFormatter({
+  format: format4
+}) {
+  return ({
+    exclude,
+    format: formatOverride
+  }) => (data) => {
+    const formatted = format4(data);
+    if (exclude) {
+      for (const key of exclude) {
+        delete formatted[key];
+      }
+    }
+    return {
+      ...formatted,
+      ...formatOverride?.(data)
+    };
+  };
+}
+
+// src/utils/formatters/transaction.ts
 var transactionType = {
   "0x0": "legacy",
   "0x1": "eip2930",
   "0x2": "eip1559"
 };
-
-// src/utils/formatters/transaction.ts
 function formatTransaction(transaction) {
   const transaction_ = {
     ...transaction,
@@ -1457,6 +2095,7 @@ function formatTransaction(transaction) {
   }
   return transaction_;
 }
+var defineTransaction = defineFormatter({ format: formatTransaction });
 
 // src/utils/formatters/block.ts
 function formatBlock(block) {
@@ -1478,6 +2117,21 @@ function formatBlock(block) {
     totalDifficulty: block.totalDifficulty ? BigInt(block.totalDifficulty) : null
   };
 }
+var defineBlock = defineFormatter({ format: formatBlock });
+
+// src/utils/formatters/extract.ts
+function extract(value, { formatter }) {
+  if (!formatter)
+    return {};
+  const keys = Object.keys(formatter({}));
+  return keys.reduce((data, key) => {
+    if (value?.hasOwnProperty(key)) {
+      ;
+      data[key] = value[key];
+    }
+    return data;
+  }, {});
+}
 
 // src/utils/formatters/feeHistory.ts
 function formatFeeHistory(feeHistory) {
@@ -1491,11 +2145,6 @@ function formatFeeHistory(feeHistory) {
   };
 }
 
-// src/utils/formatters/format.ts
-function format3(data, { formatter }) {
-  return formatter(data);
-}
-
 // src/utils/formatters/log.ts
 function formatLog(log) {
   return {
@@ -1524,6 +2173,9 @@ function formatTransactionReceipt(transactionReceipt) {
     type: transactionReceipt.type ? transactionType[transactionReceipt.type] : null
   };
 }
+var defineTransactionReceipt = defineFormatter({
+  format: formatTransactionReceipt
+});
 
 // src/utils/formatters/transactionRequest.ts
 function formatTransactionRequest(transactionRequest) {
@@ -1537,6 +2189,9 @@ function formatTransactionRequest(transactionRequest) {
     value: typeof transactionRequest.value !== "undefined" ? numberToHex(transactionRequest.value) : void 0
   };
 }
+var defineTransactionRequest = defineFormatter({
+  format: formatTransactionRequest
+});
 
 // src/utils/promise/withCache.ts
 var promiseCache = /* @__PURE__ */ new Map();
@@ -1664,7 +2319,7 @@ async function http(url, {
             "Content-Type": "application/json"
           },
           method: "POST",
-          body: JSON.stringify({ jsonrpc: "2.0", id: id++, ...body }),
+          body: stringify({ jsonrpc: "2.0", id: id++, ...body }),
           signal: timeout > 0 ? signal : void 0
         });
         return response2;
@@ -1701,7 +2356,7 @@ async function http(url, {
   if (!response.ok) {
     throw new HttpRequestError({
       body,
-      details: JSON.stringify(data.error) || response.statusText,
+      details: stringify(data.error) || response.statusText,
       status: response.status,
       url
     });
@@ -1809,91 +2464,19 @@ var rpc = {
   webSocket,
   webSocketAsync
 };
-var HttpRequestError = class extends BaseError {
-  constructor({
-    body,
-    details,
-    status,
-    url
-  }) {
-    super(
-      [
-        "HTTP request failed.",
-        "",
-        `Status: ${status}`,
-        `URL: ${url}`,
-        `Request body: ${JSON.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: ${JSON.stringify(body)}`
-      ].join("\n"),
-      {
-        details
-      }
-    );
-    __publicField(this, "name", "WebSocketRequestError");
-  }
+
+// src/utils/unit/constants.ts
+var etherUnits = {
+  gwei: 9,
+  wei: 18
 };
-var RpcError = class extends BaseError {
-  constructor({
-    body,
-    error,
-    url
-  }) {
-    super(
-      [
-        "RPC Request failed.",
-        "",
-        `URL: ${url}`,
-        `Request body: ${JSON.stringify(body)}`
-      ].join("\n"),
-      {
-        cause: error,
-        details: error.message
-      }
-    );
-    __publicField(this, "code");
-    __publicField(this, "name", "RpcError");
-    this.code = error.code;
-  }
+var gweiUnits = {
+  ether: -9,
+  wei: 9
 };
-var TimeoutError = class extends BaseError {
-  constructor({
-    body,
-    url
-  }) {
-    super(
-      [
-        "The request took too long to respond.",
-        "",
-        `URL: ${url}`,
-        `Request body: ${JSON.stringify(body)}`
-      ].join("\n"),
-      {
-        details: "The request timed out."
-      }
-    );
-    __publicField(this, "name", "TimeoutError");
-  }
+var weiUnits = {
+  ether: -18,
+  gwei: -9
 };
 
 // src/utils/unit/formatUnit.ts
@@ -1954,8 +2537,49 @@ function parseGwei(ether, unit = "wei") {
 }
 
 export {
-  __publicField,
+  stringify,
   BaseError,
+  AbiConstructorNotFoundError,
+  AbiConstructorParamsNotFoundError,
+  AbiDecodingDataSizeInvalidError,
+  AbiEncodingArrayLengthMismatchError,
+  AbiEncodingLengthMismatchError,
+  AbiErrorInputsNotFoundError,
+  AbiErrorNotFoundError,
+  AbiErrorSignatureNotFoundError,
+  AbiEventNotFoundError,
+  AbiFunctionNotFoundError,
+  AbiFunctionOutputsNotFoundError,
+  AbiFunctionSignatureNotFoundError,
+  InvalidAbiEncodingTypeError,
+  InvalidAbiDecodingTypeError,
+  InvalidArrayError,
+  InvalidDefinitionTypeError,
+  InvalidAddressError,
+  BlockNotFoundError,
+  SizeExceedsPaddingSizeError,
+  DataLengthTooLongError,
+  DataLengthTooShortError,
+  InvalidBytesBooleanError,
+  InvalidHexBooleanError,
+  InvalidHexValueError,
+  OffsetOutOfBoundsError,
+  FilterTypeNotSupportedError,
+  RequestError,
+  RpcRequestError,
+  ParseRpcError,
+  InvalidRequestRpcError,
+  MethodNotFoundRpcError,
+  InvalidParamsRpcError,
+  InternalRpcError,
+  InvalidInputRpcError,
+  ResourceNotFoundRpcError,
+  ResourceUnavailableRpcError,
+  TransactionRejectedRpcError,
+  MethodNotSupportedRpcError,
+  LimitExceededRpcError,
+  JsonRpcVersionUnsupportedError,
+  UnknownRpcError,
   isBytes,
   isHex,
   pad,
@@ -1988,9 +2612,11 @@ export {
   bytesToNumber,
   bytesToString,
   decodeRlp,
+  extractFunctionParts,
   extractFunctionName,
   extractFunctionParams,
   extractFunctionType,
+  getContractError,
   keccak256,
   getEventSignature,
   getFunctionSignature,
@@ -2003,44 +2629,55 @@ export {
   isAddressEqual,
   encodeAbi,
   decodeAbi,
-  encodeFunctionParams,
+  formatAbiItem,
+  decodeErrorResult,
+  decodeFunctionData,
+  decodeFunctionResult,
+  encodeDeployData,
+  getAbiItem,
+  encodeErrorResult,
+  encodeEventTopics,
+  encodeFunctionData,
+  encodeFunctionResult,
+  formatAbiItemWithArgs,
   buildRequest,
-  RpcRequestError,
-  ParseRpcError,
-  InvalidRequestRpcError,
-  MethodNotFoundRpcError,
-  InvalidParamsRpcError,
-  InternalRpcError,
-  InvalidInputRpcError,
-  ResourceNotFoundRpcError,
-  ResourceUnavailableRpcError,
-  TransactionRejectedRpcError,
-  MethodNotSupportedRpcError,
-  LimitExceededRpcError,
-  JsonRpcVersionUnsupportedError,
-  etherUnits,
-  gweiUnits,
-  weiUnits,
+  defineChain,
+  format3 as format,
+  defineFormatter,
   transactionType,
   formatTransaction,
+  defineTransaction,
   formatBlock,
+  defineBlock,
+  extract,
   formatFeeHistory,
-  format3 as format,
   formatLog,
   formatTransactionReceipt,
+  defineTransactionReceipt,
   formatTransactionRequest,
+  defineTransactionRequest,
   getCache,
   withCache,
   wait,
   getSocket,
   rpc,
-  HttpRequestError,
-  RpcError,
-  TimeoutError,
+  etherUnits,
+  gweiUnits,
+  weiUnits,
   formatUnit,
   formatEther,
   formatGwei,
   parseUnit,
   parseEther,
-  parseGwei
+  parseGwei,
+  HttpRequestError,
+  WebSocketRequestError,
+  RpcError,
+  TimeoutError,
+  InvalidGasArgumentsError,
+  TransactionNotFoundError,
+  TransactionReceiptNotFoundError,
+  WaitForTransactionReceiptTimeoutError,
+  UrlRequiredError
 };
+//# sourceMappingURL=chunk-5Q6FSUU2.mjs.map