@aksumite/react-providers 1.0.0

package/dist/index.js

@@ -0,0 +1,946 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Context: () => Context,
+  ExtensionAccountsContext: () => ExtensionAccountsContext,
+  ExtensionAccountsProvider: () => ExtensionAccountsProvider,
+  ExtensionsContext: () => ExtensionsContext,
+  ExtensionsProvider: () => ExtensionsProvider,
+  LocalAccountsContext: () => LocalAccountsContext,
+  TransactionManagerProvider: () => TransactionManagerProvider,
+  UserAccountsProvider: () => UserAccountsProvider,
+  defaultExtensionAccountsContext: () => defaultExtensionAccountsContext,
+  defaultExtensionsContext: () => defaultExtensionsContext,
+  defaultHandleImportExtension: () => defaultHandleImportExtension,
+  useExtensionAccounts: () => useExtensionAccounts,
+  useExtensions: () => useExtensions,
+  useTransactionManager: () => useTransactionManager,
+  useUserAccounts: () => useUserAccounts
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/ExtensionAccountsProvider/provider.tsx
+var import_react3 = require("react");
+var import_sdk_utils5 = require("@aksumite/sdk-utils");
+var import_react_hooks = require("@mitratrade/react-hooks");
+
+// src/ExtensionsProvider/provider.tsx
+var import_react = require("react");
+var import_sdk_utils2 = require("@aksumite/sdk-utils");
+var import_extensions = require("@polkadot-cloud/assets/extensions");
+
+// src/ExtensionsProvider/constants.ts
+var defaultExtensionsContext = {
+  checkingInjectedWeb3: false,
+  extensionsStatus: {},
+  setExtensionStatus: (id, status) => {
+  },
+  removeExtensionStatus: (id) => {
+  },
+  extensionInstalled: (id) => false,
+  extensionCanConnect: (id) => false,
+  extensionHasFeature: (id, feature) => false
+};
+
+// src/ExtensionsProvider/utils.ts
+var import_sdk_utils = require("@aksumite/sdk-utils");
+function hasMetaMask() {
+  if (!window.ethereum) {
+    return false;
+  }
+  return window.ethereum.isMetaMask;
+}
+var getWalletSnaps = () => __async(void 0, null, function* () {
+  var _a;
+  const ethRequest = !!((_a = window == null ? void 0 : window.ethereum) == null ? void 0 : _a.request);
+  if (ethRequest) {
+    const response = yield (0, import_sdk_utils.withTimeout)(
+      window.ethereum.request,
+      [
+        {
+          method: "wallet_getSnaps"
+        }
+      ],
+      200
+    );
+    return response;
+  }
+});
+var polkadexSnapAvailable = () => __async(void 0, null, function* () {
+  if (!hasMetaMask())
+    return false;
+  try {
+    yield getWalletSnaps();
+    return true;
+  } catch (e) {
+    return false;
+  }
+});
+
+// src/ExtensionsProvider/provider.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var ExtensionsContext = (0, import_react.createContext)(
+  defaultExtensionsContext
+);
+var ExtensionsProvider = ({ children }) => {
+  const [checkingInjectedWeb3, setCheckingInjectedWeb3] = (0, import_react.useState)(true);
+  const checkingInjectedWeb3Ref = (0, import_react.useRef)(checkingInjectedWeb3);
+  const intervalInitialisedRef = (0, import_react.useRef)(false);
+  const [extensionsStatus, setExtensionsStatus] = (0, import_react.useState)({});
+  const extensionsStatusRef = (0, import_react.useRef)(extensionsStatus);
+  const injectCounter = (0, import_react.useRef)(0);
+  const setExtensionStatus = (id, status) => {
+    (0, import_sdk_utils2.setStateWithRef)(
+      __spreadProps(__spreadValues({}, extensionsStatusRef.current), {
+        [id]: status
+      }),
+      setExtensionsStatus,
+      extensionsStatusRef
+    );
+  };
+  const removeExtensionStatus = (id) => {
+    const newExtensionsStatus = __spreadValues({}, extensionsStatusRef.current);
+    delete newExtensionsStatus[id];
+    (0, import_sdk_utils2.setStateWithRef)(
+      newExtensionsStatus,
+      setExtensionsStatus,
+      extensionsStatusRef
+    );
+  };
+  const getExtensionsStatus = (0, import_react.useCallback)(
+    (snapAvailable) => {
+      const { injectedWeb3 } = window;
+      const newExtensionsStatus = __spreadValues({}, extensionsStatus);
+      if (snapAvailable)
+        newExtensionsStatus["metamask-polkadex-snap"] = "installed";
+      import_extensions.ExtensionsArray.forEach((e) => {
+        if (injectedWeb3[e.id] !== void 0) {
+          newExtensionsStatus[e.id] = "installed";
+        }
+      });
+      return newExtensionsStatus;
+    },
+    [extensionsStatus]
+  );
+  const handleSnapInjection = (0, import_react.useCallback)(
+    (hasInjectedWeb3) => __async(void 0, null, function* () {
+      const snapAvailable = yield polkadexSnapAvailable();
+      if (hasInjectedWeb3 || snapAvailable)
+        (0, import_sdk_utils2.setStateWithRef)(
+          getExtensionsStatus(snapAvailable),
+          setExtensionsStatus,
+          extensionsStatusRef
+        );
+      (0, import_sdk_utils2.setStateWithRef)(false, setCheckingInjectedWeb3, checkingInjectedWeb3Ref);
+    }),
+    [getExtensionsStatus]
+  );
+  const handleClearInterval = (0, import_react.useCallback)(
+    (interval, hasInjectedWeb3) => {
+      clearInterval(interval);
+      handleSnapInjection(hasInjectedWeb3);
+    },
+    [handleSnapInjection]
+  );
+  const extensionInstalled = (id) => extensionsStatus[id] !== void 0;
+  const extensionCanConnect = (id) => extensionInstalled(id) && extensionsStatus[id] !== "connected";
+  const extensionHasFeature = (id, feature) => {
+    const features = import_extensions.Extensions[id].features;
+    if (features === "*" || features.includes(feature))
+      return true;
+    else
+      return false;
+  };
+  const checkEveryMs = 500;
+  const totalChecks = 10;
+  (0, import_react.useEffect)(() => {
+    let injectedWeb3Interval;
+    if (!intervalInitialisedRef.current) {
+      intervalInitialisedRef.current = true;
+      injectedWeb3Interval = setInterval(() => {
+        injectCounter.current++;
+        if (injectCounter.current === totalChecks)
+          handleClearInterval(injectedWeb3Interval, false);
+        else {
+          const injectedWeb3 = (window == null ? void 0 : window.injectedWeb3) || null;
+          if (injectedWeb3 !== null)
+            handleClearInterval(injectedWeb3Interval, true);
+        }
+      }, checkEveryMs);
+    }
+    return () => {
+      clearInterval(injectedWeb3Interval);
+    };
+  }, [handleClearInterval]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    ExtensionsContext.Provider,
+    {
+      value: {
+        extensionsStatus: extensionsStatusRef.current,
+        checkingInjectedWeb3: checkingInjectedWeb3Ref.current,
+        setExtensionStatus,
+        removeExtensionStatus,
+        extensionInstalled,
+        extensionCanConnect,
+        extensionHasFeature
+      },
+      children
+    }
+  );
+};
+
+// src/ExtensionsProvider/useExtensions.tsx
+var import_react2 = require("react");
+var useExtensions = () => {
+  var _a;
+  const state = (0, import_react2.useContext)(ExtensionsContext);
+  if (!ExtensionsContext) {
+    const error = new Error("ExtensionsContext context is undefined");
+    error.name = "ContextError";
+    (_a = Error == null ? void 0 : Error.captureStackTrace) == null ? void 0 : _a.call(Error, error, import_react2.useContext);
+    throw error;
+  }
+  return __spreadValues({}, state);
+};
+
+// src/ExtensionAccountsProvider/useImportExtension.tsx
+var import_keyring2 = __toESM(require("@polkadot/keyring"));
+var import_sdk_utils4 = require("@aksumite/sdk-utils");
+
+// src/ExtensionAccountsProvider/constants.ts
+var defaultExtensionAccountsContext = {
+  connectExtensionAccounts: () => Promise.resolve(false),
+  extensionAccountsSynced: "unsynced",
+  extensionAccounts: []
+};
+var defaultHandleImportExtension = {
+  newAccounts: [],
+  meta: {
+    removedActiveAccount: null
+  }
+};
+
+// src/ExtensionAccountsProvider/utils.ts
+var import_keyring = __toESM(require("@polkadot/keyring"));
+var import_sdk_utils3 = require("@aksumite/sdk-utils");
+var getActiveAccountLocal = (network, ss58) => {
+  const keyring = new import_keyring.default();
+  keyring.setSS58Format(ss58);
+  let account = (0, import_sdk_utils3.localStorageOrDefault)(`${network}_active_account`, null);
+  if (account !== null) {
+    account = keyring.addFromAddress(account).address;
+  }
+  return account;
+};
+var addToLocalExtensions = (id) => {
+  const localExtensions = (0, import_sdk_utils3.localStorageOrDefault)(
+    `active_extensions`,
+    [],
+    true
+  );
+  if (Array.isArray(localExtensions)) {
+    if (!localExtensions.includes(id)) {
+      localExtensions.push(id);
+      localStorage.setItem(
+        "active_extensions",
+        JSON.stringify(localExtensions)
+      );
+    }
+  }
+};
+var extensionIsLocal = (id) => {
+  const localExtensions = (0, import_sdk_utils3.localStorageOrDefault)(
+    `active_extensions`,
+    [],
+    true
+  );
+  let foundExtensionLocally = false;
+  if (Array.isArray(localExtensions)) {
+    foundExtensionLocally = localExtensions.find((l) => l === id) !== void 0;
+  }
+  return foundExtensionLocally;
+};
+var removeFromLocalExtensions = (id) => {
+  let localExtensions = (0, import_sdk_utils3.localStorageOrDefault)(
+    `active_extensions`,
+    [],
+    true
+  );
+  if (Array.isArray(localExtensions)) {
+    localExtensions = localExtensions.filter((l) => l !== id);
+    localStorage.setItem("active_extensions", JSON.stringify(localExtensions));
+  }
+};
+
+// src/ExtensionAccountsProvider/useImportExtension.tsx
+var useImportExtension = () => {
+  const { setExtensionStatus } = useExtensions();
+  const handleImportExtension = (id, currentAccounts, extension, newAccounts, forget, {
+    network,
+    ss58
+  }) => {
+    setExtensionStatus(id, "connected");
+    addToLocalExtensions(id);
+    if (newAccounts.length) {
+      return handleInjectedAccounts(
+        id,
+        currentAccounts,
+        extension,
+        newAccounts,
+        forget,
+        { network, ss58 }
+      );
+    }
+    return defaultHandleImportExtension;
+  };
+  const handleInjectedAccounts = (id, currentAccounts, extension, newAccounts, forget, {
+    ss58,
+    network
+  }) => {
+    var _a;
+    const keyring = new import_keyring2.default();
+    keyring.setSS58Format(ss58);
+    newAccounts = newAccounts.filter(
+      ({ address }) => (0, import_sdk_utils4.isValidAddress)(address) || (0, import_sdk_utils4.isValidEvmAddress)(address)
+    );
+    newAccounts.forEach((account) => __async(void 0, null, function* () {
+      if ((0, import_sdk_utils4.isValidEvmAddress)(account.address))
+        return account;
+      const { address } = keyring.addFromAddress(account.address);
+      account.address = address;
+      return account;
+    }));
+    const goneFromExtension = currentAccounts.filter((j) => j.source === id).filter((j) => !newAccounts.find((i) => i.address === j.address));
+    const activeGoneFromExtension = goneFromExtension.find(
+      ({ address }) => address === getActiveAccountLocal(network, ss58)
+    );
+    forget(goneFromExtension);
+    newAccounts = newAccounts.filter(
+      (i) => !currentAccounts.find(
+        (j) => j.address === i.address && j.source !== "external"
+      )
+    );
+    newAccounts = newAccounts.map(({ address, name, type }) => ({
+      address,
+      source: id,
+      name,
+      signer: extension.signer,
+      type
+    }));
+    return {
+      newAccounts,
+      meta: {
+        removedActiveAccount: (_a = activeGoneFromExtension == null ? void 0 : activeGoneFromExtension.address) != null ? _a : null
+      }
+    };
+  };
+  const getActiveExtensionAccount = ({
+    network,
+    ss58
+  }, accounts) => {
+    var _a;
+    return (_a = accounts.find(
+      ({ address }) => address === getActiveAccountLocal(network, ss58)
+    )) != null ? _a : null;
+  };
+  const connectActiveExtensionAccount = (account, callback) => {
+    if (account !== null) {
+      callback(account);
+    }
+  };
+  return {
+    handleImportExtension,
+    getActiveExtensionAccount,
+    connectActiveExtensionAccount
+  };
+};
+
+// src/ExtensionAccountsProvider/provider.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var ExtensionAccountsContext = (0, import_react3.createContext)(
+  defaultExtensionAccountsContext
+);
+var ExtensionAccountsProvider = ({
+  children,
+  network,
+  ss58,
+  dappName,
+  activeAccount,
+  setActiveAccount,
+  onExtensionEnabled
+}) => {
+  const {
+    handleImportExtension,
+    getActiveExtensionAccount,
+    connectActiveExtensionAccount
+  } = useImportExtension();
+  const {
+    extensionsStatus,
+    setExtensionStatus,
+    removeExtensionStatus,
+    checkingInjectedWeb3,
+    extensionHasFeature
+  } = useExtensions();
+  const [extensionAccounts, setExtensionAccounts] = (0, import_react3.useState)([]);
+  const extensionAccountsRef = (0, import_react3.useRef)(extensionAccounts);
+  const [extensionAccountsSynced, setExtensionAccountsSynced] = (0, import_react3.useState)("unsynced");
+  const [extensionsInitialised, setExtensionsInitialised] = (0, import_react3.useState)(
+    []
+  );
+  const extensionsInitialisedRef = (0, import_react3.useRef)(extensionsInitialised);
+  const unsubs = (0, import_react3.useRef)({});
+  const maybeSetActiveAccount = (0, import_react3.useCallback)(
+    (address) => {
+      if (typeof setActiveAccount === "function")
+        setActiveAccount(address != null ? address : null);
+    },
+    [setActiveAccount]
+  );
+  const maybeOnExtensionEnabled = (id) => {
+    if (typeof onExtensionEnabled === "function")
+      onExtensionEnabled(id);
+  };
+  const connectToAccount = (0, import_react3.useCallback)(
+    (account) => {
+      var _a;
+      maybeSetActiveAccount((_a = account == null ? void 0 : account.address) != null ? _a : null);
+    },
+    [maybeSetActiveAccount]
+  );
+  const connectExtensionAccounts = (id) => __async(void 0, null, function* () {
+    const extensionKeys = Object.keys(extensionsStatus);
+    const exists = extensionKeys.find((key) => key === id) || void 0;
+    if (!exists) {
+      updateInitialisedExtensions(
+        `unknown_extension_${extensionsInitialisedRef.current.length + 1}`
+      );
+    } else {
+      try {
+        const { enable } = window.injectedWeb3[id];
+        const extension = yield enable(dappName);
+        if (extension !== void 0) {
+          maybeOnExtensionEnabled(id);
+          const handleAccounts = (a) => {
+            const { newAccounts, meta } = handleImportExtension(
+              id,
+              extensionAccountsRef.current,
+              extension,
+              a,
+              forgetAccounts,
+              { network, ss58 }
+            );
+            if (!activeAccount) {
+              const activeExtensionAccount = getActiveExtensionAccount(
+                { network, ss58 },
+                newAccounts
+              );
+              if ((activeExtensionAccount == null ? void 0 : activeExtensionAccount.address) !== meta.removedActiveAccount && meta.removedActiveAccount !== null)
+                connectActiveExtensionAccount(
+                  activeExtensionAccount,
+                  connectToAccount
+                );
+            }
+            addExtensionAccount(newAccounts);
+            updateInitialisedExtensions(id);
+          };
+          if (!extensionHasFeature(id, "subscribeAccounts")) {
+            const accounts = yield extension.accounts.get();
+            handleAccounts(accounts);
+          } else {
+            const unsub = extension.accounts.subscribe((accounts) => {
+              if (accounts)
+                handleAccounts(accounts);
+            });
+            addToUnsubscribe(id, unsub);
+          }
+          return true;
+        }
+      } catch (err) {
+        handleExtensionError(id, String(err));
+      }
+    }
+    return false;
+  });
+  const handleExtensionError = (0, import_react3.useCallback)(
+    (id, err) => {
+      if (err.startsWith("Error")) {
+        removeFromLocalExtensions(id);
+        if (err.substring(0, 17) === "NotInstalledError") {
+          removeExtensionStatus(id);
+        } else {
+          setExtensionStatus(id, "not_authenticated");
+        }
+      }
+      updateInitialisedExtensions(id);
+    },
+    [removeExtensionStatus, setExtensionStatus]
+  );
+  const forgetAccounts = (0, import_react3.useCallback)(
+    (forget) => {
+      if (forget.length) {
+        for (const { address } of forget) {
+          if (extensionAccountsRef.current.find((a) => a.address === address)) {
+            const unsub = unsubs.current[address];
+            if (unsub) {
+              unsub();
+              delete unsubs.current[address];
+            }
+          }
+        }
+        (0, import_sdk_utils5.setStateWithRef)(
+          [...extensionAccountsRef.current].filter(
+            (a) => forget.find((s) => s.address === a.address) === void 0
+          ),
+          setExtensionAccounts,
+          extensionAccountsRef
+        );
+        if (activeAccount) {
+          if (forget.find(({ address }) => address === activeAccount) !== void 0)
+            maybeSetActiveAccount(null);
+        }
+      }
+    },
+    [activeAccount, maybeSetActiveAccount]
+  );
+  const connectActiveExtensions = (0, import_react3.useCallback)(() => __async(void 0, null, function* () {
+    var _a;
+    const extensionKeys = Object.keys(extensionsStatus);
+    if (!extensionKeys.length)
+      return;
+    const total = (_a = extensionKeys == null ? void 0 : extensionKeys.length) != null ? _a : 0;
+    let activeWalletAccount = null;
+    let i = 0;
+    for (const id of extensionKeys) {
+      i++;
+      const isLocal = extensionIsLocal(id != null ? id : "0");
+      if (!id || !isLocal) {
+        updateInitialisedExtensions(
+          id || `unknown_extension_${extensionsInitialisedRef.current.length + 1}`
+        );
+      } else {
+        try {
+          const { enable } = window.injectedWeb3[id];
+          const extension = yield enable(dappName);
+          if (extension !== void 0) {
+            const handleAccounts = (accounts) => {
+              const { newAccounts, meta } = handleImportExtension(
+                id,
+                extensionAccountsRef.current,
+                extension,
+                accounts,
+                forgetAccounts,
+                {
+                  network,
+                  ss58
+                }
+              );
+              if (newAccounts.length) {
+                if (!activeWalletAccount)
+                  activeWalletAccount = getActiveExtensionAccount(
+                    { network, ss58 },
+                    newAccounts
+                  );
+              }
+              if (i === total && !activeAccount) {
+                const activeAccountRemoved = (activeWalletAccount == null ? void 0 : activeWalletAccount.address) !== meta.removedActiveAccount && meta.removedActiveAccount !== null;
+                if (!activeAccountRemoved) {
+                  connectActiveExtensionAccount(
+                    activeWalletAccount,
+                    connectToAccount
+                  );
+                }
+              }
+              addExtensionAccount(newAccounts);
+              updateInitialisedExtensions(id);
+            };
+            if (!extensionHasFeature(id, "subscribeAccounts")) {
+              const accounts = yield extension.accounts.get();
+              handleAccounts(accounts);
+            } else {
+              const unsub = extension.accounts.subscribe((accounts) => {
+                if (accounts)
+                  handleAccounts(accounts);
+              });
+              addToUnsubscribe(id, unsub);
+            }
+          }
+        } catch (err) {
+          handleExtensionError(id, String(err));
+        }
+      }
+    }
+  }), [
+    activeAccount,
+    connectActiveExtensionAccount,
+    connectToAccount,
+    dappName,
+    extensionHasFeature,
+    extensionsStatus,
+    forgetAccounts,
+    getActiveExtensionAccount,
+    handleExtensionError,
+    handleImportExtension,
+    network,
+    ss58
+  ]);
+  const updateInitialisedExtensions = (id) => {
+    if (!extensionsInitialisedRef.current.includes(id)) {
+      (0, import_sdk_utils5.setStateWithRef)(
+        [...extensionsInitialisedRef.current].concat(id),
+        setExtensionsInitialised,
+        extensionsInitialisedRef
+      );
+    }
+  };
+  const addExtensionAccount = (a) => {
+    (0, import_sdk_utils5.setStateWithRef)(
+      [...extensionAccountsRef.current].concat(a),
+      setExtensionAccounts,
+      extensionAccountsRef
+    );
+  };
+  const addToUnsubscribe = (id, unsub) => {
+    unsubs.current[id] = unsub;
+  };
+  const unsubscribe = () => {
+    Object.values(unsubs.current).forEach((unsub) => {
+      unsub();
+    });
+  };
+  (0, import_react3.useEffect)(() => {
+    if (!checkingInjectedWeb3 && extensionAccountsSynced === "unsynced") {
+      unsubscribe();
+      (0, import_sdk_utils5.setStateWithRef)([], setExtensionAccounts, extensionAccountsRef);
+      (0, import_sdk_utils5.setStateWithRef)([], setExtensionsInitialised, extensionsInitialisedRef);
+      if (Object.keys(extensionsStatus).length) {
+        const localExtensions = (0, import_sdk_utils5.localStorageOrDefault)(
+          `active_extensions`,
+          [],
+          true
+        );
+        if (Object.keys(extensionsStatus).length && localExtensions.length) {
+          setExtensionAccountsSynced("syncing");
+          connectActiveExtensions();
+        } else
+          setExtensionAccountsSynced("synced");
+      }
+    }
+    return () => unsubscribe();
+  }, [
+    extensionsStatus,
+    checkingInjectedWeb3,
+    extensionAccountsSynced,
+    connectActiveExtensions
+  ]);
+  (0, import_react_hooks.useEffectIgnoreInitial)(() => {
+    setExtensionAccountsSynced("unsynced");
+  }, [ss58]);
+  (0, import_react_hooks.useEffectIgnoreInitial)(() => {
+    if (!checkingInjectedWeb3 && extensionsInitialised.length === Object.keys(extensionsStatus).length) {
+      setExtensionAccountsSynced("synced");
+    }
+  }, [checkingInjectedWeb3, extensionsInitialised]);
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+    ExtensionAccountsContext.Provider,
+    {
+      value: {
+        connectExtensionAccounts,
+        extensionAccountsSynced,
+        extensionAccounts: extensionAccountsRef.current
+      },
+      children
+    }
+  );
+};
+
+// src/ExtensionAccountsProvider/useExtensionAccounts.tsx
+var import_react4 = require("react");
+var useExtensionAccounts = () => {
+  var _a;
+  const state = (0, import_react4.useContext)(ExtensionAccountsContext);
+  if (!ExtensionAccountsContext) {
+    const error = new Error("ExtensionAccountsContext context is undefined");
+    error.name = "ContextError";
+    (_a = Error == null ? void 0 : Error.captureStackTrace) == null ? void 0 : _a.call(Error, error, import_react4.useContext);
+    throw error;
+  }
+  return __spreadValues({}, state);
+};
+
+// src/LocalAccountsProvider/provider.tsx
+var import_react5 = require("react");
+var import_local_wallets = require("@aksumite/local-wallets");
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var wallet = new import_local_wallets.BrowserWallet();
+var LocalAccountsContext = (0, import_react5.createContext)(
+  {
+    wallet,
+    isReady: false,
+    localAddresses: []
+  }
+);
+var UserAccountsProvider = ({
+  children
+}) => {
+  const [localAddresses, setLocalAddresses] = (0, import_react5.useState)([]);
+  (0, import_react5.useEffect)(() => {
+    if (!wallet.isReady()) {
+      wallet.init().then(() => {
+        wallet.subscribeAddresses((addresses) => {
+          setLocalAddresses(addresses);
+        });
+      });
+    }
+  });
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+    LocalAccountsContext.Provider,
+    {
+      value: {
+        wallet,
+        isReady: wallet.isReady(),
+        localAddresses
+      },
+      children
+    }
+  );
+};
+
+// src/LocalAccountsProvider/useLocalAccounts.tsx
+var import_react6 = require("react");
+var useUserAccounts = () => {
+  var _a;
+  const state = (0, import_react6.useContext)(LocalAccountsContext);
+  if (!LocalAccountsContext) {
+    const error = new Error("UserAccountsContext context is undefined");
+    error.name = "ContextError";
+    (_a = Error == null ? void 0 : Error.captureStackTrace) == null ? void 0 : _a.call(Error, error, import_react6.useContext);
+    throw error;
+  }
+  return __spreadValues({}, state);
+};
+
+// src/TransactionManagerProvider/provider.tsx
+var import_react7 = require("react");
+
+// src/TransactionManagerProvider/utils.ts
+var getStatus = (status) => {
+  const statusMap = {
+    isError: "error",
+    isBroadcast: "broadcasted",
+    isInBlock: "inblock",
+    isFinalized: "finalized"
+  };
+  for (const key of Object.keys(statusMap).reverse())
+    if (status[key])
+      return statusMap[key];
+  return "ongoing";
+};
+
+// src/TransactionManagerProvider/provider.tsx
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var TransactionManagerProvider = ({
+  children
+}) => {
+  const [txQueue, _setTxQueue] = (0, import_react7.useState)([]);
+  const [txStatus, _setTxStatus] = (0, import_react7.useState)([]);
+  const stRef = (0, import_react7.useRef)(txStatus);
+  const txRef = (0, import_react7.useRef)(txQueue);
+  const setStQueue = (0, import_react7.useCallback)((st) => {
+    stRef.current = st;
+    _setTxStatus(st);
+  }, []);
+  const setTxQueue = (0, import_react7.useCallback)((txs) => {
+    txRef.current = txs;
+    _setTxQueue(txs);
+  }, []);
+  const updateTxStatus = (0, import_react7.useCallback)(
+    (extrinsic, hash, result) => {
+      const updatedTxStatus = stRef.current.map((e) => {
+        if (e.hash === hash) {
+          if (e.error)
+            return e;
+          let error = "";
+          const { status, isError, dispatchError } = result;
+          const { isFinalized, isInBlock, isBroadcast } = status;
+          if (dispatchError) {
+            if (dispatchError.isModule) {
+              const { docs, name, section } = extrinsic.registry.findMetaError(
+                dispatchError.asModule
+              );
+              error = `${section}.${name}: ${docs.join(" ")}`;
+            } else {
+              error = dispatchError.toString();
+            }
+          }
+          const statusText = getStatus({
+            isError,
+            isBroadcast,
+            isInBlock,
+            isFinalized
+          });
+          return {
+            hash,
+            result: [...e.result, result],
+            status: statusText,
+            error
+          };
+        }
+        return e;
+      });
+      setStQueue(updatedTxStatus);
+      if (!result || result.isError || result.dispatchError || result.status.isFinalized) {
+        const validTxs = txRef.current.filter(
+          (t) => t.hash.toHex().toString() !== hash
+        );
+        setTxQueue(validTxs);
+      }
+    },
+    [setStQueue, setTxQueue]
+  );
+  const sendExtrinsicToChain = (0, import_react7.useCallback)(
+    (ext) => __async(void 0, null, function* () {
+      const hash = ext.hash.toHex().toString();
+      try {
+        yield ext.send((result) => updateTxStatus(ext, hash, result));
+      } catch (error) {
+        throw new Error(error);
+      }
+    }),
+    [updateTxStatus]
+  );
+  const addToTxQueue = (tx) => {
+    setTxQueue([...txQueue, tx]);
+    setStQueue([
+      ...txStatus,
+      {
+        hash: tx.hash.toHex().toString(),
+        result: [],
+        status: "ongoing"
+      }
+    ]);
+  };
+  const getTxStatus = (0, import_react7.useCallback)(
+    (hash) => {
+      return txStatus.find((s) => s.hash === hash);
+    },
+    [txStatus]
+  );
+  (0, import_react7.useEffect)(() => {
+    if (txQueue.length) {
+      const started = txStatus.filter((s) => !s.error).find((s) => s.status === "broadcasted" || s.status === "inblock");
+      if (!started)
+        sendExtrinsicToChain(txQueue[0]);
+    }
+  }, [txStatus, txQueue, sendExtrinsicToChain]);
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(Provider, { value: { addToTxQueue, getTxStatus, txStatus }, children });
+};
+var Context = (0, import_react7.createContext)({
+  addToTxQueue: () => {
+  },
+  getTxStatus: () => void 0,
+  txStatus: []
+});
+var Provider = ({
+  value,
+  children
+}) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(Context.Provider, { value, children });
+};
+
+// src/TransactionManagerProvider/useTransactionManager.ts
+var import_react8 = require("react");
+var useTransactionManager = () => {
+  var _a;
+  const state = (0, import_react8.useContext)(Context);
+  if (!state) {
+    const error = new Error("useTransactionManager context is undefined");
+    error.name = "ContextError";
+    (_a = Error == null ? void 0 : Error.captureStackTrace) == null ? void 0 : _a.call(Error, error, import_react8.useContext);
+    throw error;
+  }
+  return __spreadValues({}, state);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Context,
+  ExtensionAccountsContext,
+  ExtensionAccountsProvider,
+  ExtensionsContext,
+  ExtensionsProvider,
+  LocalAccountsContext,
+  TransactionManagerProvider,
+  UserAccountsProvider,
+  defaultExtensionAccountsContext,
+  defaultExtensionsContext,
+  defaultHandleImportExtension,
+  useExtensionAccounts,
+  useExtensions,
+  useTransactionManager,
+  useUserAccounts
+});