@luno-kit/react 0.0.1

package/dist/index.cjs

@@ -0,0 +1,1177 @@
+'use strict';
+
+var React = require('react');
+var zustand = require('zustand');
+var core = require('@luno-kit/core');
+var dedot = require('dedot');
+var jsxRuntime = require('react/jsx-runtime');
+var reactQuery = require('@tanstack/react-query');
+var utils = require('dedot/utils');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+// src/types/state.ts
+var ConnectionStatus = /* @__PURE__ */ ((ConnectionStatus2) => {
+  ConnectionStatus2["Disconnected"] = "disconnected";
+  ConnectionStatus2["Connecting"] = "connecting";
+  ConnectionStatus2["Disconnecting"] = "disconnecting";
+  ConnectionStatus2["Connected"] = "connected";
+  return ConnectionStatus2;
+})(ConnectionStatus || {});
+
+// src/constants.ts
+var PERSIST_KEY = {
+  LAST_CONNECTOR_ID: "lastConnectorId",
+  LAST_CHAIN_ID: "lastChainId",
+  LAST_SELECTED_ACCOUNT_INFO: "lastSelectedAccountInfo"
+};
+var createApi = async ({
+  config,
+  chainId
+}) => {
+  const chainConfig = config.chains.find((c) => c.genesisHash === chainId);
+  const transportConfig = config.transports[chainId];
+  if (!chainConfig || !transportConfig) {
+    throw new Error(`Configuration missing for chainId: ${chainId}`);
+  }
+  const provider = core.wsProvider(transportConfig);
+  const apiOptions = {
+    provider,
+    cacheMetadata: config.cacheMetadata,
+    metadata: config.metadata,
+    scaledResponses: {
+      ...config.scaledResponses,
+      ...config.customTypes
+    },
+    runtimeApis: config.runtimeApis,
+    cacheStorage: config.cacheStorage
+  };
+  const newApi = new dedot.LegacyClient(apiOptions);
+  try {
+    await newApi.connect();
+    const actualGenesisHash = await newApi.rpc.chain_getBlockHash(0);
+    if (actualGenesisHash !== chainId) {
+      await newApi.disconnect();
+      throw new Error(
+        `Chain genesis hash mismatch. Expected: ${chainId}, Got: ${actualGenesisHash}. This might indicate connecting to the wrong network or incorrect chain configuration.`
+      );
+    }
+    return newApi;
+  } catch (error) {
+    throw new Error(`Failed to connect to ${chainConfig.name}: ${error?.message || error}`);
+  }
+};
+
+// src/utils/dispatchError.ts
+function getReadableDispatchError(api, dispatchError) {
+  if (dispatchError.type === "Module") {
+    try {
+      const errorMeta = api.registry.findErrorMeta(dispatchError);
+      if (errorMeta) {
+        const { docs, name, pallet, fields, fieldCodecs } = errorMeta;
+        return `[useSendTransaction]: ${pallet}.${name} error,  ${docs.join(" ")}`;
+      }
+      return `[useSendTransaction]: Module Error (index: ${dispatchError.value.index}, error: ${dispatchError.value.error})`;
+    } catch (e) {
+      const { value: { error, index } } = dispatchError;
+      return `[useSendTransaction]: Module Error (index: ${index}, error: ${error}) - Failed to decode: ${e instanceof Error ? e.message : "Unknown error"}`;
+    }
+  } else if (dispatchError.type === "Token") {
+    return `[useSendTransaction]: Token Error: ${dispatchError.value}`;
+  }
+  if ("value" in dispatchError) {
+    return `[useSendTransaction]: ${dispatchError.type} Error: ${dispatchError.value}`;
+  }
+  return `[useSendTransaction]: Error: ${dispatchError.type}`;
+}
+
+// src/store/createLunoStore.ts
+var activeConnectorUnsubscribeFunctions = [];
+var cleanupActiveConnectorListeners = () => {
+  activeConnectorUnsubscribeFunctions.forEach((unsub) => {
+    try {
+      unsub();
+    } catch (e) {
+      console.warn("[LunoStore] Error during listener cleanup:", e);
+    }
+  });
+  activeConnectorUnsubscribeFunctions = [];
+};
+var useLunoStore = zustand.create((set, get) => ({
+  config: void 0,
+  status: "disconnected" /* Disconnected */,
+  activeConnector: void 0,
+  accounts: [],
+  account: void 0,
+  currentChainId: void 0,
+  currentChain: void 0,
+  currentApi: void 0,
+  isApiReady: false,
+  apiError: null,
+  _setConfig: async (newConfig) => {
+    cleanupActiveConnectorListeners();
+    let storedChainId = null;
+    try {
+      storedChainId = await newConfig.storage.getItem(PERSIST_KEY.LAST_CHAIN_ID);
+    } catch (e) {
+      console.warn("[LunoStore] Failed to read stored chain ID from storage:", e);
+    }
+    const normalizedStoredChainId = storedChainId?.toLowerCase();
+    const initialChainId = normalizedStoredChainId && newConfig.chains.some((c) => c.genesisHash.toLowerCase() === normalizedStoredChainId) ? normalizedStoredChainId : newConfig.chains[0]?.genesisHash;
+    const initialChain = initialChainId ? newConfig.chains.find((c) => c.genesisHash.toLowerCase() === initialChainId) : void 0;
+    set({
+      config: newConfig,
+      status: "disconnected" /* Disconnected */,
+      activeConnector: void 0,
+      accounts: [],
+      currentChainId: initialChainId,
+      currentChain: initialChain
+    });
+  },
+  _setApi: (apiInstance) => {
+    set({ currentApi: apiInstance });
+  },
+  _setIsApiReady: (isReady) => {
+    set({ isApiReady: isReady });
+  },
+  setAccount: async (accountOrPublicKey) => {
+    if (!accountOrPublicKey) return;
+    const { accounts, config } = get();
+    const targetPublicKey = typeof accountOrPublicKey === "string" ? accountOrPublicKey.toLowerCase() : accountOrPublicKey.publicKey?.toLowerCase();
+    const nextAccount = accounts.find((acc) => acc.publicKey?.toLowerCase() === targetPublicKey);
+    if (!nextAccount) {
+      throw new Error("[LunoStore] setAccount: The provided account or address is not in the current accounts list. Ignored.");
+    }
+    set({ account: nextAccount });
+    if (config) {
+      try {
+        const accountInfo = {
+          publicKey: nextAccount.publicKey,
+          address: nextAccount.address,
+          name: nextAccount.name,
+          source: nextAccount.meta.source
+        };
+        await config.storage.setItem(PERSIST_KEY.LAST_SELECTED_ACCOUNT_INFO, JSON.stringify(accountInfo));
+        console.log(`[LunoStore] Persisted selected account: ${nextAccount.address}`);
+      } catch (e) {
+        console.error("[LunoStore] Failed to persist selected account:", e);
+      }
+    }
+  },
+  connect: async (connectorId, targetChainId) => {
+    const config = get().config;
+    if (!config) {
+      set({ status: "disconnected" /* Disconnected */ });
+      throw new Error("[LunoStore] LunoConfig has not been initialized. Cannot connect.");
+    }
+    const connector = config.connectors.find((c) => c.id === connectorId);
+    if (!connector) {
+      set({ status: "disconnected" /* Disconnected */ });
+      throw new Error(`[LunoStore] Connector with ID "${connectorId}" not found in LunoConfig.`);
+    }
+    set({ status: "connecting" /* Connecting */ });
+    const previouslyActiveConnector = get().activeConnector;
+    if (previouslyActiveConnector && previouslyActiveConnector.id !== connector.id) {
+      console.log(`[LunoStore] Switching connector. Cleaning up listeners for old connector: ${previouslyActiveConnector.id}`);
+      cleanupActiveConnectorListeners();
+    } else if (previouslyActiveConnector && previouslyActiveConnector.id === connector.id) {
+      console.log(`[LunoStore] Attempting to reconnect with the same connector: ${connector.id}. Cleaning up existing listeners.`);
+      cleanupActiveConnectorListeners();
+    }
+    try {
+      const handleAccountsChanged = async (newAccounts) => {
+        console.log(`[LunoStore] accountsChanged event from ${connector.name}:`, newAccounts);
+        newAccounts.forEach((acc) => {
+          if (!acc.publicKey) {
+            console.warn(`[LunoStore] Account ${acc.address} (from ${connector.name}) is missing publicKey.`);
+          }
+        });
+        let selectedAccount2 = newAccounts[0];
+        try {
+          const storedAccountJson = await config.storage.getItem(PERSIST_KEY.LAST_SELECTED_ACCOUNT_INFO);
+          if (storedAccountJson) {
+            const storedAccount = JSON.parse(storedAccountJson);
+            const restoredAccount = newAccounts.find(
+              (acc) => storedAccount.publicKey && acc.publicKey?.toLowerCase() === storedAccount.publicKey.toLowerCase() || core.isSameAddress(acc.address, storedAccount.address)
+            );
+            if (restoredAccount) {
+              selectedAccount2 = restoredAccount;
+            }
+          }
+        } catch (e) {
+          console.warn("[LunoStore] Failed to restore account during accountsChanged:", e);
+        }
+        set({ accounts: newAccounts, account: selectedAccount2 });
+      };
+      const handleDisconnect = () => {
+        console.log(`[LunoStore] disconnect event from ${connector.name}`);
+        if (get().activeConnector?.id === connector.id) {
+          cleanupActiveConnectorListeners();
+          try {
+            config.storage.removeItem(PERSIST_KEY.LAST_CONNECTOR_ID);
+            config.storage.removeItem(PERSIST_KEY.LAST_CHAIN_ID);
+            console.log("[LunoStore] Removed persisted connection info from storage due to disconnect event.");
+          } catch (e) {
+            console.error("[LunoStore] Failed to remove connection info from storage:", e);
+          }
+          set({
+            status: "disconnected" /* Disconnected */,
+            activeConnector: void 0,
+            accounts: []
+          });
+        } else {
+          console.warn(`[LunoStore] Received disconnect event from an inactive connector ${connector.name}. Ignored.`);
+        }
+      };
+      connector.on("accountsChanged", handleAccountsChanged);
+      activeConnectorUnsubscribeFunctions.push(() => connector.off("accountsChanged", handleAccountsChanged));
+      connector.on("disconnect", handleDisconnect);
+      activeConnectorUnsubscribeFunctions.push(() => connector.off("disconnect", handleDisconnect));
+      const chainIdToUse = targetChainId || get().currentChainId || config.chains[0]?.genesisHash;
+      const accountsFromWallet = await connector.connect(config.appName, config.chains, chainIdToUse);
+      accountsFromWallet.forEach((acc) => {
+        if (!acc.publicKey) {
+          console.error(`[LunoStore] CRITICAL WARNING: Account ${acc.address} from connector ${connector.name} was returned without a publicKey! SS58 address formatting will fail.`);
+        }
+      });
+      let selectedAccount = accountsFromWallet[0];
+      try {
+        const storedAccountJson = await config.storage.getItem(PERSIST_KEY.LAST_SELECTED_ACCOUNT_INFO);
+        if (storedAccountJson) {
+          const storedAccount = JSON.parse(storedAccountJson);
+          const restoredAccount = accountsFromWallet.find(
+            (acc) => storedAccount.publicKey && acc.publicKey?.toLowerCase() === storedAccount.publicKey.toLowerCase() || core.isSameAddress(acc.address, storedAccount.address)
+          );
+          if (restoredAccount) {
+            selectedAccount = restoredAccount;
+            console.log(`[LunoStore] Restored previously selected account: ${selectedAccount.address}`);
+          } else {
+            console.log("[LunoStore] Previously selected account not found in current accounts list, using first account");
+          }
+        }
+      } catch (e) {
+        console.warn("[LunoStore] Failed to restore selected account from storage:", e);
+      }
+      set({
+        activeConnector: connector,
+        accounts: accountsFromWallet,
+        status: "connected" /* Connected */,
+        account: selectedAccount
+      });
+      try {
+        config.storage.setItem(PERSIST_KEY.LAST_CONNECTOR_ID, connector.id);
+        console.log(`[LunoStore] Persisted connectorId: ${connector.id}`);
+      } catch (e) {
+        console.error("[LunoStore] Failed to persist connectorId to storage:", e);
+      }
+      const currentStoreChainId = get().currentChainId;
+      const chainIdToSet = targetChainId || currentStoreChainId || config.chains[0]?.genesisHash;
+      if (chainIdToSet) {
+        const newChain = config.chains.find((c) => c.genesisHash === chainIdToSet);
+        if (newChain) {
+          if (chainIdToSet !== currentStoreChainId || !get().currentApi) {
+            set({
+              currentChainId: chainIdToSet,
+              currentChain: newChain,
+              currentApi: void 0
+            });
+          }
+          try {
+            config.storage.setItem(PERSIST_KEY.LAST_CHAIN_ID, chainIdToSet);
+            console.log(`[LunoStore] Persisted chainId: ${chainIdToSet}`);
+          } catch (e) {
+            console.error("[LunoStore] Failed to persist chainId to storage:", e);
+          }
+        } else {
+          console.warn(`[LunoStore] After connection, target chain ID "${chainIdToSet}" was not found in config. Current chain state might not have changed. Not persisting chainId.`);
+        }
+      } else {
+        console.warn(`[LunoStore] Could not determine target chain ID after connection. Please check config.`);
+      }
+    } catch (err) {
+      cleanupActiveConnectorListeners();
+      set({
+        status: "disconnected" /* Disconnected */,
+        activeConnector: void 0,
+        accounts: []
+      });
+      throw new Error(`[LunoStore] Error connecting with ${connector.name}: ${err?.message || err}`);
+    }
+  },
+  disconnect: async () => {
+    const { activeConnector, status, config } = get();
+    if (!activeConnector || status === "disconnecting" /* Disconnecting */ || status === "disconnected" /* Disconnected */) {
+      console.log("[LunoStore] No active connector or already disconnected/disconnecting. Disconnect action aborted.");
+      return;
+    }
+    set({ status: "disconnecting" /* Disconnecting */ });
+    try {
+      await activeConnector.disconnect();
+      if (config) {
+        try {
+          console.log("[LunoStore] Attempting to remove persisted connection info due to user disconnect action...");
+          await config.storage.removeItem(PERSIST_KEY.LAST_CONNECTOR_ID);
+          await config.storage.removeItem(PERSIST_KEY.LAST_CHAIN_ID);
+          await config.storage.removeItem(PERSIST_KEY.LAST_SELECTED_ACCOUNT_INFO);
+          console.log("[LunoStore] Removed persisted connection info from storage.");
+        } catch (e) {
+          console.error("[LunoStore] Failed to remove connection info from storage during disconnect action:", e);
+        }
+      }
+      cleanupActiveConnectorListeners();
+      set({ status: "disconnected" /* Disconnected */, activeConnector: void 0, accounts: [], account: void 0 });
+      if (get().status !== "disconnected" /* Disconnected */) {
+        console.warn("[LunoStore] disconnect method called, but status is not yet 'disconnected' (event handler might be delayed or did not fire). Check connector events.");
+      }
+    } catch (err) {
+      set({ status: "connected" /* Connected */ });
+      throw new Error(`[LunoStore] Error disconnecting from ${activeConnector.name}: ${err?.message || err}`);
+    }
+  },
+  switchChain: async (newChainId) => {
+    const { config, currentChainId, currentApi, activeConnector, account, accounts } = get();
+    if (!config) {
+      throw new Error("[LunoStore] LunoConfig has not been initialized. Cannot switch chain.");
+    }
+    if (newChainId === currentChainId) {
+      console.log(`[LunoStore] Already on chain ${newChainId}. No switch needed.`);
+      return;
+    }
+    const newChain = config.chains.find((c) => c.genesisHash === newChainId);
+    if (!newChain) {
+      throw new Error(`[LunoStore] Chain with ID "${newChainId}" not found in LunoConfig.`);
+    }
+    const prevAccountIndex = accounts.findIndex((acc) => acc.address === account.address);
+    const newAccounts = await activeConnector.updateAccountsForChain(newChainId);
+    set({ accounts: newAccounts, account: newAccounts[prevAccountIndex] });
+    try {
+      try {
+        if (currentApi && currentApi.status === "connected") {
+          await currentApi.disconnect();
+        }
+      } catch (e) {
+        console.warn("[LunoStore] Failed to disconnect from previous chain:", e);
+      }
+      console.log(`[LunoStore] Attempting to switch chain to ${newChain.name} (ID: ${newChainId})`);
+      set({
+        currentChainId: newChainId,
+        currentChain: newChain,
+        currentApi: void 0,
+        isApiReady: false,
+        apiError: null
+      });
+      const newApi = await createApi({ config, chainId: newChainId });
+      set({
+        currentApi: newApi,
+        isApiReady: true
+      });
+      await config.storage.setItem(PERSIST_KEY.LAST_CHAIN_ID, newChainId);
+    } catch (e) {
+      set({
+        apiError: e,
+        isApiReady: false
+      });
+    }
+  },
+  _setApiError: (err) => {
+    set({ apiError: err });
+  }
+}));
+var LunoContext = React__default.default.createContext({});
+var useIsInitialized = () => {
+  const isInitialized = React.useRef(false);
+  return {
+    isInitialized: isInitialized.current,
+    markAsInitialized: () => {
+      isInitialized.current = true;
+    }
+  };
+};
+var LunoProvider = ({ config: configFromProps, children }) => {
+  const {
+    _setConfig,
+    _setApi,
+    _setIsApiReady,
+    _setApiError,
+    setAccount,
+    currentChainId,
+    config: configInStore,
+    currentApi,
+    connect,
+    status,
+    activeConnector,
+    accounts,
+    account,
+    currentChain,
+    isApiReady,
+    apiError,
+    disconnect,
+    switchChain
+  } = useLunoStore();
+  const { markAsInitialized, isInitialized } = useIsInitialized();
+  const clearApiState = React.useCallback(() => {
+    _setApi(void 0);
+    _setIsApiReady(false);
+  }, [_setApi, _setIsApiReady]);
+  React.useEffect(() => {
+    if (configFromProps) {
+      console.log("[LunoProvider] Setting config to store:", configFromProps);
+      _setConfig(configFromProps);
+    }
+  }, [configFromProps]);
+  React.useEffect(() => {
+    if (isInitialized) return;
+    if (!configFromProps || !currentChainId) {
+      if (currentApi && currentApi.status === "connected") {
+        currentApi.disconnect().catch(console.error);
+      }
+      clearApiState();
+      return;
+    }
+    const chainConfig = configFromProps.chains.find(
+      (c) => c.genesisHash === currentChainId
+    );
+    const transportConfig = configFromProps.transports[currentChainId];
+    if (!chainConfig || !transportConfig) {
+      if (currentApi && currentApi.status === "connected") {
+        currentApi.disconnect().catch(console.error);
+      }
+      clearApiState();
+      return;
+    }
+    if (currentApi && currentApi.status === "connected") {
+      console.log("[LunoProvider]: Disconnecting API from previous render cycle:", currentApi.runtimeVersion.specName);
+      currentApi.disconnect().catch((e) => console.error("[LunoProvider] Error disconnecting previous API:", e));
+    }
+    clearApiState();
+    createApi({ config: configFromProps, chainId: currentChainId }).then((api) => {
+      _setApi(api);
+      _setIsApiReady(true);
+    }).catch((e) => {
+      clearApiState();
+      _setApiError(e);
+    }).finally(() => markAsInitialized());
+  }, [configFromProps, currentChainId]);
+  React.useEffect(() => {
+    const performAutoConnect = async () => {
+      if (!configFromProps.autoConnect) {
+        console.log("[LunoProvider]: AutoConnect disabled or config not set.");
+        return;
+      }
+      if (!configFromProps.storage) {
+        console.warn("[LunoProvider]: AutoConnect Storage not available, cannot auto-connect.");
+        return;
+      }
+      try {
+        const lastConnectorId = await configFromProps.storage.getItem(PERSIST_KEY.LAST_CONNECTOR_ID);
+        const lastChainId = await configFromProps.storage.getItem(PERSIST_KEY.LAST_CHAIN_ID);
+        if (lastConnectorId && lastChainId) {
+          console.log(`[LunoProvider]: AutoConnect Found persisted session: Connector ID "${lastConnectorId}", Chain ID "${lastChainId}"`);
+          await connect(lastConnectorId, lastChainId);
+        } else {
+          console.log("[LunoProvider]: AutoConnect No persisted session found or missing data.");
+        }
+      } catch (error) {
+        console.error("[LunoProvider]: AutoConnect Error during auto-connect process:", error);
+      }
+    };
+    if (configFromProps) {
+      performAutoConnect();
+    }
+  }, [configFromProps]);
+  React.useEffect(() => {
+    if (isApiReady && currentApi && currentChain && currentChain.ss58Format !== void 0 && currentChain.ss58Format !== null) {
+      try {
+        const apiSs58 = currentApi.consts.system.ss58Prefix;
+        if (apiSs58 !== null && apiSs58 !== void 0 && apiSs58 !== currentChain.ss58Format) {
+          console.error(
+            `[LunoProvider]: SS58 Format Mismatch for chain "${currentChain.name}" (genesisHash: ${currentChain.genesisHash}):
+  - Configured SS58Format: ${currentChain.ss58Format}
+  - Node Runtime SS58Format: ${apiSs58}
+Please verify your Luno configuration for this chain to ensure correct address display and interaction.`
+          );
+        } else if (apiSs58 === null || apiSs58 === void 0) {
+          console.warn(
+            `[LunoProvider]: Could not determine SS58 format from the API for chain "${currentChain.name}". Cannot validate configured SS58Format (${currentChain.ss58Format}). The application will use the configured value.`
+          );
+        }
+      } catch (e) {
+        console.error(
+          `[LunoProvider]: Error retrieving SS58 format from API for chain "${currentChain.name}" while attempting validation:`,
+          e
+        );
+      }
+    }
+  }, [isApiReady, currentApi, currentChain]);
+  const contextValue = React.useMemo(() => ({
+    config: configInStore,
+    status,
+    activeConnector,
+    accounts,
+    account,
+    setAccount,
+    currentChainId,
+    currentChain,
+    currentApi,
+    isApiReady,
+    connect,
+    disconnect,
+    switchChain,
+    apiError
+  }), [
+    configInStore,
+    status,
+    activeConnector,
+    accounts,
+    account,
+    currentChainId,
+    currentChain,
+    currentApi,
+    isApiReady,
+    apiError,
+    connect,
+    disconnect,
+    switchChain,
+    setAccount
+  ]);
+  return /* @__PURE__ */ jsxRuntime.jsx(LunoContext.Provider, { value: contextValue, children });
+};
+var useLuno = () => {
+  const context = React.useContext(LunoContext);
+  if (context === void 0) {
+    throw new Error("useLuno must be used within a LunoProvider");
+  }
+  return context;
+};
+
+// src/hooks/useApi.ts
+var useApi = () => {
+  const { currentApi, isApiReady, apiError } = useLuno();
+  return {
+    api: currentApi,
+    isApiReady,
+    apiError
+  };
+};
+var useAccount = () => {
+  const { account, currentChain } = useLuno();
+  const formattedAccount = React.useMemo(() => {
+    if (!account) return;
+    if (!currentChain || currentChain?.ss58Format === void 0 || !account?.publicKey) return account;
+    try {
+      const newAddress = core.convertAddress(account.address, currentChain.ss58Format);
+      return {
+        ...account,
+        address: newAddress
+      };
+    } catch (error) {
+      console.error(`[useAccount]: Failed to re-format address for account with publicKey ${account.publicKey}:`, error);
+      return { ...account };
+    }
+  }, [account, currentChain, currentChain?.ss58Format]);
+  return {
+    account: formattedAccount,
+    address: formattedAccount?.address
+  };
+};
+var useAccounts = () => {
+  const { accounts, setAccount, currentChain } = useLuno();
+  const formattedAccounts = React.useMemo(() => {
+    if (!currentChain || currentChain?.ss58Format === void 0) return accounts ?? [];
+    return (accounts || []).map((acc) => {
+      if (!acc.publicKey) {
+        console.warn(`[useAccounts]: Account ${acc.name || acc.address} is missing publicKey. Cannot re-format address.`);
+        return acc;
+      }
+      try {
+        const newAddress = core.convertAddress(acc.address, currentChain.ss58Format);
+        return {
+          ...acc,
+          address: newAddress
+        };
+      } catch (error) {
+        console.error(`[useAccounts]: Failed to re-format address for account with publicKey ${acc.publicKey}:`, error);
+        return { ...acc };
+      }
+    });
+  }, [accounts, currentChain, currentChain?.ss58Format]);
+  return { accounts: formattedAccounts, selectAccount: setAccount };
+};
+
+// src/hooks/useActiveConnector.ts
+var useActiveConnector = () => {
+  const { activeConnector } = useLuno();
+  return activeConnector;
+};
+var defaultTransform = (data) => data;
+var useSubscription = ({ queryKey: userQueryKey, factory, params, options = {} }) => {
+  const [error, setError] = React.useState(void 0);
+  const { currentApi, isApiReady } = useLuno();
+  const queryClient = reactQuery.useQueryClient();
+  const {
+    enabled = true,
+    transform = defaultTransform,
+    defaultValue
+  } = options;
+  const isSubscribed = React.useRef(false);
+  const resolvedParams = React.useMemo(() => {
+    if (!params || !currentApi || !isApiReady) return void 0;
+    return typeof params === "function" ? [params(currentApi)] : params;
+  }, [params, currentApi, isApiReady]);
+  const queryKey = React.useMemo(() => [
+    userQueryKey,
+    resolvedParams,
+    currentApi?.genesisHash
+  ], [userQueryKey, resolvedParams, currentApi?.genesisHash]);
+  React.useEffect(() => {
+    if (!enabled || !factory || !currentApi || !resolvedParams || !isApiReady || isSubscribed.current) {
+      return;
+    }
+    let unsubscribe = null;
+    isSubscribed.current = true;
+    try {
+      const factoryFn = factory(currentApi);
+      const boundFn = typeof factoryFn === "function" ? factoryFn.bind(currentApi) : factoryFn;
+      const callback = (result) => {
+        try {
+          const transformedData = transform(result);
+          queryClient.setQueryData(queryKey, transformedData);
+          setError(void 0);
+        } catch (err) {
+          setError(new Error(`[useSubscription]: ${err}`));
+        }
+      };
+      boundFn(...resolvedParams, callback).then((unsub) => {
+        unsubscribe = unsub;
+      }).catch((err) => {
+        setError(new Error(`[useSubscription]: ${err}`));
+      });
+    } catch (err) {
+      setError(new Error(`[useSubscription]: ${err}`));
+    }
+    return () => {
+      if (unsubscribe) {
+        unsubscribe();
+        isSubscribed.current = false;
+        setError(void 0);
+      }
+    };
+  }, [JSON.stringify(queryKey), enabled, queryClient]);
+  const { data, isLoading } = reactQuery.useQuery({
+    queryKey,
+    queryFn: () => {
+      return Promise.resolve(defaultValue);
+    },
+    enabled: false,
+    initialData: defaultValue
+  });
+  return {
+    data,
+    error,
+    isLoading: !!(enabled && isApiReady && !data)
+  };
+};
+var DEFAULT_TOKEN_DECIMALS = 10;
+var transformBalance = (results, chainProperties) => {
+  const accountInfo = results[0];
+  const locks = results[1];
+  const free = accountInfo.data.free;
+  const reserved = accountInfo.data.reserved;
+  const frozen = accountInfo.data.frozen;
+  const total = BigInt(free) + BigInt(reserved);
+  const transferable = free > frozen ? BigInt(free) - BigInt(frozen) : 0n;
+  return {
+    free,
+    total,
+    reserved,
+    transferable,
+    formattedTransferable: core.formatBalance(transferable, chainProperties.tokenDecimals),
+    formattedTotal: core.formatBalance(total, chainProperties.tokenDecimals),
+    locks: locks.map((lock) => ({
+      id: lock.id,
+      amount: lock.amount,
+      reason: lock.reasons,
+      lockHuman: core.formatBalance(lock.amount, chainProperties.tokenDecimals)
+    }))
+  };
+};
+var useBalance = ({ address }) => {
+  const { currentApi, isApiReady, currentChain } = useLuno();
+  return useSubscription({
+    queryKey: "/native-balance",
+    factory: (api) => api.queryMulti,
+    params: (api) => [
+      { fn: api.query.system.account, args: [address] },
+      { fn: api.query.balances.locks, args: [address] }
+    ],
+    options: {
+      enabled: !!currentApi && isApiReady && !!address,
+      transform: (results) => {
+        const chainProperties = {
+          tokenDecimals: currentChain?.nativeCurrency?.decimals ?? DEFAULT_TOKEN_DECIMALS,
+          tokenSymbol: currentChain?.nativeCurrency?.symbol,
+          ss58Format: currentChain?.ss58Format
+        };
+        return transformBalance(results, chainProperties);
+      }
+    }
+  });
+};
+
+// src/hooks/useBlockNumber.ts
+var useBlockNumber = () => {
+  const { currentApi, isApiReady } = useLuno();
+  const transform = (blockNumberBn) => {
+    return blockNumberBn;
+  };
+  return useSubscription({
+    queryKey: "/block-number",
+    factory: (api) => api.query.system.number,
+    params: [],
+    options: {
+      enabled: !!currentApi && isApiReady,
+      transform
+    }
+  });
+};
+
+// src/hooks/useChain.ts
+var useChain = () => {
+  const { currentChain, currentChainId } = useLuno();
+  return {
+    chain: currentChain,
+    chainId: currentChainId
+  };
+};
+
+// src/hooks/useChains.ts
+var useChains = () => {
+  const { config } = useLuno();
+  return config?.chains ? [...config.chains] : [];
+};
+
+// src/hooks/useConnectors.ts
+var useConnectors = () => {
+  const { config } = useLuno();
+  return config?.connectors ? [...config.connectors] : [];
+};
+
+// src/hooks/useConfig.ts
+var useConfig = () => {
+  const { config } = useLuno();
+  return config;
+};
+function useLunoMutation(mutationFn, hookLevelOptions) {
+  const tanstackMutationHookOptions = {};
+  if (hookLevelOptions?.onSuccess) {
+    tanstackMutationHookOptions.onSuccess = hookLevelOptions.onSuccess;
+  }
+  if (hookLevelOptions?.onError) {
+    tanstackMutationHookOptions.onError = hookLevelOptions.onError;
+  }
+  if (hookLevelOptions?.onSettled) {
+    tanstackMutationHookOptions.onSettled = hookLevelOptions.onSettled;
+  }
+  const mutation = reactQuery.useMutation({
+    mutationFn,
+    retry: false,
+    throwOnError: false,
+    ...tanstackMutationHookOptions
+  });
+  return {
+    mutate: (variables, callTimeOptions) => {
+      mutation.mutate(variables, callTimeOptions);
+    },
+    mutateAsync: (variables, callTimeOptions) => {
+      return mutation.mutateAsync(variables, callTimeOptions);
+    },
+    data: mutation.data,
+    error: mutation.error,
+    isError: mutation.isError,
+    isIdle: mutation.isIdle,
+    isPending: mutation.isPending,
+    isSuccess: mutation.isSuccess,
+    reset: mutation.reset,
+    status: mutation.status,
+    variables: mutation.variables
+  };
+}
+
+// src/hooks/useConnect.ts
+var useConnect = (hookLevelConfig) => {
+  const { connect, config, activeConnector, status } = useLuno();
+  const connectFn = async (variables) => {
+    await connect(variables.connectorId, variables.targetChainId);
+  };
+  const mutationResult = useLunoMutation(connectFn, hookLevelConfig);
+  return {
+    connect: mutationResult.mutate,
+    connectAsync: mutationResult.mutateAsync,
+    connectors: config?.connectors ? [...config.connectors] : [],
+    activeConnector,
+    status,
+    data: mutationResult.data,
+    error: mutationResult.error,
+    isError: mutationResult.isError,
+    isIdle: mutationResult.isIdle,
+    isPending: mutationResult.isPending,
+    isSuccess: mutationResult.isSuccess,
+    reset: mutationResult.reset,
+    variables: mutationResult.variables
+  };
+};
+
+// src/hooks/useDisconnect.ts
+var useDisconnect = (hookLevelConfig) => {
+  const { disconnect, status } = useLuno();
+  const disconnectFn = async () => {
+    await disconnect();
+  };
+  const mutationResult = useLunoMutation(disconnectFn, hookLevelConfig);
+  return {
+    disconnect: (options) => mutationResult.mutate(void 0, options),
+    disconnectAsync: (options) => mutationResult.mutateAsync(void 0, options),
+    status,
+    data: mutationResult.data,
+    error: mutationResult.error,
+    isError: mutationResult.isError,
+    isIdle: mutationResult.isIdle,
+    isPending: mutationResult.isPending,
+    isSuccess: mutationResult.isSuccess,
+    reset: mutationResult.reset,
+    variables: mutationResult.variables
+  };
+};
+var useGenesisHash = () => {
+  const { currentApi, currentChainId, isApiReady } = useLuno();
+  const { data, isLoading, error } = reactQuery.useQuery({
+    queryKey: ["/genesis-hash", currentChainId],
+    queryFn: async () => {
+      return await currentApi.rpc.chain_getBlockHash(0);
+    },
+    enabled: !!currentApi && isApiReady && !!currentChainId,
+    staleTime: Infinity,
+    gcTime: Infinity,
+    retry: false
+  });
+  return { data, isLoading, error };
+};
+var useRuntimeVersion = () => {
+  const { currentApi, isApiReady, currentChainId } = useLuno();
+  return reactQuery.useQuery({
+    queryKey: ["luno", "runtimeVersion", currentChainId],
+    queryFn: async () => {
+      return await currentApi.getRuntimeVersion();
+    },
+    enabled: !!currentApi && isApiReady && !!currentChainId
+  });
+};
+function useSendTransaction(hookLevelConfig) {
+  const { account, activeConnector, currentApi, isApiReady } = useLuno();
+  const [txStatus, setTxStatus] = React.useState("idle");
+  const [detailedTxStatus, setDetailedTxStatus] = React.useState("idle");
+  const [txError, setTxError] = React.useState(null);
+  const sendTransactionFn = React.useCallback(async (variables) => {
+    if (!currentApi || !isApiReady) {
+      throw new Error("[useSendTransaction]: Polkadot API is not ready.");
+    }
+    if (!activeConnector) {
+      throw new Error("[useSendTransaction]: No active connector found.");
+    }
+    if (!account || !account.address || !account.meta?.source) {
+      throw new Error(
+        "[useSendTransaction]: No active account, address, or account metadata (source) found."
+      );
+    }
+    if (!variables.extrinsic) {
+      throw new Error("[useSendTransaction]: No extrinsic provided to send.");
+    }
+    const signer = await activeConnector.getSigner();
+    if (!signer) {
+      throw new Error("[useSendTransaction]: Could not retrieve signer from the injector.");
+    }
+    setTxStatus("signing");
+    setDetailedTxStatus("idle");
+    return new Promise((resolve, reject) => {
+      let unsubscribe;
+      variables.extrinsic.signAndSend(
+        account.address,
+        { signer },
+        ({ status, dispatchError, events, dispatchInfo, txHash, txIndex }) => {
+          const resolveAndUnsubscribe = (receipt) => {
+            if (unsubscribe) unsubscribe();
+            resolve(receipt);
+          };
+          const rejectAndUnsubscribe = (error) => {
+            if (unsubscribe) unsubscribe();
+            setTxError(error);
+            reject(error);
+          };
+          switch (status.type) {
+            case "Broadcasting":
+              setDetailedTxStatus("broadcasting");
+              break;
+            case "BestChainBlockIncluded":
+              setDetailedTxStatus("inBlock");
+              break;
+            case "Finalized":
+              setTxStatus("success");
+              setDetailedTxStatus("finalized");
+              if (dispatchError) {
+                resolveAndUnsubscribe({
+                  transactionHash: txHash,
+                  blockHash: status.value?.blockHash,
+                  blockNumber: status.value?.blockNumber,
+                  events,
+                  status: "failed",
+                  dispatchError,
+                  errorMessage: getReadableDispatchError(currentApi, dispatchError),
+                  dispatchInfo
+                });
+              } else {
+                resolveAndUnsubscribe({
+                  transactionHash: txHash,
+                  blockHash: status.value?.blockHash,
+                  blockNumber: status.value?.blockNumber,
+                  events,
+                  status: "success",
+                  dispatchError: void 0,
+                  errorMessage: void 0,
+                  dispatchInfo
+                });
+              }
+              break;
+            case "Invalid":
+              setTxStatus("failed");
+              setDetailedTxStatus("invalid");
+              rejectAndUnsubscribe(new Error(`Transaction invalid: ${txHash}`));
+              break;
+            case "Drop":
+              setTxStatus("failed");
+              setDetailedTxStatus("dropped");
+              rejectAndUnsubscribe(new Error(`Transaction dropped: ${txHash}`));
+              break;
+          }
+        }
+      ).then((unsub) => {
+        unsubscribe = unsub;
+      }).catch((error) => {
+        setTxStatus("failed");
+        console.error("[useSendTransaction]: Error in signAndSend promise:", error?.message || error);
+        setTxError(error);
+        reject(error);
+      });
+    });
+  }, [currentApi, isApiReady, activeConnector, account, setTxStatus, setDetailedTxStatus]);
+  const mutationResult = useLunoMutation(sendTransactionFn, hookLevelConfig);
+  return {
+    sendTransaction: mutationResult.mutate,
+    sendTransactionAsync: mutationResult.mutateAsync,
+    data: mutationResult.data,
+    error: txError || mutationResult.error,
+    isError: Boolean(txError) || mutationResult.isError,
+    isIdle: mutationResult.isIdle,
+    isPending: mutationResult.isPending,
+    isSuccess: mutationResult.isSuccess,
+    reset: mutationResult.reset,
+    status: mutationResult.status,
+    variables: mutationResult.variables,
+    txStatus,
+    detailedStatus: detailedTxStatus
+  };
+}
+function useSendTransactionHash(hookLevelConfig) {
+  const { account, activeConnector, currentApi, isApiReady } = useLuno();
+  const [txError, setTxError] = React.useState(null);
+  const sendTransactionFn = React.useCallback(async (variables) => {
+    if (!currentApi || !isApiReady) {
+      throw new Error("[useSendTransactionHash]: Polkadot API is not ready.");
+    }
+    if (!activeConnector) {
+      throw new Error("[useSendTransactionHash]: No active connector found.");
+    }
+    if (!account || !account.address || !account.meta?.source) {
+      throw new Error(
+        "[useSendTransactionHash]: No active account, address, or account metadata (source) found."
+      );
+    }
+    if (!variables.extrinsic) {
+      throw new Error("[useSendTransactionHash]: No extrinsic provided to send.");
+    }
+    const signer = await activeConnector.getSigner();
+    if (!signer) {
+      throw new Error("[useSendTransactionHash]: Could not retrieve signer from the injector.");
+    }
+    try {
+      const txHash = await variables.extrinsic.signAndSend(account.address, { signer }).catch((e) => {
+        throw e;
+      });
+      return txHash;
+    } catch (error) {
+      setTxError(error);
+      throw error;
+    }
+  }, [currentApi, isApiReady, activeConnector, account]);
+  const mutationResult = useLunoMutation(sendTransactionFn, hookLevelConfig);
+  return {
+    sendTransaction: mutationResult.mutate,
+    sendTransactionAsync: mutationResult.mutateAsync,
+    data: mutationResult.data,
+    error: txError || mutationResult.error,
+    isError: Boolean(txError) || mutationResult.isError,
+    isIdle: mutationResult.isIdle,
+    isPending: mutationResult.isPending,
+    isSuccess: mutationResult.isSuccess,
+    reset: mutationResult.reset,
+    status: mutationResult.status,
+    variables: mutationResult.variables
+  };
+}
+
+// src/hooks/useSignMessage.ts
+function useSignMessage(hookLevelConfig) {
+  const { activeConnector, account, accounts } = useLuno();
+  const mutationFn = async (variables) => {
+    if (!activeConnector) {
+      throw new Error("[useSignMessage]: No active connector found to sign the message.");
+    }
+    if (!account || !account.address || !account.meta?.source) {
+      throw new Error("[useSignMessage]: No address provided for signing.");
+    }
+    if (!accounts.some((acc) => acc.address === account.address)) {
+      throw new Error(`[useSignMessage]: Address ${account.address} is not managed by ${activeConnector.id}.`);
+    }
+    if (!variables.message) {
+      throw new Error("[useSignMessage]: No message provided for signing.");
+    }
+    const signatureString = await activeConnector.signMessage(
+      variables.message,
+      account.address
+    );
+    if (!signatureString) {
+      throw new Error(
+        "[useSignMessage]: Signature was not obtained. The user may have cancelled the request or the connector failed."
+      );
+    }
+    return {
+      signature: signatureString,
+      rawMessage: variables.message,
+      addressUsed: account.address
+    };
+  };
+  const mutationResult = useLunoMutation(mutationFn, hookLevelConfig);
+  return {
+    signMessage: mutationResult.mutate,
+    signMessageAsync: mutationResult.mutateAsync,
+    data: mutationResult.data,
+    error: mutationResult.error,
+    isError: mutationResult.isError,
+    isIdle: mutationResult.isIdle,
+    isPending: mutationResult.isPending,
+    isSuccess: mutationResult.isSuccess,
+    reset: mutationResult.reset,
+    status: mutationResult.status,
+    variables: mutationResult.variables
+  };
+}
+var DEFAULT_SS58_FORMAT = 42;
+var useSs58Format = () => {
+  const { currentApi, isApiReady, currentChain } = useLuno();
+  const configuredSs58Fallback = currentChain?.ss58Format !== void 0 ? currentChain.ss58Format : DEFAULT_SS58_FORMAT;
+  return React.useMemo(() => {
+    if (currentApi && isApiReady) {
+      let ss58 = void 0;
+      try {
+        const format = currentApi.consts.system.ss58Prefix;
+        ss58 = utils.isNumber(format) ? format : DEFAULT_SS58_FORMAT;
+      } catch (e) {
+        console.error("[useSs58Format] Error fetching chainSS58:", e);
+        ss58 = configuredSs58Fallback;
+      }
+      return { data: ss58, isLoading: false };
+    } else {
+      return { data: void 0, isLoading: true };
+    }
+  }, [currentApi, isApiReady, configuredSs58Fallback]);
+};
+
+// src/hooks/useStatus.ts
+var useStatus = () => {
+  const { status } = useLuno();
+  return status;
+};
+
+// src/hooks/useSwitchChain.ts
+var useSwitchChain = (hookLevelConfig) => {
+  const { switchChain: storeSwitchChain, config, currentChain, currentChainId } = useLuno();
+  const switchChainFn = async (variables) => {
+    await storeSwitchChain(variables.chainId);
+  };
+  const mutationResult = useLunoMutation(switchChainFn, hookLevelConfig);
+  return {
+    switchChain: mutationResult.mutate,
+    switchChainAsync: mutationResult.mutateAsync,
+    chains: config?.chains ? [...config.chains] : [],
+    currentChain,
+    currentChainId,
+    data: mutationResult.data,
+    error: mutationResult.error,
+    isError: mutationResult.isError,
+    isIdle: mutationResult.isIdle,
+    isPending: mutationResult.isPending,
+    isSuccess: mutationResult.isSuccess,
+    reset: mutationResult.reset,
+    variables: mutationResult.variables
+  };
+};
+var useSigner = () => {
+  const { activeConnector } = useLuno();
+  const { account } = useAccount();
+  const [signer, setSigner] = React.useState(void 0);
+  const [isLoading, setIsLoading] = React.useState(false);
+  React.useEffect(() => {
+    if (!activeConnector || !account?.address) {
+      setSigner(void 0);
+      setIsLoading(false);
+      return;
+    }
+    setIsLoading(true);
+    activeConnector.getSigner().then((signer2) => setSigner(signer2)).catch(() => setSigner(void 0)).finally(() => setIsLoading(false));
+  }, [activeConnector, account?.address]);
+  return { signer, isLoading };
+};
+
+exports.ConnectionStatus = ConnectionStatus;
+exports.LunoProvider = LunoProvider;
+exports.useAccount = useAccount;
+exports.useAccounts = useAccounts;
+exports.useActiveConnector = useActiveConnector;
+exports.useApi = useApi;
+exports.useBalance = useBalance;
+exports.useBlockNumber = useBlockNumber;
+exports.useChain = useChain;
+exports.useChains = useChains;
+exports.useConfig = useConfig;
+exports.useConnect = useConnect;
+exports.useConnectors = useConnectors;
+exports.useDisconnect = useDisconnect;
+exports.useGenesisHash = useGenesisHash;
+exports.useRuntimeVersion = useRuntimeVersion;
+exports.useSendTransaction = useSendTransaction;
+exports.useSendTransactionHash = useSendTransactionHash;
+exports.useSignMessage = useSignMessage;
+exports.useSigner = useSigner;
+exports.useSs58Format = useSs58Format;
+exports.useStatus = useStatus;
+exports.useSubscription = useSubscription;
+exports.useSwitchChain = useSwitchChain;
+Object.keys(core).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return core[k]; }
+  });
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map