@getpara/react-sdk 1.7.0 → 1.8.0

package/dist/modal/constants/defaults.js

@@ -0,0 +1,10 @@
+"use client";
+import "../../chunk-MMUBH76A.js";
+const DEFAULTS = {
+  LOGGIN_POLLING_DELAY_MS: 5e3,
+  POLLING_INTERVAL_MS: 2e3,
+  ANIMATION_DURATION: 0.15
+};
+export {
+  DEFAULTS
+};

package/dist/modal/constants/oAuthLogos.js

@@ -0,0 +1,24 @@
+"use client";
+import "../../chunk-MMUBH76A.js";
+const brandedOAuthLogos = {
+  GOOGLE: "googleBrand",
+  TWITTER: "twitter",
+  APPLE: "apple",
+  DISCORD: "discordBrand",
+  FACEBOOK: "facebookBrand",
+  FARCASTER: "farcasterBrand",
+  TELEGRAM: "telegramBrand"
+};
+const oAuthLogos = {
+  GOOGLE: "google",
+  TWITTER: "twitter",
+  APPLE: "apple",
+  DISCORD: "discord",
+  FACEBOOK: "facebook",
+  FARCASTER: "farcaster",
+  TELEGRAM: "telegram"
+};
+export {
+  brandedOAuthLogos,
+  oAuthLogos
+};

package/dist/modal/hooks/useActiveWallet.js

@@ -0,0 +1,15 @@
+"use client";
+import "../../chunk-MMUBH76A.js";
+import { useMemo } from "react";
+import { useWalletState } from "../../provider/index.js";
+import { useInternalClient } from "../../provider/hooks/utils/useInternalClient.js";
+function useActiveWallet() {
+  const client = useInternalClient();
+  const { selectedWallet } = useWalletState();
+  return useMemo(() => {
+    return client.findWallet(selectedWallet.id, selectedWallet.type, { forbidPregen: true });
+  }, [client, selectedWallet]);
+}
+export {
+  useActiveWallet
+};

package/dist/modal/hooks/useCreateAccount.js

@@ -0,0 +1,72 @@
+"use client";
+import {
+  __async
+} from "../../chunk-MMUBH76A.js";
+import { useInternalClient } from "../../provider/hooks/utils/useInternalClient.js";
+import { DEFAULTS } from "../constants/defaults.js";
+import { useModalStore } from "../stores/index.js";
+import { openPopup } from "../utils/openPopup.js";
+import { ModalStep } from "../utils/steps.js";
+import { useGoBack } from "./useGoBack.js";
+function useCreateAccount() {
+  const para = useInternalClient();
+  const goBack = useGoBack();
+  const refs = useModalStore((state) => state.refs);
+  const setStep = useModalStore((state) => state.setStep);
+  const webAuthURLForCreate = useModalStore((state) => state.webAuthURLForCreate);
+  const setWebAuthURLForCreate = useModalStore((state) => state.setWebAuthURLForCreate);
+  const setIFrameUrl = useModalStore((state) => state.setIFrameUrl);
+  const awaitWalletCreationTransition = () => __async(this, null, function* () {
+    var _a;
+    const isComplete = yield para.waitForAccountCreation({ popupWindow: refs.popupWindow.current });
+    window.clearTimeout((_a = refs.poll.current) == null ? void 0 : _a.timeout);
+    refs.poll.current = void 0;
+    refs.popupWindow.current = void 0;
+    if (isComplete) {
+      setWebAuthURLForCreate("");
+      setIFrameUrl("");
+      setStep(ModalStep.AWAITING_WALLET_CREATION);
+    } else if (refs.currentStep.current === ModalStep.AWAITING_BIOMETRIC_CREATION) {
+      goBack();
+    }
+  });
+  return {
+    withPasskey: () => {
+      var _a, _b;
+      if (((_a = refs.poll.current) == null ? void 0 : _a.action) === "createPasskey") {
+        return;
+      }
+      clearTimeout((_b = refs.poll.current) == null ? void 0 : _b.timeout);
+      refs.popupWindow.current = openPopup({
+        url: webAuthURLForCreate,
+        target: "ParaPasskey",
+        type: "CREATE_PASSKEY",
+        current: refs.popupWindow.current
+      });
+      refs.poll.current = {
+        action: "createPasskey",
+        timeout: window.setTimeout(awaitWalletCreationTransition, DEFAULTS.POLLING_INTERVAL_MS)
+      };
+      if (refs.currentStep.current !== ModalStep.AWAITING_BIOMETRIC_CREATION) {
+        setStep(ModalStep.AWAITING_BIOMETRIC_CREATION);
+      }
+    },
+    withPassword: () => {
+      var _a, _b;
+      if (((_a = refs.poll.current) == null ? void 0 : _a.action) === "createPassword") {
+        return;
+      }
+      clearTimeout((_b = refs.poll.current) == null ? void 0 : _b.timeout);
+      refs.poll.current = {
+        action: "createPassword",
+        timeout: window.setTimeout(awaitWalletCreationTransition, DEFAULTS.POLLING_INTERVAL_MS)
+      };
+      if (refs.currentStep.current !== ModalStep.PASSWORD_CREATION) {
+        setStep(ModalStep.PASSWORD_CREATION);
+      }
+    }
+  };
+}
+export {
+  useCreateAccount
+};

