@txnlab/use-wallet-react/dist/index.js

React library for integrating Algorand wallets into decentralized applications

// src/index.tsx
import { useStore } from "@tanstack/react-store";
import algosdk from "algosdk";
import * as React from "react";
export * from "@txnlab/use-wallet";
import { jsx } from "react/jsx-runtime";
var WalletContext = React.createContext(void 0);
var WalletProvider = ({ manager, children }) => {
  const [algodClient, setAlgodClient] = React.useState(manager.algodClient);
  React.useEffect(() => {
    manager.algodClient = algodClient;
  }, [algodClient, manager]);
  const resumedRef = React.useRef(false);
  React.useEffect(() => {
    if (!resumedRef.current) {
      manager.resumeSessions();
      resumedRef.current = true;
    }
  }, [manager]);
  return /* @__PURE__ */ jsx(WalletContext.Provider, { value: { manager, algodClient, setAlgodClient }, children });
};
var useNetwork = () => {
  const context = React.useContext(WalletContext);
  if (!context) {
    throw new Error("useNetwork must be used within the WalletProvider");
  }
  const { manager, setAlgodClient } = context;
  const activeNetwork = useStore(manager.store, (state) => state.activeNetwork);
  const setActiveNetwork = async (networkId) => {
    if (networkId === activeNetwork) {
      return;
    }
    if (!manager.networkConfig[networkId]) {
      throw new Error(`Network "${networkId}" not found in network configuration`);
    }
    console.info(`[React] Creating new Algodv2 client...`);
    const { algod } = manager.networkConfig[networkId];
    const { token = "", baseServer, port = "", headers = {} } = algod;
    const newClient = new algosdk.Algodv2(token, baseServer, port, headers);
    setAlgodClient(newClient);
    manager.store.setState((state) => ({
      ...state,
      activeNetwork: networkId
    }));
    console.info(`[React] \u2705 Active network set to ${networkId}.`);
  };
  const updateAlgodConfig = (networkId, config) => {
    manager.updateAlgodConfig(networkId, config);
    if (networkId === activeNetwork) {
      console.info(`[React] Creating new Algodv2 client...`);
      const { algod } = manager.networkConfig[networkId];
      const { token = "", baseServer, port = "", headers = {} } = algod;
      const newClient = new algosdk.Algodv2(token, baseServer, port, headers);
      setAlgodClient(newClient);
    }
  };
  const resetNetworkConfig = (networkId) => {
    manager.resetNetworkConfig(networkId);
    if (networkId === activeNetwork) {
      console.info(`[React] Creating new Algodv2 client...`);
      const { algod } = manager.networkConfig[networkId];
      const { token = "", baseServer, port = "", headers = {} } = algod;
      const newClient = new algosdk.Algodv2(token, baseServer, port, headers);
      setAlgodClient(newClient);
    }
  };
  return {
    activeNetwork,
    networkConfig: manager.networkConfig,
    activeNetworkConfig: manager.activeNetworkConfig,
    setActiveNetwork,
    updateAlgodConfig,
    resetNetworkConfig
  };
};
var useWallet = () => {
  const context = React.useContext(WalletContext);
  if (!context) {
    throw new Error("useWallet must be used within the WalletProvider");
  }
  const { manager, algodClient, setAlgodClient } = context;
  const managerStatus = useStore(manager.store, (state) => state.managerStatus);
  const isReady = managerStatus === "ready";
  const walletStateMap = useStore(manager.store, (state) => state.wallets);
  const activeWalletId = useStore(manager.store, (state) => state.activeWallet);
  const transformToWallet = React.useCallback(
    (wallet) => {
      const walletState = walletStateMap[wallet.id];
      return {
        id: wallet.id,
        metadata: wallet.metadata,
        accounts: walletState?.accounts ?? [],
        activeAccount: walletState?.activeAccount ?? null,
        isConnected: !!walletState,
        isActive: wallet.id === activeWalletId,
        canSignData: wallet.canSignData ?? false,
        connect: (args) => wallet.connect(args),
        disconnect: () => wallet.disconnect(),
        setActive: () => wallet.setActive(),
        setActiveAccount: (addr) => wallet.setActiveAccount(addr)
      };
    },
    [walletStateMap, activeWalletId]
  );
  const wallets = React.useMemo(() => {
    return [...manager.wallets.values()].map(transformToWallet);
  }, [manager, transformToWallet]);
  const activeBaseWallet = activeWalletId ? manager.getWallet(activeWalletId) || null : null;
  const activeWallet = React.useMemo(() => {
    return activeBaseWallet ? transformToWallet(activeBaseWallet) : null;
  }, [activeBaseWallet, transformToWallet]);
  const activeWalletAccounts = activeWallet?.accounts ?? null;
  const activeWalletAddresses = activeWalletAccounts?.map((account) => account.address) ?? null;
  const activeAccount = activeWallet?.activeAccount ?? null;
  const activeAddress = activeAccount?.address ?? null;
  const signTransactions = (txnGroup, indexesToSign) => {
    if (!activeBaseWallet) {
      throw new Error("No active wallet");
    }
    return activeBaseWallet.signTransactions(txnGroup, indexesToSign);
  };
  const transactionSigner = (txnGroup, indexesToSign) => {
    if (!activeBaseWallet) {
      throw new Error("No active wallet");
    }
    return activeBaseWallet.transactionSigner(txnGroup, indexesToSign);
  };
  const signData = (data, metadata) => {
    if (!activeBaseWallet) {
      throw new Error("No active wallet");
    }
    return activeBaseWallet.signData(data, metadata);
  };
  return {
    wallets,
    isReady,
    algodClient,
    setAlgodClient,
    activeWallet,
    activeWalletAccounts,
    activeWalletAddresses,
    activeAccount,
    activeAddress,
    signData,
    signTransactions,
    transactionSigner
  };
};
export {
  WalletProvider,
  useNetwork,
  useWallet
};
//# sourceMappingURL=index.js.map