@dappworks/kit 0.5.28 → 0.5.30

package/dist/{chunk-KMJSNJHU.mjs → chunk-BHO5VKIO.mjs}

@@ -1,8 +1,8 @@
-import { AIem } from './chunk-6AX24IFY.mjs';
-import { DialogStore } from './chunk-DVNRHEKS.mjs';
-import { ToastPlugin } from './chunk-IMOLRP7I.mjs';
-import { RootStore, rootStore } from './chunk-XSGTWROT.mjs';
-import { helper } from './chunk-R4N52NI2.mjs';
+import { AIem } from './chunk-SQ7DRKMK.mjs';
+import { DialogStore } from './chunk-FWK5VZHE.mjs';
+import { ToastPlugin } from './chunk-7EL2RQI7.mjs';
+import { RootStore, rootStore } from './chunk-SA53R6TL.mjs';
+import { helper } from './chunk-7WJMHFRA.mjs';
 import { __commonJS, __require, __export, __toESM, __spreadProps, __spreadValues } from './chunk-VIK2VI34.mjs';
 import { observable, makeAutoObservable } from 'mobx';
 import BigNumber2 from 'bignumber.js';
@@ -6637,6 +6637,7 @@ var WalletConfigStore = class {
     var _a;
     return ObjectPool.get(`rainbowKitConfig-${(_a = this.supportedChains) == null ? void 0 : _a.map((i) => i.id).join("-")}`, () => {
       return getDefaultConfig({
+        pollingInterval: 2500,
         appName: this.appName,
         projectId: this.projectId,
         //@ts-ignore
@@ -6934,10 +6935,10 @@ __export(ethers_exports, {
   constants: () => lib_exports2,
   errors: () => ErrorCode,
   getDefaultProvider: () => getDefaultProvider,
-  logger: () => logger46,
+  logger: () => logger47,
   providers: () => lib_exports4,
   utils: () => utils_exports,
-  version: () => version26,
+  version: () => version27,
   wordlists: () => wordlists
 });
 
@@ -7010,10 +7011,10 @@ var ErrorCode;
 })(ErrorCode || (ErrorCode = {}));
 var HEX = "0123456789abcdef";
 var Logger = class _Logger {
-  constructor(version27) {
+  constructor(version28) {
     Object.defineProperty(this, "version", {
       enumerable: true,
-      value: version27,
+      value: version28,
       writable: false
     });
   }
@@ -7225,8 +7226,8 @@ var Logger = class _Logger {
     }
     _logLevel = level;
   }
-  static from(version27) {
-    return new _Logger(version27);
+  static from(version28) {
+    return new _Logger(version28);
   }
 };
 Logger.errors = ErrorCode;
@@ -17400,7 +17401,7 @@ function poll(func, options) {
 var import_bech32 = __toESM(require_bech32());
 
 // ../../node_modules/@ethersproject/providers/lib.esm/_version.js
-var version23 = "providers/5.7.2";
+var version23 = "providers/5.7.0";
 
 // ../../node_modules/@ethersproject/providers/lib.esm/formatter.js
 var logger29 = new Logger(version23);
@@ -18149,17 +18150,17 @@ var Resolver = class {
     }
     if (coinInfo.prefix != null) {
       const length = bytes[1];
-      let version27 = bytes[0];
-      if (version27 === 0) {
+      let version28 = bytes[0];
+      if (version28 === 0) {
         if (length !== 20 && length !== 32) {
-          version27 = -1;
+          version28 = -1;
         }
       } else {
-        version27 = -1;
+        version28 = -1;
       }
-      if (version27 >= 0 && bytes.length === 2 + length && length >= 1 && length <= 75) {
+      if (version28 >= 0 && bytes.length === 2 + length && length >= 1 && length <= 75) {
         const words2 = import_bech32.default.toWords(bytes.slice(2));
-        words2.unshift(version27);
+        words2.unshift(version28);
         return import_bech32.default.encode(coinInfo.prefix, words2);
       }
     }
@@ -19733,7 +19734,7 @@ function checkError(method, error, params) {
     message = error.responseText;
   }
   message = (message || "").toLowerCase();
-  if (message.match(/insufficient funds|base fee exceeds gas limit|InsufficientFunds/i)) {
+  if (message.match(/insufficient funds|base fee exceeds gas limit/i)) {
     logger31.throwError("insufficient funds for intrinsic transaction cost", Logger.errors.INSUFFICIENT_FUNDS, {
       error,
       method,
@@ -19761,7 +19762,7 @@ function checkError(method, error, params) {
       transaction
     });
   }
-  if (errorGas.indexOf(method) >= 0 && message.match(/gas required exceeds allowance|always failing transaction|execution reverted|revert/)) {
+  if (errorGas.indexOf(method) >= 0 && message.match(/gas required exceeds allowance|always failing transaction|execution reverted/)) {
     logger31.throwError("cannot estimate gas; transaction may fail or may require manual gas limit", Logger.errors.UNPREDICTABLE_GAS_LIMIT, {
       error,
       method,
@@ -19916,7 +19917,7 @@ var JsonRpcSigner = class extends Signer {
           logger31.throwError("user rejected signing", Logger.errors.ACTION_REJECTED, {
             action: "signMessage",
             from: address,
-            messageData: message
+            message: data
           });
         }
         throw error;
@@ -19934,7 +19935,7 @@ var JsonRpcSigner = class extends Signer {
           logger31.throwError("user rejected signing", Logger.errors.ACTION_REJECTED, {
             action: "_legacySignMessage",
             from: address,
-            messageData: message
+            message: data
           });
         }
         throw error;
@@ -19957,7 +19958,7 @@ var JsonRpcSigner = class extends Signer {
           logger31.throwError("user rejected signing", Logger.errors.ACTION_REJECTED, {
             action: "_signTypedData",
             from: address,
-            messageData: { domain: populated.domain, types, value: populated.value }
+            message: { domain: populated.domain, types, value: populated.value }
           });
         }
         throw error;
@@ -20214,7 +20215,7 @@ var JsonRpcProvider = class extends BaseProvider {
     const pendingFilter = this.send("eth_newPendingTransactionFilter", []);
     this._pendingFilter = pendingFilter;
     pendingFilter.then(function(filterId) {
-      function poll2() {
+      function poll3() {
         self2.send("eth_getFilterChanges", [filterId]).then(function(hashes) {
           if (self2._pendingFilter != pendingFilter) {
             return null;
@@ -20238,13 +20239,13 @@ var JsonRpcProvider = class extends BaseProvider {
             return;
           }
           setTimeout(function() {
-            poll2();
+            poll3();
           }, 0);
           return null;
         }).catch((error) => {
         });
       }
-      poll2();
+      poll3();
       return filterId;
     }).catch((error) => {
     });
@@ -20306,9 +20307,9 @@ try {
     throw new Error("inject please");
   }
 } catch (error) {
-  const logger47 = new Logger(version23);
+  const logger48 = new Logger(version23);
   WS = function() {
-    logger47.throwError("WebSockets not supported in this environment", Logger.errors.UNSUPPORTED_OPERATION, {
+    logger48.throwError("WebSockets not supported in this environment", Logger.errors.UNSUPPORTED_OPERATION, {
       operation: "new WebSocket()"
     });
   };
@@ -20710,8 +20711,17 @@ var AlchemyProvider = class extends UrlJsonRpcProvider {
       case "homestead":
         host = "eth-mainnet.alchemyapi.io/v2/";
         break;
+      case "ropsten":
+        host = "eth-ropsten.alchemyapi.io/v2/";
+        break;
+      case "rinkeby":
+        host = "eth-rinkeby.alchemyapi.io/v2/";
+        break;
       case "goerli":
-        host = "eth-goerli.g.alchemy.com/v2/";
+        host = "eth-goerli.alchemyapi.io/v2/";
+        break;
+      case "kovan":
+        host = "eth-kovan.alchemyapi.io/v2/";
         break;
       case "matic":
         host = "polygon-mainnet.g.alchemy.com/v2/";
@@ -20722,12 +20732,18 @@ var AlchemyProvider = class extends UrlJsonRpcProvider {
       case "arbitrum":
         host = "arb-mainnet.g.alchemy.com/v2/";
         break;
+      case "arbitrum-rinkeby":
+        host = "arb-rinkeby.g.alchemy.com/v2/";
+        break;
       case "arbitrum-goerli":
         host = "arb-goerli.g.alchemy.com/v2/";
         break;
       case "optimism":
         host = "opt-mainnet.g.alchemy.com/v2/";
         break;
+      case "optimism-kovan":
+        host = "opt-kovan.g.alchemy.com/v2/";
+        break;
       case "optimism-goerli":
         host = "opt-goerli.g.alchemy.com/v2/";
         break;
@@ -21030,22 +21046,18 @@ var EtherscanProvider = class extends BaseProvider {
     switch (this.network ? this.network.name : "invalid") {
       case "homestead":
         return "https://api.etherscan.io";
+      case "ropsten":
+        return "https://api-ropsten.etherscan.io";
+      case "rinkeby":
+        return "https://api-rinkeby.etherscan.io";
+      case "kovan":
+        return "https://api-kovan.etherscan.io";
       case "goerli":
         return "https://api-goerli.etherscan.io";
-      case "sepolia":
-        return "https://api-sepolia.etherscan.io";
-      case "matic":
-        return "https://api.polygonscan.com";
-      case "maticmum":
-        return "https://api-testnet.polygonscan.com";
-      case "arbitrum":
-        return "https://api.arbiscan.io";
-      case "arbitrum-goerli":
-        return "https://api-goerli.arbiscan.io";
       case "optimism":
         return "https://api-optimistic.etherscan.io";
-      case "optimism-goerli":
-        return "https://api-goerli-optimistic.etherscan.io";
+      case "optimism-kovan":
+        return "https://api-kovan-optimistic.etherscan.io";
     }
     return logger37.throwArgumentError("unsupported network", "network", this.network.name);
   }
@@ -21865,12 +21877,18 @@ var InfuraProvider = class extends UrlJsonRpcProvider {
       case "homestead":
         host = "mainnet.infura.io";
         break;
+      case "ropsten":
+        host = "ropsten.infura.io";
+        break;
+      case "rinkeby":
+        host = "rinkeby.infura.io";
+        break;
+      case "kovan":
+        host = "kovan.infura.io";
+        break;
       case "goerli":
         host = "goerli.infura.io";
         break;
-      case "sepolia":
-        host = "sepolia.infura.io";
-        break;
       case "matic":
         host = "polygon-mainnet.infura.io";
         break;
@@ -21880,14 +21898,14 @@ var InfuraProvider = class extends UrlJsonRpcProvider {
       case "optimism":
         host = "optimism-mainnet.infura.io";
         break;
-      case "optimism-goerli":
-        host = "optimism-goerli.infura.io";
+      case "optimism-kovan":
+        host = "optimism-kovan.infura.io";
         break;
       case "arbitrum":
         host = "arbitrum-mainnet.infura.io";
         break;
-      case "arbitrum-goerli":
-        host = "arbitrum-goerli.infura.io";
+      case "arbitrum-rinkeby":
+        host = "arbitrum-rinkeby.infura.io";
         break;
       default:
         logger39.throwError("unsupported network", Logger.errors.INVALID_ARGUMENT, {
@@ -22274,7 +22292,7 @@ __export(utils_exports, {
   Utf8ErrorFuncs: () => Utf8ErrorFuncs,
   Utf8ErrorReason: () => Utf8ErrorReason,
   _TypedDataEncoder: () => TypedDataEncoder,
-  _fetchData: () => _fetchData,
+  _fetchData: () => _fetchData2,
   _toEscapedUtf8String: () => _toEscapedUtf8String,
   accessListify: () => accessListify,
   arrayify: () => arrayify,
@@ -22293,7 +22311,7 @@ __export(utils_exports, {
   defineReadOnly: () => defineReadOnly,
   dnsEncode: () => dnsEncode,
   entropyToMnemonic: () => entropyToMnemonic,
-  fetchJson: () => fetchJson,
+  fetchJson: () => fetchJson2,
   formatBytes32String: () => formatBytes32String,
   formatEther: () => formatEther,
   formatUnits: () => formatUnits,
@@ -22329,7 +22347,7 @@ __export(utils_exports, {
   parseEther: () => parseEther,
   parseTransaction: () => parse,
   parseUnits: () => parseUnits,
-  poll: () => poll,
+  poll: () => poll2,
   randomBytes: () => randomBytes,
   recoverAddress: () => recoverAddress,
   recoverPublicKey: () => recoverPublicKey,
@@ -22517,11 +22535,473 @@ function parseEther(ether) {
   return parseUnits(ether, 18);
 }
 
+// ../../node_modules/ethers/node_modules/@ethersproject/web/lib.esm/_version.js
+var version26 = "web/5.7.0";
+
+// ../../node_modules/ethers/node_modules/@ethersproject/web/lib.esm/geturl.js
+var __awaiter17 = function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, [])).next());
+  });
+};
+function getUrl2(href, options) {
+  return __awaiter17(this, void 0, void 0, function* () {
+    if (options == null) {
+      options = {};
+    }
+    const request = {
+      method: options.method || "GET",
+      headers: options.headers || {},
+      body: options.body || void 0
+    };
+    if (options.skipFetchSetup !== true) {
+      request.mode = "cors";
+      request.cache = "no-cache";
+      request.credentials = "same-origin";
+      request.redirect = "follow";
+      request.referrer = "client";
+    }
+    if (options.fetchOptions != null) {
+      const opts = options.fetchOptions;
+      if (opts.mode) {
+        request.mode = opts.mode;
+      }
+      if (opts.cache) {
+        request.cache = opts.cache;
+      }
+      if (opts.credentials) {
+        request.credentials = opts.credentials;
+      }
+      if (opts.redirect) {
+        request.redirect = opts.redirect;
+      }
+      if (opts.referrer) {
+        request.referrer = opts.referrer;
+      }
+    }
+    const response = yield fetch(href, request);
+    const body = yield response.arrayBuffer();
+    const headers = {};
+    if (response.headers.forEach) {
+      response.headers.forEach((value, key2) => {
+        headers[key2.toLowerCase()] = value;
+      });
+    } else {
+      response.headers.keys().forEach((key2) => {
+        headers[key2.toLowerCase()] = response.headers.get(key2);
+      });
+    }
+    return {
+      headers,
+      statusCode: response.status,
+      statusMessage: response.statusText,
+      body: arrayify(new Uint8Array(body))
+    };
+  });
+}
+
+// ../../node_modules/ethers/node_modules/@ethersproject/web/lib.esm/index.js
+var __awaiter18 = function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, [])).next());
+  });
+};
+var logger46 = new Logger(version26);
+function staller2(duration) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, duration);
+  });
+}
+function bodyify2(value, type) {
+  if (value == null) {
+    return null;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (isBytesLike(value)) {
+    if (type && (type.split("/")[0] === "text" || type.split(";")[0].trim() === "application/json")) {
+      try {
+        return toUtf8String(value);
+      } catch (error) {
+      }
+    }
+    return hexlify(value);
+  }
+  return value;
+}
+function _fetchData2(connection, body, processFunc) {
+  const attemptLimit = typeof connection === "object" && connection.throttleLimit != null ? connection.throttleLimit : 12;
+  logger46.assertArgument(attemptLimit > 0 && attemptLimit % 1 === 0, "invalid connection throttle limit", "connection.throttleLimit", attemptLimit);
+  const throttleCallback = typeof connection === "object" ? connection.throttleCallback : null;
+  const throttleSlotInterval = typeof connection === "object" && typeof connection.throttleSlotInterval === "number" ? connection.throttleSlotInterval : 100;
+  logger46.assertArgument(throttleSlotInterval > 0 && throttleSlotInterval % 1 === 0, "invalid connection throttle slot interval", "connection.throttleSlotInterval", throttleSlotInterval);
+  const errorPassThrough = typeof connection === "object" ? !!connection.errorPassThrough : false;
+  const headers = {};
+  let url = null;
+  const options = {
+    method: "GET"
+  };
+  let allow304 = false;
+  let timeout = 2 * 60 * 1e3;
+  if (typeof connection === "string") {
+    url = connection;
+  } else if (typeof connection === "object") {
+    if (connection == null || connection.url == null) {
+      logger46.throwArgumentError("missing URL", "connection.url", connection);
+    }
+    url = connection.url;
+    if (typeof connection.timeout === "number" && connection.timeout > 0) {
+      timeout = connection.timeout;
+    }
+    if (connection.headers) {
+      for (const key2 in connection.headers) {
+        headers[key2.toLowerCase()] = { key: key2, value: String(connection.headers[key2]) };
+        if (["if-none-match", "if-modified-since"].indexOf(key2.toLowerCase()) >= 0) {
+          allow304 = true;
+        }
+      }
+    }
+    options.allowGzip = !!connection.allowGzip;
+    if (connection.user != null && connection.password != null) {
+      if (url.substring(0, 6) !== "https:" && connection.allowInsecureAuthentication !== true) {
+        logger46.throwError("basic authentication requires a secure https url", Logger.errors.INVALID_ARGUMENT, { argument: "url", url, user: connection.user, password: "[REDACTED]" });
+      }
+      const authorization = connection.user + ":" + connection.password;
+      headers["authorization"] = {
+        key: "Authorization",
+        value: "Basic " + encode2(toUtf8Bytes(authorization))
+      };
+    }
+    if (connection.skipFetchSetup != null) {
+      options.skipFetchSetup = !!connection.skipFetchSetup;
+    }
+    if (connection.fetchOptions != null) {
+      options.fetchOptions = shallowCopy(connection.fetchOptions);
+    }
+  }
+  const reData = new RegExp("^data:([a-z0-9-]+/[a-z0-9-]+);base64,(.*)$", "i");
+  const dataMatch = url ? url.match(reData) : null;
+  if (dataMatch) {
+    try {
+      const response = {
+        statusCode: 200,
+        statusMessage: "OK",
+        headers: { "content-type": dataMatch[1] },
+        body: decode2(dataMatch[2])
+      };
+      let result = response.body;
+      if (processFunc) {
+        result = processFunc(response.body, response);
+      }
+      return Promise.resolve(result);
+    } catch (error) {
+      logger46.throwError("processing response error", Logger.errors.SERVER_ERROR, {
+        body: bodyify2(dataMatch[1], dataMatch[2]),
+        error,
+        requestBody: null,
+        requestMethod: "GET",
+        url
+      });
+    }
+  }
+  if (body) {
+    options.method = "POST";
+    options.body = body;
+    if (headers["content-type"] == null) {
+      headers["content-type"] = { key: "Content-Type", value: "application/octet-stream" };
+    }
+    if (headers["content-length"] == null) {
+      headers["content-length"] = { key: "Content-Length", value: String(body.length) };
+    }
+  }
+  const flatHeaders = {};
+  Object.keys(headers).forEach((key2) => {
+    const header = headers[key2];
+    flatHeaders[header.key] = header.value;
+  });
+  options.headers = flatHeaders;
+  const runningTimeout = function() {
+    let timer2 = null;
+    const promise = new Promise(function(resolve, reject) {
+      if (timeout) {
+        timer2 = setTimeout(() => {
+          if (timer2 == null) {
+            return;
+          }
+          timer2 = null;
+          reject(logger46.makeError("timeout", Logger.errors.TIMEOUT, {
+            requestBody: bodyify2(options.body, flatHeaders["content-type"]),
+            requestMethod: options.method,
+            timeout,
+            url
+          }));
+        }, timeout);
+      }
+    });
+    const cancel = function() {
+      if (timer2 == null) {
+        return;
+      }
+      clearTimeout(timer2);
+      timer2 = null;
+    };
+    return { promise, cancel };
+  }();
+  const runningFetch = function() {
+    return __awaiter18(this, void 0, void 0, function* () {
+      for (let attempt = 0; attempt < attemptLimit; attempt++) {
+        let response = null;
+        try {
+          response = yield getUrl2(url, options);
+          if (attempt < attemptLimit) {
+            if (response.statusCode === 301 || response.statusCode === 302) {
+              const location = response.headers.location || "";
+              if (options.method === "GET" && location.match(/^https:/)) {
+                url = response.headers.location;
+                continue;
+              }
+            } else if (response.statusCode === 429) {
+              let tryAgain = true;
+              if (throttleCallback) {
+                tryAgain = yield throttleCallback(attempt, url);
+              }
+              if (tryAgain) {
+                let stall3 = 0;
+                const retryAfter = response.headers["retry-after"];
+                if (typeof retryAfter === "string" && retryAfter.match(/^[1-9][0-9]*$/)) {
+                  stall3 = parseInt(retryAfter) * 1e3;
+                } else {
+                  stall3 = throttleSlotInterval * parseInt(String(Math.random() * Math.pow(2, attempt)));
+                }
+                yield staller2(stall3);
+                continue;
+              }
+            }
+          }
+        } catch (error) {
+          response = error.response;
+          if (response == null) {
+            runningTimeout.cancel();
+            logger46.throwError("missing response", Logger.errors.SERVER_ERROR, {
+              requestBody: bodyify2(options.body, flatHeaders["content-type"]),
+              requestMethod: options.method,
+              serverError: error,
+              url
+            });
+          }
+        }
+        let body2 = response.body;
+        if (allow304 && response.statusCode === 304) {
+          body2 = null;
+        } else if (!errorPassThrough && (response.statusCode < 200 || response.statusCode >= 300)) {
+          runningTimeout.cancel();
+          logger46.throwError("bad response", Logger.errors.SERVER_ERROR, {
+            status: response.statusCode,
+            headers: response.headers,
+            body: bodyify2(body2, response.headers ? response.headers["content-type"] : null),
+            requestBody: bodyify2(options.body, flatHeaders["content-type"]),
+            requestMethod: options.method,
+            url
+          });
+        }
+        if (processFunc) {
+          try {
+            const result = yield processFunc(body2, response);
+            runningTimeout.cancel();
+            return result;
+          } catch (error) {
+            if (error.throttleRetry && attempt < attemptLimit) {
+              let tryAgain = true;
+              if (throttleCallback) {
+                tryAgain = yield throttleCallback(attempt, url);
+              }
+              if (tryAgain) {
+                const timeout2 = throttleSlotInterval * parseInt(String(Math.random() * Math.pow(2, attempt)));
+                yield staller2(timeout2);
+                continue;
+              }
+            }
+            runningTimeout.cancel();
+            logger46.throwError("processing response error", Logger.errors.SERVER_ERROR, {
+              body: bodyify2(body2, response.headers ? response.headers["content-type"] : null),
+              error,
+              requestBody: bodyify2(options.body, flatHeaders["content-type"]),
+              requestMethod: options.method,
+              url
+            });
+          }
+        }
+        runningTimeout.cancel();
+        return body2;
+      }
+      return logger46.throwError("failed response", Logger.errors.SERVER_ERROR, {
+        requestBody: bodyify2(options.body, flatHeaders["content-type"]),
+        requestMethod: options.method,
+        url
+      });
+    });
+  }();
+  return Promise.race([runningTimeout.promise, runningFetch]);
+}
+function fetchJson2(connection, json, processFunc) {
+  let processJsonFunc = (value, response) => {
+    let result = null;
+    if (value != null) {
+      try {
+        result = JSON.parse(toUtf8String(value));
+      } catch (error) {
+        logger46.throwError("invalid JSON", Logger.errors.SERVER_ERROR, {
+          body: value,
+          error
+        });
+      }
+    }
+    if (processFunc) {
+      result = processFunc(result, response);
+    }
+    return result;
+  };
+  let body = null;
+  if (json != null) {
+    body = toUtf8Bytes(json);
+    const updated = typeof connection === "string" ? { url: connection } : shallowCopy(connection);
+    if (updated.headers) {
+      const hasContentType = Object.keys(updated.headers).filter((k) => k.toLowerCase() === "content-type").length !== 0;
+      if (!hasContentType) {
+        updated.headers = shallowCopy(updated.headers);
+        updated.headers["content-type"] = "application/json";
+      }
+    } else {
+      updated.headers = { "content-type": "application/json" };
+    }
+    connection = updated;
+  }
+  return _fetchData2(connection, body, processJsonFunc);
+}
+function poll2(func, options) {
+  if (!options) {
+    options = {};
+  }
+  options = shallowCopy(options);
+  if (options.floor == null) {
+    options.floor = 0;
+  }
+  if (options.ceiling == null) {
+    options.ceiling = 1e4;
+  }
+  if (options.interval == null) {
+    options.interval = 250;
+  }
+  return new Promise(function(resolve, reject) {
+    let timer2 = null;
+    let done = false;
+    const cancel = () => {
+      if (done) {
+        return false;
+      }
+      done = true;
+      if (timer2) {
+        clearTimeout(timer2);
+      }
+      return true;
+    };
+    if (options.timeout) {
+      timer2 = setTimeout(() => {
+        if (cancel()) {
+          reject(new Error("timeout"));
+        }
+      }, options.timeout);
+    }
+    const retryLimit = options.retryLimit;
+    let attempt = 0;
+    function check() {
+      return func().then(function(result) {
+        if (result !== void 0) {
+          if (cancel()) {
+            resolve(result);
+          }
+        } else if (options.oncePoll) {
+          options.oncePoll.once("poll", check);
+        } else if (options.onceBlock) {
+          options.onceBlock.once("block", check);
+        } else if (!done) {
+          attempt++;
+          if (attempt > retryLimit) {
+            if (cancel()) {
+              reject(new Error("retry limit reached"));
+            }
+            return;
+          }
+          let timeout = options.interval * parseInt(String(Math.random() * Math.pow(2, attempt)));
+          if (timeout < options.floor) {
+            timeout = options.floor;
+          }
+          if (timeout > options.ceiling) {
+            timeout = options.ceiling;
+          }
+          setTimeout(check, timeout);
+        }
+        return null;
+      }, function(error) {
+        if (cancel()) {
+          reject(error);
+        }
+      });
+    }
+    check();
+  });
+}
+
 // ../../node_modules/ethers/lib.esm/_version.js
-var version26 = "ethers/5.7.2";
+var version27 = "ethers/5.7.0";
 
 // ../../node_modules/ethers/lib.esm/ethers.js
-var logger46 = new Logger(version26);
+var logger47 = new Logger(version27);
 
 // ../../node_modules/ethers/lib.esm/index.js
 try {
@@ -22773,7 +23253,8 @@ var WalletStore = class _WalletStore {
         this.walletClient = createWalletClient({
           account: this.account,
           chain: this.chain,
-          transport: custom(window.ethereum)
+          transport: custom(window.ethereum),
+          pollingInterval: 2500
         }).extend(publicActions);
       }
       console.log(this.walletClient, "this.walletClientxxx");
@@ -23199,4 +23680,4 @@ js-sha3/src/sha3.js:
 
 export { AppProvider, AutoMan, BigNumberInputState, BigNumberState, ConnectLedger, DisconnectLedger, ObjectPool, PromiseHook, StorageListState, StorageState, WalletConfigStore, WalletHistoryStore, WalletRpcStore, WalletStore };
 //# sourceMappingURL=out.js.map
-//# sourceMappingURL=chunk-KMJSNJHU.mjs.map
+//# sourceMappingURL=chunk-BHO5VKIO.mjs.map