package/dist/modal/hooks/useEmbeddedExternalConnection.js

@@ -0,0 +1,54 @@
+"use client";
+import {
+  __async
+} from "../../chunk-MMUBH76A.js";
+import { WalletType } from "@getpara/web-sdk";
+import { useInternalClient } from "../../provider/hooks/utils/useInternalClient.js";
+import { useWalletState } from "../../provider/index.js";
+import { useExternalWalletProviderStore } from "../stores/externalWalletProvider/useExternalWalletProviderStore.js";
+const useEmbeddedExternalConnection = () => {
+  const client = useInternalClient();
+  const { setSelectedWallet } = useWalletState();
+  const connectParaEvmWallet = useExternalWalletProviderStore((state) => state.connectParaEvmWallet);
+  const EvmProvider = useExternalWalletProviderStore((state) => state.EvmProvider);
+  const evmContext = useExternalWalletProviderStore((state) => state.evmContext);
+  const connectParaCosmosWallet = useExternalWalletProviderStore((state) => state.connectParaCosmosWallet);
+  const CosmosProvider = useExternalWalletProviderStore((state) => state.CosmosProvider);
+  const cosmosContext = useExternalWalletProviderStore((state) => state.cosmosContext);
+  const connectEmbeddedToExternalConnectors = () => __async(void 0, null, function* () {
+    if (evmContext && EvmProvider && connectParaEvmWallet) {
+      try {
+        const { error } = yield connectParaEvmWallet();
+        if (error) {
+          console.warn("Failed to connect Para EVM wallet to Wagmi:", error);
+        } else {
+          const wallet = client.findWallet(void 0, void 0, { type: [WalletType.EVM] });
+          if (wallet) {
+            setSelectedWallet({ id: wallet.id, type: WalletType.EVM });
+          }
+        }
+      } catch (err) {
+        console.warn("Error calling connectParaEvmWallet:", err);
+      }
+    }
+    if (cosmosContext && CosmosProvider && connectParaCosmosWallet) {
+      try {
+        const { error } = yield connectParaCosmosWallet();
+        if (error) {
+          console.warn("Failed to connect Para Cosmos wallet to Graz:", error);
+        } else {
+          const wallet = client.findWallet(void 0, void 0, { type: [WalletType.COSMOS] });
+          if (wallet) {
+            setSelectedWallet({ id: wallet.id, type: WalletType.COSMOS });
+          }
+        }
+      } catch (err) {
+        console.warn("Error calling connectParaCosmosWallet:", err);
+      }
+    }
+  });
+  return connectEmbeddedToExternalConnectors;
+};
+export {
+  useEmbeddedExternalConnection
+};

package/dist/modal/hooks/useGoBack.js

