viem 0.0.1-alpha.24 → 0.0.1-alpha.26

package/dist/{chunk-LQVMDX5I.mjs → chunk-PRG3BBPZ.mjs}

@@ -6,159 +6,15 @@ var __publicField = (obj, key, value) => {
 };
 
 // package.json
-var package_default = {
-  name: "viem",
-  description: "TypeScript Interface for Ethereum",
-  version: "0.0.1-alpha.24",
-  scripts: {
-    anvil: "source .env && anvil --fork-url $VITE_ANVIL_FORK_URL --fork-block-number $VITE_ANVIL_BLOCK_NUMBER --block-time $VITE_ANVIL_BLOCK_TIME",
-    bench: "vitest bench --no-threads",
-    "bench:ci": "CI=true vitest bench --no-threads",
-    build: "tsup",
-    changeset: "changeset",
-    "changeset:release": "pnpm build && changeset publish",
-    "changeset:version": "changeset version && pnpm install --lockfile-only",
-    "contracts:build": "wagmi generate",
-    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 && pnpm contracts:build",
-    preinstall: "npx only-allow pnpm",
-    prepublishOnly: "pnpm ts-node scripts/generate-package-json.ts",
-    prepare: "npx simple-git-hooks",
-    test: "vitest dev --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: [
-    "/actions",
-    "/chains",
-    "/dist",
-    "/clients",
-    "/src",
-    "/types",
-    "/utils",
-    "/window"
-  ],
-  exports: {
-    ".": {
-      types: "./dist/index.d.ts",
-      module: "./dist/index.mjs",
-      default: "./dist/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"
-    },
-    "./ens": {
-      types: "./dist/ens.d.ts",
-      module: "./dist/ens.mjs",
-      default: "./dist/ens.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"
-  },
-  main: "dist/index.js",
-  module: "dist/index.mjs",
-  types: "dist/index.d.ts",
-  sideEffects: false,
-  dependencies: {
-    "@noble/hashes": "^1.1.2",
-    "@wagmi/chains": "~0.2.6",
-    abitype: "~0.3.0",
-    "idna-uts46-hx": "^4.1.2"
-  },
-  devDependencies: {
-    "@actions/core": "^1.10.0",
-    "@actions/github": "^5.1.1",
-    "@adraffy/ens-normalize": "^1.8.9",
-    "@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",
-    "@wagmi/cli": "^0.1.5",
-    bundlewatch: "^0.3.3",
-    dedent: "^0.7.0",
-    esbuild: "^0.16.12",
-    "esbuild-register": "^3.4.2",
-    ethers: "^5.7.2",
-    "ethers@6": "npm:ethers@^6.0.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.4",
-    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"
-    }
-  }
-};
+var name = "viem";
+var version = "0.0.1-alpha.26";
+
+// src/errors/utils.ts
+var getContractAddress = (address) => address;
+var getUrl = (url) => url;
+var getVersion = () => `${name}@${version}`;
 
 // src/errors/base.ts
