viem 0.0.1-alpha.1 → 0.0.1-alpha.3

package/dist/{chunk-Z6LRV6XI.js → chunk-SRDTRROA.js}

@@ -1,160 +1,22 @@
-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.1",
-  scripts: {
-    anvil: "source .env && anvil --fork-url $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",
-      default: "./dist/index.js"
-    },
-    "./actions": {
-      types: "./dist/actions/index.d.ts",
-      default: "./dist/actions/index.js"
-    },
-    "./chains": {
-      types: "./dist/chains.d.ts",
-      default: "./dist/chains.js"
-    },
-    "./clients": {
-      types: "./dist/clients/index.d.ts",
-      default: "./dist/clients/index.js"
-    },
-    "./utils": {
-      types: "./dist/utils/index.d.ts",
-      default: "./dist/utils/index.js"
-    },
-    "./window": {
-      types: "./dist/window.d.ts",
-      default: "./dist/window.js"
-    },
-    "./package.json": "./package.json"
-  },
-  type: "module",
-  main: "dist/index.js",
-  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/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;
-  }
-};
+import {
+  AbiDecodingDataSizeInvalidError,
+  AbiEncodingArrayLengthMismatchError,
+  AbiEncodingLengthMismatchError,
+  AbiFunctionNotFoundError,
+  AbiFunctionSignatureNotFoundError,
+  DataLengthTooLongError,
+  DataLengthTooShortError,
+  InvalidAbiDecodingTypeError,
+  InvalidAbiEncodingTypeError,
+  InvalidAddressError,
+  InvalidArrayError,
+  InvalidBytesBooleanError,
+  InvalidDefinitionTypeError,
+  InvalidHexBooleanError,
+  InvalidHexValueError,
+  OffsetOutOfBoundsError,
+  SizeExceedsPaddingSizeError
+} from "./chunk-WZITKXV3.js";
 
 // src/utils/data/concat.ts
 function concat(values) {
@@ -233,18 +95,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 +307,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 +336,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,38 +417,6 @@ 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
 var paramsRegex = /((function|event)\s)?(.*)(\((.*)\))/;
@@ -665,7 +467,7 @@ function hashFunction(def) {
 var getEventSignature = (event) => hashFunction(event);
 
 // src/utils/hash/getFunctionSignature.ts
-var getFunctionSignature = (fn) => hashFunction(fn).slice(0, 10);
+var getFunctionSignature = (fn) => slice(hashFunction(fn), 0, 4);
 
 // src/utils/address/getAddress.ts
 var addressRegex = /^(0x)?[a-fA-F0-9]{40}$/;
@@ -688,12 +490,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) {
@@ -754,7 +550,10 @@ function encodeAbi({
       givenLength: values.length
     });
   const preparedParams = prepareParams({ params, values });
-  return encodeParams(preparedParams);
+  const data = encodeParams(preparedParams);
+  if (data.length === 0)
+    return void 0;
+  return data;
 }
 function prepareParams({
   params,
@@ -822,6 +621,9 @@ function encodeParams(preparedParams) {
   }
   return concat([...staticParams, ...dynamicParams]);
 }
+function encodeAddress(value) {
+  return { dynamic: false, encoded: padHex(value.toLowerCase()) };
+}
 function encodeArray(value, {
   length,
   param
@@ -860,27 +662,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_)
@@ -914,59 +695,28 @@ function encodeString(value) {
     ])
   };
 }
+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;
 }
-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");
-  }
-};
 
 // src/utils/abi/decodeAbi.ts
 function decodeAbi({
@@ -1029,6 +779,9 @@ function decodeParam({
   }
   throw new InvalidAbiDecodingTypeError(param.type);
 }
+function decodeAddress(value) {
+  return { consumed: 32, value: checksumAddress(trim(value)) };
+}
 function decodeArray(data, {
   param,
   length,
@@ -1080,9 +833,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) };
 }
@@ -1158,192 +908,58 @@ 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)})`;
+}
+function getParams(params) {
+  if (!params)
+    return "";
+  return params.map(getParam).join(",");
+}
+function getParam(param) {
+  if (param.type.startsWith("tuple")) {
+    return `(${getParams(
+      param.components
+    )})${param.type.slice("tuple".length)}`;
   }
-};
+  return param.type;
+}
 
-// 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(getDefinition(x))
+  );
+  if (!description)
+    throw new AbiFunctionSignatureNotFoundError(signature);
+  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);
-  }
-};
-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/utils/abi/encodeFunctionData.ts
+function encodeFunctionData({
+  abi,
+  args,
+  functionName
+}) {
+  const description = abi.find((x) => "name" in x && x.name === functionName);
+  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"]);
+}
 
 // src/constants.ts
 var etherUnits = {
@@ -1471,364 +1087,6 @@ function formatTransactionRequest(transactionRequest) {
   };
 }
 
-// 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: controller?.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: JSON.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 = data2?.headers.get("Retry-After");
-        if (retryAfter?.match(/\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 (response.headers.get("Content-Type")?.startsWith("application/json")) {
-    data = await response.json();
-  } else {
-    data = await response.text();
-  }
-  if (!response.ok) {
-    throw new HttpRequestError({
-      body,
-      details: JSON.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) {
-      onError?.(new RpcError({ body, error: message.error, url: socket.url }));
-    } else {
-      onData?.(message);
-    }
-    if (body.method === "eth_subscribe" && typeof message.result === "string") {
-      socket.subscriptions.set(message.result, callback);
-    }
-    if (body.method === "eth_unsubscribe") {
-      socket.subscriptions.delete(body.params?.[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
-};
-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");
-  }
-};
-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 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");
-  }
-};
-
 // src/utils/unit/formatUnit.ts
 function formatUnit(value, decimals) {
   let display = value.toString();
@@ -1887,8 +1145,6 @@ function parseGwei(ether, unit = "wei") {
 }
 
 export {
-  __publicField,
-  BaseError,
   isBytes,
   isHex,
   pad,
@@ -1936,20 +1192,8 @@ export {
   isAddressEqual,
   encodeAbi,
   decodeAbi,
-  buildRequest,
-  RpcRequestError,
-  ParseRpcError,
-  InvalidRequestRpcError,
-  MethodNotFoundRpcError,
-  InvalidParamsRpcError,
-  InternalRpcError,
-  InvalidInputRpcError,
-  ResourceNotFoundRpcError,
-  ResourceUnavailableRpcError,
-  TransactionRejectedRpcError,
-  MethodNotSupportedRpcError,
-  LimitExceededRpcError,
-  JsonRpcVersionUnsupportedError,
+  decodeFunctionData,
+  encodeFunctionData,
   etherUnits,
   gweiUnits,
   weiUnits,
@@ -1961,14 +1205,6 @@ export {
   formatLog,
   formatTransactionReceipt,
   formatTransactionRequest,
-  getCache,
-  withCache,
-  wait,
-  getSocket,
-  rpc,
-  HttpRequestError,
-  RpcError,
-  TimeoutError,
   formatUnit,
   formatEther,
   formatGwei,