@aksumite/react-providers 1.0.0

package/dist/index.mjs

@@ -0,0 +1,916 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+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 __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/ExtensionAccountsProvider/provider.tsx
+import { createContext as createContext2, useCallback as useCallback2, useEffect as useEffect2, useRef as useRef2, useState as useState2 } from "react";
+import {
+  setStateWithRef as setStateWithRef2,
+  localStorageOrDefault as localStorageOrDefault2
+} from "@aksumite/sdk-utils";
+import { useEffectIgnoreInitial } from "@mitratrade/react-hooks";
+
+// src/ExtensionsProvider/provider.tsx
+import {
+  createContext,
+  useCallback,
+  useEffect,
+  useRef,
+  useState
+} from "react";
+import { setStateWithRef } from "@aksumite/sdk-utils";
+import { Extensions, ExtensionsArray } from "@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
+import { withTimeout } from "@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 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
+import { jsx } from "react/jsx-runtime";
+var ExtensionsContext = createContext(
+  defaultExtensionsContext
+);
+var ExtensionsProvider = ({ children }) => {
+  const [checkingInjectedWeb3, setCheckingInjectedWeb3] = useState(true);
+  const checkingInjectedWeb3Ref = useRef(checkingInjectedWeb3);
+  const intervalInitialisedRef = useRef(false);
+  const [extensionsStatus, setExtensionsStatus] = useState({});
+  const extensionsStatusRef = useRef(extensionsStatus);
+  const injectCounter = useRef(0);
+  const setExtensionStatus = (id, status) => {
+    setStateWithRef(
+      __spreadProps(__spreadValues({}, extensionsStatusRef.current), {
+        [id]: status
+      }),
+      setExtensionsStatus,
+      extensionsStatusRef
+    );
+  };
+  const removeExtensionStatus = (id) => {
+    const newExtensionsStatus = __spreadValues({}, extensionsStatusRef.current);
+    delete newExtensionsStatus[id];
+    setStateWithRef(
+      newExtensionsStatus,
+      setExtensionsStatus,
+      extensionsStatusRef
+    );
+  };
+  const getExtensionsStatus = useCallback(
+    (snapAvailable) => {
+      const { injectedWeb3 } = window;
+      const newExtensionsStatus = __spreadValues({}, extensionsStatus);
+      if (snapAvailable)
+        newExtensionsStatus["metamask-polkadex-snap"] = "installed";
+      ExtensionsArray.forEach((e) => {
+        if (injectedWeb3[e.id] !== void 0) {
+          newExtensionsStatus[e.id] = "installed";
+        }
+      });
+      return newExtensionsStatus;
+    },
+    [extensionsStatus]
+  );
+  const handleSnapInjection = useCallback(
+    (hasInjectedWeb3) => __async(void 0, null, function* () {
+      const snapAvailable = yield polkadexSnapAvailable();
+      if (hasInjectedWeb3 || snapAvailable)
+        setStateWithRef(
+          getExtensionsStatus(snapAvailable),
+          setExtensionsStatus,
+          extensionsStatusRef
+        );
+      setStateWithRef(false, setCheckingInjectedWeb3, checkingInjectedWeb3Ref);
+    }),
+    [getExtensionsStatus]
+  );
+  const handleClearInterval = 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 = Extensions[id].features;
+    if (features === "*" || features.includes(feature))
+      return true;
+    else
+      return false;
+  };
+  const checkEveryMs = 500;
+  const totalChecks = 10;
+  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__ */ jsx(
+    ExtensionsContext.Provider,
+    {
+      value: {
+        extensionsStatus: extensionsStatusRef.current,
+        checkingInjectedWeb3: checkingInjectedWeb3Ref.current,
+        setExtensionStatus,
+        removeExtensionStatus,
+        extensionInstalled,
+        extensionCanConnect,
+        extensionHasFeature
+      },
+      children
+    }
+  );
+};
+
+// src/ExtensionsProvider/useExtensions.tsx
+import { useContext } from "react";
+var useExtensions = () => {
+  var _a;
+  const state = 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, useContext);
+    throw error;
+  }
+  return __spreadValues({}, state);
+};
+
+// src/ExtensionAccountsProvider/useImportExtension.tsx
+import Keyring2 from "@polkadot/keyring";
+import {
+  isValidAddress,
+  isValidEvmAddress
+} from "@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
+import Keyring from "@polkadot/keyring";
+import { localStorageOrDefault } from "@aksumite/sdk-utils";
+var getActiveAccountLocal = (network, ss58) => {
+  const keyring = new Keyring();
+  keyring.setSS58Format(ss58);
+  let account = localStorageOrDefault(`${network}_active_account`, null);
+  if (account !== null) {
+    account = keyring.addFromAddress(account).address;
+  }
+  return account;
+};
+var addToLocalExtensions = (id) => {
+  const localExtensions = 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 = 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 = 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 Keyring2();
+    keyring.setSS58Format(ss58);
+    newAccounts = newAccounts.filter(
+      ({ address }) => isValidAddress(address) || isValidEvmAddress(address)
+    );
+    newAccounts.forEach((account) => __async(void 0, null, function* () {
+      if (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
+import { jsx as jsx2 } from "react/jsx-runtime";
+var ExtensionAccountsContext = createContext2(
+  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] = useState2([]);
+  const extensionAccountsRef = useRef2(extensionAccounts);
+  const [extensionAccountsSynced, setExtensionAccountsSynced] = useState2("unsynced");
+  const [extensionsInitialised, setExtensionsInitialised] = useState2(
+    []
+  );
+  const extensionsInitialisedRef = useRef2(extensionsInitialised);
+  const unsubs = useRef2({});
+  const maybeSetActiveAccount = useCallback2(
+    (address) => {
+      if (typeof setActiveAccount === "function")
+        setActiveAccount(address != null ? address : null);
+    },
+    [setActiveAccount]
+  );
+  const maybeOnExtensionEnabled = (id) => {
+    if (typeof onExtensionEnabled === "function")
+      onExtensionEnabled(id);
+  };
+  const connectToAccount = useCallback2(
+    (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 = useCallback2(
+    (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 = useCallback2(
+    (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];
+            }
+          }
+        }
+        setStateWithRef2(
+          [...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 = useCallback2(() => __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)) {
+      setStateWithRef2(
+        [...extensionsInitialisedRef.current].concat(id),
+        setExtensionsInitialised,
+        extensionsInitialisedRef
+      );
+    }
+  };
+  const addExtensionAccount = (a) => {
+    setStateWithRef2(
+      [...extensionAccountsRef.current].concat(a),
+      setExtensionAccounts,
+      extensionAccountsRef
+    );
+  };
+  const addToUnsubscribe = (id, unsub) => {
+    unsubs.current[id] = unsub;
+  };
+  const unsubscribe = () => {
+    Object.values(unsubs.current).forEach((unsub) => {
+      unsub();
+    });
+  };
+  useEffect2(() => {
+    if (!checkingInjectedWeb3 && extensionAccountsSynced === "unsynced") {
+      unsubscribe();
+      setStateWithRef2([], setExtensionAccounts, extensionAccountsRef);
+      setStateWithRef2([], setExtensionsInitialised, extensionsInitialisedRef);
+      if (Object.keys(extensionsStatus).length) {
+        const localExtensions = localStorageOrDefault2(
+          `active_extensions`,
+          [],
+          true
+        );
+        if (Object.keys(extensionsStatus).length && localExtensions.length) {
+          setExtensionAccountsSynced("syncing");
+          connectActiveExtensions();
+        } else
+          setExtensionAccountsSynced("synced");
+      }
+    }
+    return () => unsubscribe();
+  }, [
+    extensionsStatus,
+    checkingInjectedWeb3,
+    extensionAccountsSynced,
+    connectActiveExtensions
+  ]);
+  useEffectIgnoreInitial(() => {
+    setExtensionAccountsSynced("unsynced");
+  }, [ss58]);
+  useEffectIgnoreInitial(() => {
+    if (!checkingInjectedWeb3 && extensionsInitialised.length === Object.keys(extensionsStatus).length) {
+      setExtensionAccountsSynced("synced");
+    }
+  }, [checkingInjectedWeb3, extensionsInitialised]);
+  return /* @__PURE__ */ jsx2(
+    ExtensionAccountsContext.Provider,
+    {
+      value: {
+        connectExtensionAccounts,
+        extensionAccountsSynced,
+        extensionAccounts: extensionAccountsRef.current
+      },
+      children
+    }
+  );
+};
+
+// src/ExtensionAccountsProvider/useExtensionAccounts.tsx
+import { useContext as useContext2 } from "react";
+var useExtensionAccounts = () => {
+  var _a;
+  const state = useContext2(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, useContext2);
+    throw error;
+  }
+  return __spreadValues({}, state);
+};
+
+// src/LocalAccountsProvider/provider.tsx
+import { createContext as createContext3, useEffect as useEffect3, useState as useState3 } from "react";
+import { BrowserWallet } from "@aksumite/local-wallets";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var wallet = new BrowserWallet();
+var LocalAccountsContext = createContext3(
+  {
+    wallet,
+    isReady: false,
+    localAddresses: []
+  }
+);
+var UserAccountsProvider = ({
+  children
+}) => {
+  const [localAddresses, setLocalAddresses] = useState3([]);
+  useEffect3(() => {
+    if (!wallet.isReady()) {
+      wallet.init().then(() => {
+        wallet.subscribeAddresses((addresses) => {
+          setLocalAddresses(addresses);
+        });
+      });
+    }
+  });
+  return /* @__PURE__ */ jsx3(
+    LocalAccountsContext.Provider,
+    {
+      value: {
+        wallet,
+        isReady: wallet.isReady(),
+        localAddresses
+      },
+      children
+    }
+  );
+};
+
+// src/LocalAccountsProvider/useLocalAccounts.tsx
+import { useContext as useContext3 } from "react";
+var useUserAccounts = () => {
+  var _a;
+  const state = useContext3(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, useContext3);
+    throw error;
+  }
+  return __spreadValues({}, state);
+};
+
+// src/TransactionManagerProvider/provider.tsx
+import {
+  createContext as createContext4,
+  useCallback as useCallback3,
+  useEffect as useEffect4,
+  useRef as useRef3,
+  useState as useState4
+} from "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
+import { jsx as jsx4 } from "react/jsx-runtime";
+var TransactionManagerProvider = ({
+  children
+}) => {
+  const [txQueue, _setTxQueue] = useState4([]);
+  const [txStatus, _setTxStatus] = useState4([]);
+  const stRef = useRef3(txStatus);
+  const txRef = useRef3(txQueue);
+  const setStQueue = useCallback3((st) => {
+    stRef.current = st;
+    _setTxStatus(st);
+  }, []);
+  const setTxQueue = useCallback3((txs) => {
+    txRef.current = txs;
+    _setTxQueue(txs);
+  }, []);
+  const updateTxStatus = useCallback3(
+    (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 = useCallback3(
+    (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 = useCallback3(
+    (hash) => {
+      return txStatus.find((s) => s.hash === hash);
+    },
+    [txStatus]
+  );
+  useEffect4(() => {
+    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__ */ jsx4(Provider, { value: { addToTxQueue, getTxStatus, txStatus }, children });
+};
+var Context = createContext4({
+  addToTxQueue: () => {
+  },
+  getTxStatus: () => void 0,
+  txStatus: []
+});
+var Provider = ({
+  value,
+  children
+}) => {
+  return /* @__PURE__ */ jsx4(Context.Provider, { value, children });
+};
+
+// src/TransactionManagerProvider/useTransactionManager.ts
+import { useContext as useContext4 } from "react";
+var useTransactionManager = () => {
+  var _a;
+  const state = useContext4(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, useContext4);
+    throw error;
+  }
+  return __spreadValues({}, state);
+};
+export {
+  Context,
+  ExtensionAccountsContext,
+  ExtensionAccountsProvider,
+  ExtensionsContext,
+  ExtensionsProvider,
+  LocalAccountsContext,
+  TransactionManagerProvider,
+  UserAccountsProvider,
+  defaultExtensionAccountsContext,
+  defaultExtensionsContext,
+  defaultHandleImportExtension,
+  useExtensionAccounts,
+  useExtensions,
+  useTransactionManager,
+  useUserAccounts
+};