@@ -0,0 +1,42 @@
+"use client";
+import "../../chunk-MMUBH76A.js";
+import { useInternalClient } from "../../provider/hooks/utils/useInternalClient.js";
+import { useExternalWallets } from "../providers/ExternalWalletContext.js";
+import { useModalStore } from "../stores/index.js";
+import { getAddFundsStep, ModalStep } from "../utils/steps.js";
+const useGoBack = () => {
+  const currentStep = useModalStore((state) => state.step);
+  const setStep = useModalStore((state) => state.setStep);
+  const accountAddFundTab = useModalStore((state) => state.accountAddFundTab);
+  const decrementStep = useModalStore((state) => state.decrementStep);
+  const resetState = useModalStore((state) => state.resetState);
+  const { setChainIdSwitchingTo, disconnectExternalWallet } = useExternalWallets();
+  const client = useInternalClient();
+  const goBack = () => {
+    if (currentStep === ModalStep.ADD_FUNDS_AWAITING) {
+      setStep(getAddFundsStep(accountAddFundTab));
+    } else {
+      decrementStep();
+    }
+    switch (currentStep) {
+      case ModalStep.AUTH_MAIN:
+      case ModalStep.AUTH_MORE:
+      case ModalStep.EX_WALLET_SELECTED:
+      case ModalStep.EXTERNAL_WALLET_VERIFICATION: {
+        resetState();
+        if (client.isExternalWalletAuth) {
+          disconnectExternalWallet();
+        }
+        break;
+      }
+      case ModalStep.CHAIN_SWITCH: {
+        setChainIdSwitchingTo();
+        break;
+      }
+    }
+  };
+  return goBack;
+};
+export {
+  useGoBack
+};

package/dist/modal/hooks/useSetLoginURLs.js

@@ -0,0 +1,49 @@
+"use client";
+import {
+  __async
+} from "../../chunk-MMUBH76A.js";
+import { AuthMethod, getPublicKeyHex } from "@getpara/web-sdk";
+import { useModalStore } from "../stores/index.js";
+import { useInternalClient } from "../../provider/hooks/utils/useInternalClient.js";
+const useSetLoginURLs = () => {
+  const para = useInternalClient();
+  const setWebAuthURLForLogin = useModalStore((state) => state.setWebAuthURLForLogin);
+  const setPasswordURLForLogin = useModalStore((state) => state.setPasswordUrlForLogin);
+  const setSupportedAuthMethods = useModalStore((state) => state.setSupportedAuthMethods);
+  return (_0) => __async(void 0, [_0], function* ({
+    supportedAuthMethods,
+    authType,
+    displayName,
+    pfpUrl
+  }) {
+    setSupportedAuthMethods(supportedAuthMethods);
+    const res = yield para.touchSession();
+    const webAuthUrlForLogin = (supportedAuthMethods == null ? void 0 : supportedAuthMethods.has(AuthMethod.PASSKEY)) ? yield para.shortenLoginLink(
+      yield para.getWebAuthURLForLogin({
+        sessionId: res.data.sessionId,
+        loginEncryptionPublicKey: getPublicKeyHex(para.loginEncryptionKeyPair),
+        partnerId: res.data.partnerId,
+        newDeviceSessionId: res.data.sessionLookupId,
+        newDeviceEncryptionKey: getPublicKeyHex(para.loginEncryptionKeyPair),
+        authType,
+        displayName,
+        pfpUrl
+      })
+    ) : void 0;
+    const passwordAuthUrlForLogin = (supportedAuthMethods == null ? void 0 : supportedAuthMethods.has(AuthMethod.PASSWORD)) ? yield para.shortenLoginLink(
+      yield para.getPasswordURLForLogin({
+        sessionId: res.data.sessionId,
+        loginEncryptionPublicKey: getPublicKeyHex(para.loginEncryptionKeyPair),
+        partnerId: res.data.partnerId,
+        authType,
+        displayName,
+        pfpUrl
+      })
+    ) : void 0;
+    setWebAuthURLForLogin(webAuthUrlForLogin);
+    setPasswordURLForLogin(passwordAuthUrlForLogin);
+  });
+};
+export {
+  useSetLoginURLs
+};

package/dist/modal/hooks/useWalletBalance.d.ts

@@ -0,0 +1,4 @@
+export declare function useWalletBalance(): {
+    balance: string;
+    isLoading: boolean;
+};

package/dist/modal/hooks/useWalletBalance.js

