viem 0.0.1-alpha.25 → 0.0.1-alpha.27

package/dist/{chunk-KSAO4Y4Q.mjs → chunk-AKGXRZDN.mjs}

@@ -9,7 +9,7 @@ var __publicField = (obj, key, value) => {
 var package_default = {
   name: "viem",
   description: "TypeScript Interface for Ethereum",
-  version: "0.0.1-alpha.25",
+  version: "0.0.1-alpha.26",
   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",
@@ -18,30 +18,45 @@ var package_default = {
     changeset: "changeset",
     "changeset:release": "pnpm build && changeset publish",
     "changeset:version": "changeset version && pnpm install --lockfile-only",
+    clean: "rimraf dist chains contract ens public test utils wallet window",
     "contracts:build": "wagmi generate",
     dev: "DEV=true tsup",
     "dev:docs": "pnpm -r --filter site dev",
-    format: "rome format src/ test/ --write",
+    format: "rome format src/ --write",
     lint: "rome check .",
     "lint:fix": "pnpm lint --apply-suggested",
-    playground: "pnpm --filter playground-dev dev",
+    playground: "pnpm --filter playground-browser dev",
     postinstall: "pnpm dev && pnpm contracts:build",
     preinstall: "npx only-allow pnpm",
-    prepublishOnly: "pnpm ts-node scripts/generate-package-json.ts",
+    prepublishOnly: "pnpm bun scripts/prepublishOnly.ts",
     prepare: "npx simple-git-hooks",
     test: "vitest dev --no-threads",
+    "test:cov": "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",
+    "ts-node": "bun",
     typecheck: "tsc --noEmit"
   },
+  tsup: {
+    entry: [
+      "src/index.ts",
+      "src/chains.ts",
+      "src/contract.ts",
+      "src/ens.ts",
+      "src/public.ts",
+      "src/test.ts",
+      "src/utils/index.ts",
+      "src/wallet.ts",
+      "src/window.ts"
+    ]
+  },
   files: [
+    "/dist",
     "/chains",
     "/contract",
-    "/dist",
     "/ens",
-    "/src",
-    "/types",
+    "/public",
+    "/test",
     "/utils",
     "/wallet",
     "/window"
@@ -49,47 +64,47 @@ var package_default = {
   exports: {
     ".": {
       types: "./dist/index.d.ts",
-      module: "./dist/index.mjs",
+      module: "./dist/index.mts",
       default: "./dist/index.js"
     },
     "./chains": {
       types: "./dist/chains.d.ts",
-      module: "./dist/chains.mjs",
+      module: "./dist/chains.mts",
       default: "./dist/chains.js"
     },
     "./contract": {
       types: "./dist/contract.d.ts",
-      module: "./dist/contract.mjs",
+      module: "./dist/contract.mts",
       default: "./dist/contract.js"
     },
     "./ens": {
       types: "./dist/ens.d.ts",
-      module: "./dist/ens.mjs",
+      module: "./dist/ens.mts",
       default: "./dist/ens.js"
     },
     "./public": {
       types: "./dist/public.d.ts",
-      module: "./dist/public.mjs",
+      module: "./dist/public.mts",
       default: "./dist/public.js"
     },
     "./test": {
       types: "./dist/test.d.ts",
-      module: "./dist/test.mjs",
+      module: "./dist/test.mts",
       default: "./dist/test.js"
     },
     "./utils": {
       types: "./dist/utils/index.d.ts",
-      module: "./dist/utils/index.mjs",
+      module: "./dist/utils/index.mts",
       default: "./dist/utils/index.js"
     },
     "./wallet": {
       types: "./dist/wallet.d.ts",
-      module: "./dist/wallet.mjs",
+      module: "./dist/wallet.mts",
       default: "./dist/wallet.js"
     },
     "./window": {
       types: "./dist/window.d.ts",
-      module: "./dist/window.mjs",
+      module: "./dist/window.mts",
       default: "./dist/window.js"
     },
     "./package.json": "./package.json"
@@ -103,7 +118,6 @@ var package_default = {
     "@wagmi/chains": "~0.2.8",
     abitype: "~0.3.0",
     "idna-uts46-hx": "^4.1.2",
-    "isomorphic-unfetch": "^4.0.2",
     "isomorphic-ws": "^5.0.0",
     ws: "^8.12.0"
   },
@@ -120,20 +134,20 @@ var package_default = {
     "@vitest/coverage-c8": "^0.24.3",
     "@vitest/ui": "^0.19.1",
     "@wagmi/cli": "^0.1.6",
+    bun: "^0.5.5",
     bundlewatch: "^0.3.3",
     dedent: "^0.7.0",
-    esbuild: "^0.16.17",
-    "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",
+    rimraf: "^4.1.2",
     rome: "^11.0.0",
     "simple-git-hooks": "^2.8.1",
     tsup: "^6.6.0",
     typescript: "^4.9.4",
     vite: "^3.2.5",
-    vitest: "^0.25.8",
+    vitest: "~0.25.8",
     web3: "^1.8.1"
   },
   license: "MIT",
@@ -150,7 +164,7 @@ var package_default = {
     "web3"
   ],
   "simple-git-hooks": {
-    "pre-commit": "pnpm format & pnpm lint:fix"
+    "pre-commit": "pnpm format && pnpm lint:fix"
   },
   pnpm: {
     patchedDependencies: {
@@ -159,8 +173,12 @@ var package_default = {
   }
 };
 
+// src/errors/utils.ts
+var getContractAddress = (address) => address;
+var getUrl = (url) => url;
+var getVersion = () => `${package_default.name}@${package_default.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;
@@ -171,7 +189,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");
@@ -575,8 +593,7 @@ var ContractFunctionExecutionError = class extends BaseError {
         docsPath: docsPath5,
         metaMessages: [
           ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
-          contractAddress && `Contract:  ${/* c8 ignore start */
-          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}`
@@ -745,17 +762,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;
@@ -875,24 +897,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 {
@@ -901,17 +926,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");
   }
 };
@@ -921,18 +939,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;
@@ -943,17 +954,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");
   }
 };
@@ -1143,7 +1147,7 @@ function sliceHex(value_, start, end) {
   return `0x${value}`;
 }
 
-// src/utils/encoding/encodeHex.ts
+// src/utils/encoding/toHex.ts
 var hexes = Array.from(
   { length: 256 },
   (v, i) => i.toString(16).padStart(2, "0")
@@ -1158,7 +1162,7 @@ function bytesToHex(value) {
   }
   return `0x${hex}`;
 }
-function encodeHex(value) {
+function toHex(value) {
   if (typeof value === "number" || typeof value === "bigint")
     return numberToHex(value);
   if (typeof value === "string") {
@@ -1200,14 +1204,14 @@ function stringToHex(value) {
   return `0x${hex}`;
 }
 
-// src/utils/encoding/encodeBytes.ts
+// src/utils/encoding/toBytes.ts
 var encoder = new TextEncoder();
 function boolToBytes(value) {
   const bytes = new Uint8Array(1);
   bytes[0] = Number(value);
   return bytes;
 }
-function encodeBytes(value) {
+function toBytes(value) {
   if (typeof value === "number" || typeof value === "bigint")
     return numberToBytes(value);
   if (typeof value === "boolean")
@@ -1239,15 +1243,15 @@ function stringToBytes(value) {
   return encoder.encode(value);
 }
 
-// src/utils/encoding/encodeRlp.ts
-function encodeRlp(hexOrBytes, to_) {
+// src/utils/encoding/toRlp.ts
+function toRlp(hexOrBytes, to_) {
   const to = to_ || "hex";
   return format(bytesToRlp(parse(hexOrBytes)), to);
 }
 function parse(hexOrBytes) {
   if (Array.isArray(hexOrBytes))
     return hexOrBytes.map(parse);
-  return typeof hexOrBytes === "string" ? encodeBytes(hexOrBytes) : hexOrBytes;
+  return typeof hexOrBytes === "string" ? toBytes(hexOrBytes) : hexOrBytes;
 }
 function format(bytes, type = "bytes") {
   return type === "hex" ? bytesToHex(bytes) : bytes;
@@ -1264,11 +1268,11 @@ function bytesToRlp(bytes) {
 function encodeLength(length, offset) {
   if (length < 56)
     return [offset + length];
-  return [encodeBytes(length).length + offset + 55, ...encodeBytes(length)];
+  return [toBytes(length).length + offset + 55, ...toBytes(length)];
 }
 
-// src/utils/encoding/decodeHex.ts
-function decodeHex(hex, to) {
+// src/utils/encoding/fromHex.ts
+function fromHex(hex, to) {
   if (to === "number")
     return hexToNumber(hex);
   if (to === "bigint")
@@ -1305,8 +1309,8 @@ function hexToString(hex) {
   return new TextDecoder().decode(bytes);
 }
 
-// src/utils/encoding/decodeBytes.ts
-function decodeBytes(bytes, to) {
+// src/utils/encoding/fromBytes.ts
+function fromBytes(bytes, to) {
   if (to === "number")
     return bytesToNumber(bytes);
   if (to === "bigint")
@@ -1334,8 +1338,8 @@ function bytesToString(bytes) {
   return new TextDecoder().decode(bytes);
 }
 
-// src/utils/encoding/decodeRlp.ts
-function decodeRlp(value, to) {
+// src/utils/encoding/fromRlp.ts
+function fromRlp(value, to) {
   const bytes = parse2(value);
   const [data, consumed] = rlpToBytes(bytes);
   if (consumed < bytes.length)
@@ -1479,11 +1483,11 @@ function keccak256(value, to_) {
   const bytes = keccak_256(value);
   if (to === "bytes")
     return bytes;
-  return encodeHex(bytes);
+  return toHex(bytes);
 }
 
 // src/utils/hash/hashFunction.ts
-var hash = (value) => keccak256(encodeBytes(value));
+var hash = (value) => keccak256(toBytes(value));
 function hashFunction(def) {
   const name = extractFunctionName(def);
   const params = extractFunctionParams(def);
@@ -1521,36 +1525,32 @@ function getAddress(address) {
 }
 
 // src/utils/address/getContractAddress.ts
-function getContractAddress(opts) {
+function getContractAddress2(opts) {
   if (opts.opcode === "CREATE2")
     return getCreate2Address(opts);
   return getCreateAddress(opts);
 }
 function getCreateAddress(opts) {
-  const from = encodeBytes(getAddress(opts.from));
-  let nonce = encodeBytes(opts.nonce);
+  const from = toBytes(getAddress(opts.from));
+  let nonce = toBytes(opts.nonce);
   if (nonce[0] === 0)
     nonce = new Uint8Array([]);
   return getAddress(
-    `0x${keccak256(encodeRlp([from, nonce], "bytes")).slice(26)}`
+    `0x${keccak256(toRlp([from, nonce], "bytes")).slice(26)}`
   );
 }
 function getCreate2Address(opts) {
-  const from = encodeBytes(getAddress(opts.from));
-  const salt = pad(
-    isBytes(opts.salt) ? opts.salt : encodeBytes(opts.salt),
-    { size: 32 }
-  );
-  const bytecodeHash = encodeBytes(
+  const from = toBytes(getAddress(opts.from));
+  const salt = pad(isBytes(opts.salt) ? opts.salt : toBytes(opts.salt), {
+    size: 32
+  });
+  const bytecodeHash = toBytes(
     keccak256(
-      isBytes(opts.bytecode) ? opts.bytecode : encodeBytes(opts.bytecode)
+      isBytes(opts.bytecode) ? opts.bytecode : toBytes(opts.bytecode)
     )
   );
   return getAddress(
-    slice(
-      keccak256(concat([encodeBytes("0xff"), from, salt, bytecodeHash])),
-      12
-    )
+    slice(keccak256(concat([toBytes("0xff"), from, salt, bytecodeHash])), 12)
   );
 }
 
@@ -1619,7 +1619,7 @@ function prepareParam({
     return encodeNumber(value, { signed });
   }
   if (param.type.startsWith("bytes")) {
-    return encodeBytes2(value, { param });
+    return toBytes2(value, { param });
   }
   if (param.type === "string") {
     return encodeString(value);
@@ -1693,7 +1693,7 @@ function encodeArray(value, {
     encoded: concat(preparedParams.map(({ encoded }) => encoded))
   };
 }
-function encodeBytes2(value, { param }) {
+function toBytes2(value, { param }) {
   const [_, size_] = param.type.split("bytes");
   if (!size_) {
     const partsLength = Math.floor(size(value) / 32);
@@ -1807,7 +1807,7 @@ function decodeParam({
     return decodeString(data, { position });
   }
   if (param.type.startsWith("bytes")) {
-    return decodeBytes2(data, { param, position });
+    return fromBytes2(data, { param, position });
   }
   let value = slice(data, position, position + 32);
   if (param.type.startsWith("uint") || param.type.startsWith("int")) {
@@ -1880,7 +1880,7 @@ function decodeArray(data, {
 function decodeBool(value) {
   return { consumed: 32, value: hexToBool(value) };
 }
-function decodeBytes2(data, { param, position }) {
+function fromBytes2(data, { param, position }) {
   const [_, size2] = param.type.split("bytes");
   if (!size2) {
     const offset = hexToNumber(slice(data, position, position + 32));
@@ -2236,7 +2236,7 @@ function encodeArg({
   value
 }) {
   if (param.type === "string" || param.type === "bytes")
-    return keccak256(encodeBytes(value));
+    return keccak256(toBytes(value));
   if (param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
     throw new FilterTypeNotSupportedError(param.type);
   return encodeAbi({ params: [param], values: [value] });
@@ -2300,42 +2300,175 @@ function formatAbiItemWithArgs({
   ).join(", ")})`;
 }
 
+// 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/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,
+  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/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/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);
+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
@@ -2497,119 +2630,8 @@ var defineTransactionRequest = defineFormatter({
 });
 
 // src/utils/rpc.ts
-import fetch from "isomorphic-unfetch";
 import WebSocket from "isomorphic-ws";
 
-// 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/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/stringify.ts
 function stringify(value) {
   return JSON.stringify(
@@ -2622,12 +2644,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: {
@@ -2644,42 +2664,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_) {
@@ -2875,6 +2892,42 @@ export {
   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,
@@ -2888,26 +2941,26 @@ export {
   sliceHex,
   boolToHex,
   bytesToHex,
-  encodeHex,
+  toHex,
   numberToHex,
   stringToHex,
   boolToBytes,
-  encodeBytes,
+  toBytes,
   hexToBytes,
   numberToBytes,
   stringToBytes,
-  encodeRlp,
-  decodeHex,
+  toRlp,
+  fromHex,
   hexToBigInt,
   hexToBool,
   hexToNumber,
   hexToString,
-  decodeBytes,
+  fromBytes,
   bytesToBigint,
   bytesToBool,
   bytesToNumber,
   bytesToString,
-  decodeRlp,
+  fromRlp,
   extractFunctionParts,
   extractFunctionName,
   extractFunctionParams,
@@ -2918,7 +2971,7 @@ export {
   getFunctionSignature,
   checksumAddress,
   getAddress,
-  getContractAddress,
+  getContractAddress2 as getContractAddress,
   getCreateAddress,
   getCreate2Address,
   isAddress,
@@ -2937,6 +2990,10 @@ export {
   encodeFunctionData,
   encodeFunctionResult,
   formatAbiItemWithArgs,
+  getCache,
+  withCache,
+  wait,
+  isDeterministicError,
   buildRequest,
   defineChain,
   format3 as format,
@@ -2953,9 +3010,6 @@ export {
   defineTransactionReceipt,
   formatTransactionRequest,
   defineTransactionRequest,
-  getCache,
-  withCache,
-  wait,
   stringify,
   getSocket,
   rpc,
@@ -2967,42 +3021,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-KSAO4Y4Q.mjs.map
+//# sourceMappingURL=chunk-AKGXRZDN.mjs.map