-var version = process.env.TEST ? "1.0.2" : package_default.version;
 var BaseError = class extends Error {
   constructor(shortMessage, args = {}) {
     const details = args.cause instanceof BaseError ? args.cause.details : args.cause?.message ? args.cause.message : args.details;
@@ -169,7 +25,7 @@ var BaseError = class extends Error {
       ...args.metaMessages ? [...args.metaMessages, ""] : [],
       ...docsPath5 ? [`Docs: https://viem.sh${docsPath5}`] : [],
       ...details ? [`Details: ${details}`] : [],
-      `Version: viem@${version}`
+      `Version: ${getVersion()}`
     ].join("\n");
     super(message);
     __publicField(this, "details");
@@ -298,7 +154,7 @@ var AbiErrorSignatureNotFoundError = class extends BaseError {
       [
         `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/.`
+        `You can look up the signature here: https://openchain.xyz/signatures?query=${signature}.`
       ].join("\n"),
       {
         docsPath: docsPath5
@@ -307,6 +163,21 @@ var AbiErrorSignatureNotFoundError = class extends BaseError {
     __publicField(this, "name", "AbiErrorSignatureNotFoundError");
   }
 };
+var AbiEventSignatureNotFoundError = class extends BaseError {
+  constructor(signature, { docsPath: docsPath5 }) {
+    super(
+      [
+        `Encoded event signature "${signature}" not found on ABI.`,
+        "Make sure you are using the correct ABI and that the event exists on it.",
+        `You can look up the signature here: https://openchain.xyz/signatures?query=${signature}.`
+      ].join("\n"),
+      {
+        docsPath: docsPath5
+      }
+    );
+    __publicField(this, "name", "AbiEventSignatureNotFoundError");
+  }
+};
 var AbiEventNotFoundError = class extends BaseError {
   constructor(eventName, { docsPath: docsPath5 }) {
     super(
@@ -356,7 +227,7 @@ var AbiFunctionSignatureNotFoundError = class extends BaseError {
       [
         `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/.`
+        `You can look up the signature here: https://openchain.xyz/signatures?query=${signature}.`
       ].join("\n"),
       {
         docsPath: docsPath5
@@ -431,6 +302,30 @@ var BlockNotFoundError = class extends BaseError {
   }
 };
 
+// src/errors/chain.ts
+var ChainDoesNotSupportContract = class extends BaseError {
+  constructor({
+    blockNumber,
+    chain,
+    contract
+  }) {
+    super(
+      `Chain "${chain.name}" does not support contract "${contract.name}".`,
+      {
+        metaMessages: [
+          "This could be due to any of the following:",
+          ...blockNumber && contract.blockCreated && contract.blockCreated > blockNumber ? [
+            `- The contract "${contract.name}" was not deployed until block ${contract.blockCreated} (current block ${blockNumber}).`
+          ] : [
+            `- The chain does not have the contract "${contract.name}" configured.`
+          ]
+        ]
+      }
+    );
+    __publicField(this, "name", "ChainDoesNotSupportContract");
+  }
+};
+
 // src/constants/abis.ts
 var multicall3Abi = [
   {
@@ -534,7 +429,7 @@ var ContractFunctionExecutionError = class extends BaseError {
         docsPath: docsPath5,
         metaMessages: [
           ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
-          contractAddress && `Contract:  ${process.env.TEST ? "0x0000000000000000000000000000000000000000" : contractAddress}`,
+          contractAddress && `Contract:  ${getContractAddress(contractAddress)}`,
           functionWithParams && `Function:  ${functionWithParams}`,
           formattedArgs && formattedArgs !== "()" && `Arguments: ${[...Array(functionName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}`,
           sender && `Sender:    ${sender}`
@@ -703,17 +598,22 @@ var FilterTypeNotSupportedError = class extends BaseError {
 
 // src/errors/request.ts
 var RequestError = class extends BaseError {
-  constructor(err, { docsPath: docsPath5, shortMessage }) {
+  constructor(err, {
+    docsPath: docsPath5,
+    metaMessages,
+    shortMessage
+  }) {
     super(shortMessage, {
       cause: err,
-      docsPath: docsPath5
+      docsPath: docsPath5,
+      metaMessages
     });
     this.name = err.name;
   }
 };
 var RpcRequestError = class extends RequestError {
   constructor(err, { docsPath: docsPath5, shortMessage }) {
-    super(err, { docsPath: docsPath5, shortMessage });
+    super(err, { docsPath: docsPath5, metaMessages: err.metaMessages, shortMessage });
     __publicField(this, "code");
     this.code = err.code;
     this.name = err.name;
@@ -833,24 +733,27 @@ var HttpRequestError = class extends BaseError {
   constructor({
     body,
     details,
+    headers,
     status,
     url
   }) {
-    super(
-      [
-        "HTTP request failed.",
-        "",
-        `Status: ${status}`,
-        `URL: ${url}`,
+    super("HTTP request failed.", {
+      details,
+      metaMessages: [
+        status && `Status: ${status}`,
+        `URL: ${getUrl(url)}`,
         `Request body: ${stringify(body)}`
-      ].join("\n"),
-      {
-        details
-      }
-    );
+      ].filter(Boolean)
+    });
     __publicField(this, "name", "HttpRequestError");
+    __publicField(this, "body");
+    __publicField(this, "headers");
     __publicField(this, "status");
+    __publicField(this, "url");
+    this.body = body;
+    this.headers = headers;
     this.status = status;
+    this.url = url;
   }
 };
 var WebSocketRequestError = class extends BaseError {
@@ -859,17 +762,10 @@ var WebSocketRequestError = class extends BaseError {
     details,
     url
   }) {
-    super(
-      [
-        "WebSocket request failed.",
-        "",
-        `URL: ${url}`,
-        `Request body: ${stringify(body)}`
-      ].join("\n"),
-      {
-        details
-      }
-    );
+    super("WebSocket request failed.", {
+      details,
+      metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`]
+    });
     __publicField(this, "name", "WebSocketRequestError");
   }
 };
@@ -879,18 +775,11 @@ var RpcError = class extends BaseError {
     error,
     url
   }) {
-    super(
-      [
-        "RPC Request failed.",
-        "",
-        `URL: ${url}`,
-        `Request body: ${stringify(body)}`
-      ].join("\n"),
-      {
-        cause: error,
-        details: error.message
-      }
-    );
+    super("RPC Request failed.", {
+      cause: error,
+      details: error.message,
+      metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`]
+    });
     __publicField(this, "code");
     __publicField(this, "name", "RpcError");
     this.code = error.code;
@@ -901,17 +790,10 @@ var TimeoutError = class extends BaseError {
     body,
     url
   }) {
-    super(
-      [
-        "The request took too long to respond.",
-        "",
-        `URL: ${url}`,
-        `Request body: ${stringify(body)}`
-      ].join("\n"),
-      {
-        details: "The request timed out."
-      }
-    );
+    super("The request took too long to respond.", {
+      details: "The request timed out.",
+      metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`]
+    });
     __publicField(this, "name", "TimeoutError");
   }
 };
@@ -1378,9 +1260,9 @@ var paramsRegex = /((function|event)\s)?(.*)(\((.*)\))/;
 function extractFunctionParts(def) {
   const parts = def.match(paramsRegex);
   const type = parts?.[2] || void 0;
-  const name = parts?.[3];
+  const name2 = parts?.[3];
   const params = parts?.[5] || void 0;
-  return { type, name, params };
+  return { type, name: name2, params };
 }
 function extractFunctionName(def) {
   return extractFunctionParts(def).name;
@@ -1443,11 +1325,11 @@ function keccak256(value, to_) {
 // src/utils/hash/hashFunction.ts
 var hash = (value) => keccak256(encodeBytes(value));
 function hashFunction(def) {
-  const name = extractFunctionName(def);
+  const name2 = extractFunctionName(def);
   const params = extractFunctionParams(def);
   if (!params || params.length === 0)
     return hash(def.replace(/ /g, ""));
-  return hash(`${name}(${params.map(({ type }) => type).join(",")})`);
+  return hash(`${name2}(${params.map(({ type }) => type).join(",")})`);
 }
 
 // src/utils/hash/getEventSignature.ts
@@ -1479,7 +1361,7 @@ function getAddress(address) {
 }
 
 // src/utils/address/getContractAddress.ts
-function getContractAddress(opts) {
+function getContractAddress2(opts) {
   if (opts.opcode === "CREATE2")
     return getCreate2Address(opts);
   return getCreateAddress(opts);
@@ -1710,7 +1592,10 @@ function encodeTuple(value, { param }) {
 }
 function getArrayComponents(type) {
   const matches = type.match(/^(.*)\[(\d+)?\]$/);
-  return matches ? [matches[2] ? Number(matches[2]) : null, matches[1]] : void 0;
+  return matches ? (
+    // Return `null` if the array is dynamic.
+    [matches[2] ? Number(matches[2]) : null, matches[1]]
+  ) : void 0;
 }
 
 // src/utils/abi/decodeAbi.ts
@@ -1863,7 +1748,7 @@ function decodeString(data, { position }) {
   return { consumed: 32, value };
 }
 function decodeTuple(data, { param, position }) {
-  const hasUnnamedChild = param.components.length === 0 || param.components.some(({ name }) => !name);
+  const hasUnnamedChild = param.components.length === 0 || param.components.some(({ name: name2 }) => !name2);
   let value = hasUnnamedChild ? [] : {};
   let consumed = 0;
   if (hasDynamicChild(param)) {
@@ -1952,6 +1837,61 @@ function decodeErrorResult({
   };
 }
 
+// src/utils/abi/decodeEventLog.ts
+function decodeEventLog({
+  abi,
+  data,
+  topics
+}) {
+  const [signature, ...argTopics] = topics;
+  const abiItem = abi.find(
+    (x) => signature === getEventSignature(formatAbiItem(x))
+  );
+  if (!(abiItem && "name" in abiItem))
+    throw new AbiEventSignatureNotFoundError(signature, {
+      docsPath: "/docs/contract/decodeEventLog"
+    });
+  const { name: name2, inputs } = abiItem;
+  const isUnnamed = inputs?.some((x) => !("name" in x && x.name));
+  let args = isUnnamed ? [] : {};
+  for (let i = 0; i < inputs.length; i++) {
+    const param = inputs[i];
+    const topic = argTopics[i];
+    if (topic === null)
+      args[param.name || i] = null;
+    if (!topic)
+      continue;
+    if (Array.isArray(topic)) {
+      args[param.name || i] = topic.map((t) => decodeTopic({ param, value: t }));
+    } else {
+      args[param.name || i] = decodeTopic({ param, value: topic });
+    }
+  }
+  if (data) {
+    const params = inputs.filter((x) => !("indexed" in x && x.indexed));
+    const decodedData = decodeAbi({ params, data });
+    if (decodedData) {
+      if (isUnnamed)
+        args = [...args, ...decodedData];
+      else {
+        for (let i = 0; i < params.length; i++) {
+          args[params[i].name] = decodedData[i];
+        }
+      }
+    }
+  }
+  return {
+    eventName: name2,
+    args: Object.values(args).length > 0 ? args : void 0
+  };
+}
+function decodeTopic({ param, value }) {
+  if (param.type === "string" || param.type === "bytes" || param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
+    return value;
+  const decodedArg = decodeAbi({ params: [param], data: value }) || [];
+  return decodedArg[0];
+}
+
 // src/utils/abi/decodeFunctionData.ts
 function decodeFunctionData({ abi, data }) {
   const signature = slice(data, 0, 4);
@@ -1969,8 +1909,8 @@ function decodeFunctionData({ abi, data }) {
 }
 
 // src/utils/abi/getAbiItem.ts
-function getAbiItem({ abi, args = [], name }) {
-  const abiItems = abi.filter((x) => "name" in x && x.name === name);
+function getAbiItem({ abi, args = [], name: name2 }) {
+  const abiItems = abi.filter((x) => "name" in x && x.name === name2);
   if (abiItems.length === 0)
     return void 0;
   if (abiItems.length === 1)
@@ -2030,6 +1970,7 @@ function isArgOfType(arg, abiParameter) {
         return Array.isArray(arg) && arg.every(
           (x) => isArgOfType(x, {
             ...abiParameter,
+            // Pop off `[]` or `[M]` from end of type
             type: abiParameterType.replace(/(\[[0-9]{0,}\])$/, "")
           })
         );
@@ -2199,74 +2140,180 @@ function formatAbiItemWithArgs({
   ).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/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 = (/* @__PURE__ */ 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: /* @__PURE__ */ new Date(), data });
+  return data;
+}
 
-// src/utils/chain.ts
-function defineChain(chain) {
-  return chain;
+// src/utils/wait.ts
+async function wait(time) {
+  return new Promise((res) => setTimeout(res, time));
 }
 
-// src/utils/ens/normalize.ts
-import { toUnicode } from "idna-uts46-hx";
-function normalize(name) {
-  return toUnicode(name, { useStd3ASCII: true });
+// src/utils/promise/withRetry.ts
+function withRetry(fn, {
+  delay: delay_ = 100,
+  retryCount = 2,
+  shouldRetry = () => true
+} = {}) {
+  return new Promise((resolve, reject) => {
+    const attemptRetry = async ({ count = 0 } = {}) => {
+      const retry = async ({ error }) => {
+        const delay = typeof delay_ === "function" ? delay_({ count, error }) : delay_;
+        if (delay)
+          await wait(delay);
+        attemptRetry({ count: count + 1 });
+      };
+      try {
+        const data = await fn();
+        resolve(data);
+      } catch (err) {
+        if (count < retryCount && await shouldRetry({ count, error: err }))
+          return retry({ error: err });
+        reject(err);
+      }
+    };
+    attemptRetry();
+  });
 }
 
-// src/utils/ens/labelhash.ts
-function labelhash(label) {
-  let result = new Uint8Array(32).fill(0);
-  if (!label)
-    return bytesToHex(result);
-  return keccak256(stringToBytes(normalize(label)));
+// 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/ens/namehash.ts
-function namehash(name) {
-  let result = new Uint8Array(32).fill(0);
-  if (!name)
-    return bytesToHex(result);
-  const labels = normalize(name).split(".");
-  for (let i = labels.length - 1; i >= 0; i -= 1) {
-    const hashed = keccak256(stringToBytes(labels[i]), "bytes");
-    result = keccak256(concat([result, hashed]), "bytes");
-  }
-  return bytesToHex(result);
+// src/utils/buildRequest.ts
+var isDeterministicError = (error) => {
+  if (error instanceof UnknownRpcError)
+    return false;
+  if ("code" in error)
+    return error.code !== -32603 && error.code !== -32005;
+  if (error instanceof HttpRequestError && error.status)
+    return error.status !== 408 && error.status !== 413 && error.status !== 429 && error.status !== 500;
+  return true;
+};
+function buildRequest(request, {
+  retryDelay = 150,
+  retryCount = 3
+} = {}) {
+  return async (args) => withRetry(
+    async () => {
+      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);
+      }
+    },
+    {
+      delay: ({ count, error }) => {
+        if (error && error instanceof HttpRequestError) {
+          const retryAfter = error?.headers?.get("Retry-After");
+          if (retryAfter?.match(/\d/))
+            return parseInt(retryAfter) * 1e3;
+        }
+        return ~~(1 << count) * retryDelay;
+      },
+      retryCount,
+      shouldRetry: ({ error }) => !isDeterministicError(error)
+    }
+  );
+}
+
+// src/utils/chain.ts
+function defineChain(chain) {
+  return chain;
 }
 
 // src/utils/formatters/format.ts
@@ -2422,115 +2469,9 @@ var defineTransactionRequest = defineFormatter({
   format: formatTransactionRequest
 });
 
-// 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
+import fetch from "isomorphic-unfetch";
+import WebSocket from "isomorphic-ws";
 
 // src/utils/stringify.ts
 function stringify(value) {
@@ -2544,12 +2485,10 @@ function stringify(value) {
 var id = 0;
 async function http(url, {
   body,
-  retryDelay = 100,
-  retryCount = 2,
   timeout = 0
 }) {
-  const response = await withRetry(
-    () => withTimeout(
+  try {
+    const response = await withTimeout(
       async ({ signal }) => {
         const response2 = await fetch(url, {
           headers: {
@@ -2566,42 +2505,39 @@ async function http(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();
     }
-  );
-  let data;
-  if (response.headers.get("Content-Type")?.startsWith("application/json")) {
-    data = await response.json();
-  } else {
-    data = await response.text();
-  }
-  if (!response.ok) {
+    if (!response.ok) {
+      throw new HttpRequestError({
+        body,
+        details: stringify(data.error) || response.statusText,
+        headers: response.headers,
+        status: response.status,
+        url
+      });
+    }
+    if (data.error) {
+      throw new RpcError({ body, error: data.error, url });
+    }
+    return data;
+  } catch (err) {
+    if (err instanceof HttpRequestError)
+      throw err;
+    if (err instanceof RpcError)
+      throw err;
+    if (err instanceof TimeoutError)
+      throw err;
     throw new HttpRequestError({
       body,
-      details: stringify(data.error) || response.statusText,
-      status: response.status,
+      details: err.message,
       url
     });
   }
-  if (data.error) {
-    throw new RpcError({ body, error: data.error, url });
-  }
-  return data;
 }
 var sockets = /* @__PURE__ */ new Map();
 async function getSocket(url_) {
@@ -2794,7 +2730,46 @@ export {
   InvalidDefinitionTypeError,
   InvalidAddressError,
   BlockNotFoundError,
+  ChainDoesNotSupportContract,
   multicall3Abi,
+  panicReasons,
+  ContractFunctionExecutionError,
+  ContractFunctionRevertedError,
+  ContractFunctionZeroDataError,
+  RawContractError,
+  SizeExceedsPaddingSizeError,
+  DataLengthTooLongError,
+  DataLengthTooShortError,
+  InvalidBytesBooleanError,
+  InvalidHexBooleanError,
+  InvalidHexValueError,
+  OffsetOutOfBoundsError,
+  FilterTypeNotSupportedError,
+  RequestError,
+  RpcRequestError,
+  ParseRpcError,
+  InvalidRequestRpcError,
+  MethodNotFoundRpcError,
+  InvalidParamsRpcError,
+  InternalRpcError,
+  InvalidInputRpcError,
+  ResourceNotFoundRpcError,
+  ResourceUnavailableRpcError,
+  TransactionRejectedRpcError,
+  MethodNotSupportedRpcError,
+  LimitExceededRpcError,
+  JsonRpcVersionUnsupportedError,
+  UnknownRpcError,
+  HttpRequestError,
+  WebSocketRequestError,
+  RpcError,
+  TimeoutError,
+  InvalidGasArgumentsError,
+  TransactionNotFoundError,
+  TransactionReceiptNotFoundError,
+  WaitForTransactionReceiptTimeoutError,
+  UrlRequiredError,
+  concat,
   isBytes,
   isHex,
   pad,
@@ -2837,7 +2812,7 @@ export {
   getFunctionSignature,
   checksumAddress,
   getAddress,
-  getContractAddress,
+  getContractAddress2 as getContractAddress,
   getCreateAddress,
   getCreate2Address,
   isAddress,
@@ -2846,6 +2821,7 @@ export {
   decodeAbi,
   formatAbiItem,
   decodeErrorResult,
+  decodeEventLog,
   decodeFunctionData,
   getAbiItem,
   decodeFunctionResult,
@@ -2855,11 +2831,12 @@ export {
   encodeFunctionData,
   encodeFunctionResult,
   formatAbiItemWithArgs,
+  getCache,
+  withCache,
+  wait,
+  isDeterministicError,
   buildRequest,
   defineChain,
-  normalize,
-  labelhash,
-  namehash,
   format3 as format,
   defineFormatter,
   transactionType,
@@ -2874,9 +2851,6 @@ export {
   defineTransactionReceipt,
   formatTransactionRequest,
   defineTransactionRequest,
-  getCache,
-  withCache,
-  wait,
   stringify,
   getSocket,
   rpc,
@@ -2888,42 +2862,6 @@ export {
   formatGwei,
   parseUnit,
   parseEther,
-  parseGwei,
-  ContractFunctionExecutionError,
-  ContractFunctionRevertedError,
-  ContractFunctionZeroDataError,
-  RawContractError,
-  SizeExceedsPaddingSizeError,
-  DataLengthTooLongError,
-  DataLengthTooShortError,
-  InvalidBytesBooleanError,
-  InvalidHexBooleanError,
-  InvalidHexValueError,
-  OffsetOutOfBoundsError,
-  FilterTypeNotSupportedError,
-  RequestError,
-  RpcRequestError,
-  ParseRpcError,
-  InvalidRequestRpcError,
-  MethodNotFoundRpcError,
-  InvalidParamsRpcError,
-  InternalRpcError,
-  InvalidInputRpcError,
-  ResourceNotFoundRpcError,
-  ResourceUnavailableRpcError,
-  TransactionRejectedRpcError,
-  MethodNotSupportedRpcError,
-  LimitExceededRpcError,
-  JsonRpcVersionUnsupportedError,
-  UnknownRpcError,
-  HttpRequestError,
-  WebSocketRequestError,
-  RpcError,
-  TimeoutError,
-  InvalidGasArgumentsError,
-  TransactionNotFoundError,
-  TransactionReceiptNotFoundError,
-  WaitForTransactionReceiptTimeoutError,
-  UrlRequiredError
+  parseGwei
 };
-//# sourceMappingURL=chunk-LQVMDX5I.mjs.map
+//# sourceMappingURL=chunk-PRG3BBPZ.mjs.map