@@ -0,0 +1,47 @@
+"use client";
+import {
+  __async
+} from "../../chunk-MMUBH76A.js";
+import { useEffect, useState } from "react";
+import { useInternalClient } from "../../provider/hooks/utils/useInternalClient.js";
+import { useActiveWallet } from "./useActiveWallet.js";
+import { WalletType } from "@getpara/web-sdk";
+import { useExternalWallets } from "../providers/ExternalWalletContext.js";
+import { useStore } from "../../provider/stores/useStore.js";
+function useWalletBalance() {
+  const client = useInternalClient();
+  const wallet = useActiveWallet();
+  const [balance, setBalance] = useState();
+  const [isLoading, setIsLoading] = useState(false);
+  const { balance: externalWalletBalance } = useExternalWallets();
+  const rpcUrl = useStore((state) => state.rpcUrl);
+  useEffect(() => {
+    const loadBalance = () => __async(this, null, function* () {
+      const skipGetBalance = !wallet || [WalletType.COSMOS, WalletType.SOLANA].includes(wallet.type);
+      if (skipGetBalance) {
+        setBalance(void 0);
+        return;
+      }
+      setIsLoading(true);
+      if (wallet.isExternal) {
+        setBalance(externalWalletBalance);
+      } else {
+        try {
+          const balance2 = yield client.getWalletBalance({
+            walletId: wallet.id,
+            rpcUrl
+          });
+          setBalance(balance2);
+        } catch (err) {
+          console.error("Error fetching wallet balance: ", err);
+        }
+      }
+      setIsLoading(false);
+    });
+    loadBalance();
+  }, [wallet == null ? void 0 : wallet.id, wallet == null ? void 0 : wallet.type, wallet == null ? void 0 : wallet.isExternal, externalWalletBalance]);
+  return { balance, isLoading };
+}
+export {
+  useWalletBalance
+};

package/dist/modal/index.js

@@ -0,0 +1,33 @@
+"use client";
+import "../chunk-MMUBH76A.js";
+export * from "./ParaModal.js";
+import { ModalStep } from "./utils/steps.js";
+import { AuthLayout } from "./types/modalProps.js";
+export * from "./utils/openPopup.js";
+import {
+  ON_RAMP_PROVIDERS,
+  ON_RAMP_ASSETS,
+  NETWORKS,
+  getAssetIcon,
+  getAssetName,
+  getNetworkIcon,
+  getNetworkName
+} from "./constants/constants.js";
+import { SaveRecoverySecret } from "./components/RecoverySecretStep/RecoverySecretStep.js";
+export * from "./utils/validateOnRampConfig.js";
+export * from "./types/externalWallets.js";
+import { useExternalWalletProviderStore } from "./stores/externalWalletProvider/useExternalWalletProviderStore.js";
+export * from "./types/commonTypes.js";
+export {
+  AuthLayout,
+  ModalStep,
+  NETWORKS,
+  ON_RAMP_ASSETS,
+  ON_RAMP_PROVIDERS,
+  SaveRecoverySecret,
+  getAssetIcon,
+  getAssetName,
+  getNetworkIcon,
+  getNetworkName,
+  useExternalWalletProviderStore
+};

package/dist/modal/providers/CosmosExternalWalletContextStub.js

@@ -0,0 +1,38 @@
+"use client";
+import "../../chunk-MMUBH76A.js";
+import { jsx } from "react/jsx-runtime";
+import { createContext, useMemo } from "react";
+const defaultCosmosExternalWallet = {
+  wallets: [],
+  chains: [],
+  chainId: void 0,
+  disconnect: () => Promise.resolve(),
+  switchChain: () => Promise.resolve({}),
+  signMessage: () => Promise.resolve({}),
+  signVerificationMessage: () => Promise.resolve({})
+};
+const CosmosExternalWalletContext = createContext(defaultCosmosExternalWallet);
+function CosmosExternalWalletProvider({ children }) {
+  const wallets = [];
+  const chains = [];
+  const chainId = void 0;
+  const disconnect = () => Promise.resolve();
+  const switchChain = () => Promise.resolve({});
+  const signMessage = () => Promise.resolve({});
+  const signVerificationMessage = () => Promise.resolve({});
+  return /* @__PURE__ */ jsx(
+    CosmosExternalWalletContext.Provider,
+    {
+      value: useMemo(
+        () => ({ wallets, chains, chainId, disconnect, switchChain, signMessage, signVerificationMessage }),
+        [wallets, chains, chainId, disconnect, switchChain, signMessage, signVerificationMessage]
+      ),
+      children
+    }
+  );
+}
+export {
+  CosmosExternalWalletContext,
+  CosmosExternalWalletProvider,
+  defaultCosmosExternalWallet
+};

package/dist/modal/providers/EvmExternalWalletContextStub.d.ts

@@ -7,6 +7,7 @@ export declare const defaultEvmExternalWallet: {
     chainId: any;
     username: any;
     avatar: any;
+    balance: any;
     disconnect: () => Promise<void>;
     switchChain: () => Promise<{}>;
     signMessage: () => Promise<{}>;
@@ -18,6 +19,7 @@ export type EvmExternalWalletContextType = {
     chainId: number;
     username: string;
     avatar?: string;
+    balance?: string;
     disconnect: () => Promise<void>;
     switchChain: (chainId: number) => Promise<{
         error?: string[];

package/dist/modal/providers/EvmExternalWalletContextStub.js

@@ -0,0 +1,55 @@
+"use client";
+import "../../chunk-MMUBH76A.js";
+import { jsx } from "react/jsx-runtime";
+import { createContext, useMemo } from "react";
+const defaultEvmExternalWallet = {
+  wallets: [],
+  chains: [],
+  chainId: void 0,
+  username: void 0,
+  avatar: void 0,
+  balance: void 0,
+  disconnect: () => Promise.resolve(),
+  switchChain: () => Promise.resolve({}),
+  signMessage: () => Promise.resolve({}),
+  signVerificationMessage: () => Promise.resolve({})
+};
+const EvmExternalWalletContext = createContext(defaultEvmExternalWallet);
+function EvmExternalWalletProvider({ children }) {
+  const wallets = [];
+  const chains = [];
+  const chainId = void 0;
+  const username = void 0;
+  const avatar = void 0;
+  const balance = void 0;
+  const disconnect = () => Promise.resolve();
+  const switchChain = () => Promise.resolve({});
+  const signMessage = () => Promise.resolve({});
+  const signVerificationMessage = () => Promise.resolve({});
+  return /* @__PURE__ */ jsx(
+    EvmExternalWalletContext.Provider,
+    {
+      value: useMemo(
+        () => ({
+          wallets,
+          chains,
+          chainId,
+          username,
+          avatar,
+          balance,
+          disconnect,
+          switchChain,
+          signMessage,
+          signVerificationMessage
+        }),
+        [wallets, chains, chainId, username, avatar, balance, disconnect, switchChain, signMessage, signVerificationMessage]
+      ),
+      children
+    }
+  );
+}
+export {
+  EvmExternalWalletContext,
+  EvmExternalWalletProvider,
+  defaultEvmExternalWallet
+};

package/dist/modal/providers/ExternalWalletContext.d.ts

@@ -19,6 +19,7 @@ export declare const defaultExternalWallet: {
     };
     username: any;
     avatar: any;
+    balance: any;
     connectExternalWallet: () => void;
     disconnectExternalWallet: () => Promise<void>;
     switchChain: () => Promise<void>;
@@ -40,6 +41,7 @@ export declare const ExternalWalletContext: Context<{
     };
     username?: string;
     avatar?: string;
+    balance?: string;
     connectExternalWallet: (wallet: CommonWallet, isMobile?: boolean, isManualWalletConnect?: boolean) => void;
     disconnectExternalWallet: () => Promise<void>;
     switchChain: (chainId: string) => Promise<void>;
@@ -75,6 +77,7 @@ export declare const useExternalWallets: () => {
     };
     username?: string;
     avatar?: string;
+    balance?: string;
     connectExternalWallet: (wallet: CommonWallet, isMobile?: boolean, isManualWalletConnect?: boolean) => void;
     disconnectExternalWallet: () => Promise<void>;
     switchChain: (chainId: string) => Promise<void>;