@getpara/react-sdk-lite 2.0.0-alpha.33

package/dist/provider/hooks/queries/useWallet.d.ts

@@ -0,0 +1,5 @@
+export declare const WALLET_BASE_KEY = "PARA_WALLET";
+/**
+ * Hook for retrieving the selected wallet
+ */
+export declare const useWallet: () => import("@tanstack/react-query").UseQueryResult<Omit<import("@getpara/core-sdk").Wallet, "signer"> | null, Error>;

package/dist/provider/hooks/queries/useWallet.js

@@ -0,0 +1,26 @@
+"use client";
+import {
+  __async
+} from "../../../chunk-MMUBH76A.js";
+import { useQuery } from "@tanstack/react-query";
+import { useClient, useWalletState } from "../index.js";
+import { getWallet } from "../../actions/getWallet.js";
+import { useIsFullyLoggedIn } from "./useIsFullyLoggedIn.js";
+const WALLET_BASE_KEY = "PARA_WALLET";
+const useWallet = () => {
+  var _a, _b;
+  const client = useClient();
+  const { selectedWallet } = useWalletState();
+  const { data: isFullyLoggedIn, isSuccess } = useIsFullyLoggedIn();
+  return useQuery({
+    enabled: !!client && !!selectedWallet && isSuccess,
+    queryKey: [WALLET_BASE_KEY, isFullyLoggedIn != null ? isFullyLoggedIn : null, (_a = selectedWallet.id) != null ? _a : null, (_b = selectedWallet.type) != null ? _b : null],
+    queryFn: () => __async(void 0, null, function* () {
+      return yield getWallet(client, selectedWallet, isFullyLoggedIn);
+    })
+  });
+};
+export {
+  WALLET_BASE_KEY,
+  useWallet
+};

package/dist/provider/hooks/queries/useWalletBalance.d.ts

@@ -0,0 +1,6 @@
+import { GetWalletBalanceParams } from '@getpara/web-sdk';
+export declare const WALLET_BALANCE_BASE_KEY = "PARA_WALLET_BALANCE";
+/**
+ * Hook for retrieving a wallet balance
+ */
+export declare const useWalletBalance: (args?: Partial<GetWalletBalanceParams>) => import("@tanstack/react-query").UseQueryResult<string | null, Error>;

package/dist/provider/hooks/queries/useWalletBalance.js

@@ -0,0 +1,55 @@
+"use client";
+import {
+  __async,
+  __spreadValues
+} from "../../../chunk-MMUBH76A.js";
+import { useQuery } from "@tanstack/react-query";
+import { useAccount, useClient, useWallet, useWalletState } from "../index.js";
+import { useStore } from "../../stores/useStore.js";
+import { getWalletBalance } from "../../actions/index.js";
+import { useExternalWallets } from "../../providers/ExternalWalletProvider.js";
+import { useCallback } from "react";
+const WALLET_BALANCE_BASE_KEY = "PARA_WALLET_BALANCE";
+const useWalletBalance = (args) => {
+  const client = useClient();
+  const { data: selectedWallet } = useWallet();
+  const {
+    selectedWallet: { type: selectedWalletType }
+  } = useWalletState();
+  const { embedded } = useAccount();
+  const rpcUrl = useStore((state) => state.rpcUrl);
+  const { getWalletBalance: getExternalWalletBalance, chainId } = useExternalWallets();
+  const queryFn = useCallback(() => __async(void 0, null, function* () {
+    var _a, _b, _c;
+    const skipGetBalance = !selectedWallet || selectedWalletType && ["COSMOS", "SOLANA"].includes(selectedWalletType);
+    if (skipGetBalance) {
+      return null;
+    }
+    try {
+      if (selectedWallet.isExternal) {
+        return (_a = yield getExternalWalletBalance()) != null ? _a : null;
+      } else {
+        const completeArgs = __spreadValues({ walletId: (_b = selectedWallet == null ? void 0 : selectedWallet.id) != null ? _b : "", rpcUrl }, args);
+        return (_c = yield getWalletBalance(client, completeArgs)) != null ? _c : null;
+      }
+    } catch (err) {
+      console.error("Error fetching wallet balance: ", err);
+      return null;
+    }
+  }), [embedded, selectedWallet, selectedWalletType, rpcUrl, getExternalWalletBalance]);
+  return useQuery({
+    queryKey: [
+      WALLET_BALANCE_BASE_KEY,
+      client == null ? void 0 : client.userId,
+      selectedWallet == null ? void 0 : selectedWallet.id,
+      selectedWallet == null ? void 0 : selectedWallet.type,
+      (selectedWallet == null ? void 0 : selectedWallet.isExternal) ? chainId : ""
+    ],
+    queryFn,
+    enabled: !!client && !!selectedWallet && !!rpcUrl && !!(embedded == null ? void 0 : embedded.isConnected)
+  });
+};
+export {
+  WALLET_BALANCE_BASE_KEY,
+  useWalletBalance
+};

package/dist/provider/hooks/queries/utils.d.ts

@@ -0,0 +1,7 @@
+import { CoreMethodName, CoreMethodParams, CoreMethods } from '@getpara/web-sdk';
+import { CoreMethodQueryHook } from '../../types/utils.js';
+import { CoreAction } from '../../actions/utils.js';
+export declare function generateCoreQueryHook<const method extends CoreMethodName & keyof CoreMethods>(method: method, action: CoreAction<method>, { isGetter, defaultParams }?: {
+    isGetter?: boolean;
+    defaultParams?: CoreMethodParams<method>;
+}): (params?: CoreMethodParams<method>) => CoreMethodQueryHook<method>;

package/dist/provider/hooks/queries/utils.js

@@ -0,0 +1,25 @@
+"use client";
+import {
+  __async
+} from "../../../chunk-MMUBH76A.js";
+import { useClient } from "../utils/index.js";
+import { useQuery } from "@tanstack/react-query";
+function generateCoreQueryHook(method, action, { isGetter = false, defaultParams } = {}) {
+  return (params = defaultParams) => {
+    var _a;
+    const para = useClient();
+    return useQuery({
+      queryKey: [method, params != null ? params : null, isGetter ? (_a = para == null ? void 0 : para[method]) != null ? _a : null : null],
+      queryFn: (_0) => __async(this, [_0], function* ({ queryKey: [_, params2] }) {
+        if (!para) {
+          return null;
+        }
+        const result = params2 ? yield action(para, params2) : defaultParams ? yield action(para, defaultParams) : yield action(para);
+        return result != null ? result : null;
+      })
+    });
+  };
+}
+export {
+  generateCoreQueryHook
+};

package/dist/provider/hooks/utils/index.d.ts

@@ -0,0 +1,3 @@
+export { useClient } from './useClient.js';
+export { useModal } from './useModal.js';
+export { useWalletState } from './useWalletState.js';

package/dist/provider/hooks/utils/index.js

@@ -0,0 +1,10 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+import { useClient } from "./useClient.js";
+import { useModal } from "./useModal.js";
+import { useWalletState } from "./useWalletState.js";
+export {
+  useClient,
+  useModal,
+  useWalletState
+};

package/dist/provider/hooks/utils/useAutoSessionKeepAlive.d.ts

@@ -0,0 +1,3 @@
+export declare const useAutoSessionKeepAlive: ({ disabled }: {
+    disabled?: boolean;
+}) => void;

package/dist/provider/hooks/utils/useAutoSessionKeepAlive.js

@@ -0,0 +1,74 @@
+"use client";
+import {
+  __async
+} from "../../../chunk-MMUBH76A.js";
+import { useEffect, useRef } from "react";
+import { useAccount, useKeepSessionAlive, useLogout } from "../index.js";
+import { useInternalClient } from "./useInternalClient.js";
+const SESSION_CHECK_INTERVAL = 6e4;
+const SESSION_REFRESH_THRESHOLD = 3e5;
+const useAutoSessionKeepAlive = ({ disabled }) => {
+  const client = useInternalClient();
+  const { embedded } = useAccount();
+  const { logoutAsync } = useLogout();
+  const { keepSessionAliveAsync } = useKeepSessionAlive();
+  const sessionCheckInterval = useRef(null);
+  useEffect(() => {
+    if (!client || disabled) {
+      clearSessionMonitoring();
+      return;
+    }
+    if ((embedded == null ? void 0 : embedded.isConnected) && !embedded.isGuestMode && client.externalWalletConnectionType !== "CONNECTION_ONLY") {
+      setupSessionMonitoring();
+    } else {
+      clearSessionMonitoring();
+    }
+    return () => clearSessionMonitoring();
+  }, [client, embedded, disabled]);
+  const getSessionExpiry = () => __async(void 0, null, function* () {
+    try {
+      const sessionCookie = yield client == null ? void 0 : client.retrieveSessionCookie();
+      if (!sessionCookie) return null;
+      const expiresMatch = sessionCookie.match(/Expires=([^;]+)/);
+      return expiresMatch ? new Date(expiresMatch[1]) : null;
+    } catch (err) {
+      return null;
+    }
+  });
+  const setupSessionMonitoring = () => {
+    clearSessionMonitoring();
+    sessionCheckInterval.current = setInterval(() => __async(void 0, null, function* () {
+      const expiry = yield getSessionExpiry();
+      if (!expiry) {
+        yield logoutAsync({});
+        clearSessionMonitoring();
+        return;
+      }
+      const timeUntilExpiry = expiry.getTime() - Date.now();
+      if (timeUntilExpiry <= 0) {
+        yield logoutAsync({});
+        clearSessionMonitoring();
+        return;
+      }
+      if (timeUntilExpiry <= SESSION_REFRESH_THRESHOLD) {
+        try {
+          yield keepSessionAliveAsync();
+          setupSessionMonitoring();
+        } catch (err) {
+          console.error("Failed to keep session alive:", err);
+          yield logoutAsync({});
+          clearSessionMonitoring();
+        }
+        return;
+      }
+    }), SESSION_CHECK_INTERVAL);
+  };
+  const clearSessionMonitoring = () => {
+    if (sessionCheckInterval.current) {
+      clearInterval(sessionCheckInterval.current);
+    }
+  };
+};
+export {
+  useAutoSessionKeepAlive
+};

package/dist/provider/hooks/utils/useClient.d.ts

@@ -0,0 +1,5 @@
+import ParaWeb from '@getpara/web-sdk';
+/**
+ * Hook for retrieving the Para client
+ */
+export declare const useClient: <Para extends ParaWeb = ParaWeb>() => Para | undefined;

package/dist/provider/hooks/utils/useClient.js

@@ -0,0 +1,10 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+import { useStore } from "../../stores/useStore.js";
+const useClient = () => {
+  const client = useStore((state) => state.client);
+  return client;
+};
+export {
+  useClient
+};

package/dist/provider/hooks/utils/useEventListeners.d.ts

@@ -0,0 +1,2 @@
+import { Callbacks } from '../../types/provider.js';
+export declare const useEventListeners: ({ onLogin, onLogout, onAccountSetup, onAccountCreation, onSignMessage, onSignTransaction, onWalletCreated, onPregenWalletClaimed, onExternalWalletChange, onWalletsChange, onGuestWalletsCreated, }?: Callbacks) => void;

package/dist/provider/hooks/utils/useEventListeners.js

@@ -0,0 +1,157 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+import { useQueryClient } from "@tanstack/react-query";
+import { useCallback, useEffect } from "react";
+import { useWalletState } from "../index.js";
+import {
+  ParaEvent
+} from "@getpara/web-sdk";
+import { ACCOUNT_BASE_KEY } from "../queries/useAccount.js";
+import { useStore } from "../../stores/useStore.js";
+import { WALLET_BASE_KEY } from "../queries/useWallet.js";
+import { WALLET_BALANCE_BASE_KEY } from "../queries/useWalletBalance.js";
+import { IS_FULLY_LOGGED_IN_BASE_KEY } from "../queries/useIsFullyLoggedIn.js";
+const useEventListeners = ({
+  onLogin,
+  onLogout,
+  onAccountSetup,
+  onAccountCreation,
+  onSignMessage,
+  onSignTransaction,
+  onWalletCreated,
+  onPregenWalletClaimed,
+  onExternalWalletChange,
+  onWalletsChange,
+  onGuestWalletsCreated
+} = {}) => {
+  const queryClient = useQueryClient();
+  const clearSelectedWallet = useStore((state) => state.clearSelectedWallet);
+  const { updateSelectedWallet } = useWalletState();
+  const loginOrSetupListener = useCallback(() => {
+    queryClient.refetchQueries({ queryKey: [IS_FULLY_LOGGED_IN_BASE_KEY] });
+    queryClient.refetchQueries({ queryKey: [ACCOUNT_BASE_KEY] });
+    queryClient.refetchQueries({ queryKey: [WALLET_BASE_KEY] });
+    queryClient.invalidateQueries({ queryKey: [WALLET_BALANCE_BASE_KEY], exact: false });
+  }, [queryClient]);
+  const loginListener = useCallback(
+    (event) => {
+      loginOrSetupListener();
+      onLogin == null ? void 0 : onLogin(event);
+    },
+    [loginOrSetupListener, onLogin]
+  );
+  const accountSetupListener = useCallback(
+    (event) => {
+      loginOrSetupListener();
+      onAccountSetup == null ? void 0 : onAccountSetup(event);
+    },
+    [loginOrSetupListener, onAccountSetup]
+  );
+  const accountCreationListener = useCallback(
+    (event) => {
+      onAccountCreation == null ? void 0 : onAccountCreation(event);
+    },
+    [onAccountCreation]
+  );
+  const logoutListener = useCallback(
+    (event) => {
+      queryClient.refetchQueries({ queryKey: [IS_FULLY_LOGGED_IN_BASE_KEY] });
+      queryClient.refetchQueries({ queryKey: [ACCOUNT_BASE_KEY] });
+      clearSelectedWallet();
+      onLogout == null ? void 0 : onLogout(event);
+    },
+    [queryClient, clearSelectedWallet, onLogout]
+  );
+  const signMessageListener = useCallback(
+    (event) => {
+      onSignMessage == null ? void 0 : onSignMessage(event);
+    },
+    [onSignMessage]
+  );
+  const signTransactionListener = useCallback(
+    (event) => {
+      onSignTransaction == null ? void 0 : onSignTransaction(event);
+    },
+    [onSignTransaction]
+  );
+  const walletChangeListener = useCallback(
+    (event) => {
+      queryClient.refetchQueries({ queryKey: [IS_FULLY_LOGGED_IN_BASE_KEY] });
+      queryClient.refetchQueries({ queryKey: [ACCOUNT_BASE_KEY] });
+      updateSelectedWallet();
+      onWalletsChange == null ? void 0 : onWalletsChange(event);
+    },
+    [queryClient, updateSelectedWallet, onWalletsChange]
+  );
+  const externalWalletChangeListener = useCallback(
+    (event) => {
+      queryClient.refetchQueries({ queryKey: [IS_FULLY_LOGGED_IN_BASE_KEY] });
+      queryClient.refetchQueries({ queryKey: [ACCOUNT_BASE_KEY] });
+      updateSelectedWallet();
+      onExternalWalletChange == null ? void 0 : onExternalWalletChange(event);
+    },
+    [queryClient, updateSelectedWallet, onExternalWalletChange]
+  );
+  const walletCreatedListener = useCallback(
+    (event) => {
+      onWalletCreated == null ? void 0 : onWalletCreated(event);
+    },
+    [onWalletCreated]
+  );
+  const pregenWalletClaimedListener = useCallback(
+    (event) => {
+      onPregenWalletClaimed == null ? void 0 : onPregenWalletClaimed(event);
+    },
+    [onPregenWalletClaimed]
+  );
+  const guestWalletsCreatedListener = useCallback(
+    (event) => {
+      queryClient.refetchQueries({ queryKey: [IS_FULLY_LOGGED_IN_BASE_KEY] });
+      queryClient.refetchQueries({ queryKey: [ACCOUNT_BASE_KEY] });
+      updateSelectedWallet();
+      onGuestWalletsCreated == null ? void 0 : onGuestWalletsCreated(event);
+    },
+    [queryClient, updateSelectedWallet, onGuestWalletsCreated]
+  );
+  useEffect(() => {
+    window.addEventListener(ParaEvent.LOGIN_EVENT, loginListener);
+    window.addEventListener(ParaEvent.ACCOUNT_SETUP_EVENT, accountSetupListener);
+    window.addEventListener(ParaEvent.ACCOUNT_CREATION_EVENT, accountCreationListener);
+    window.addEventListener(ParaEvent.LOGOUT_EVENT, logoutListener);
+    window.addEventListener(ParaEvent.SIGN_MESSAGE_EVENT, signMessageListener);
+    window.addEventListener(ParaEvent.SIGN_TRANSACTION_EVENT, signTransactionListener);
+    window.addEventListener(ParaEvent.WALLETS_CHANGE_EVENT, walletChangeListener);
+    window.addEventListener(ParaEvent.EXTERNAL_WALLET_CHANGE_EVENT, externalWalletChangeListener);
+    window.addEventListener(ParaEvent.WALLET_CREATED, walletCreatedListener);
+    window.addEventListener(ParaEvent.PREGEN_WALLET_CLAIMED, pregenWalletClaimedListener);
+    window.addEventListener(ParaEvent.GUEST_WALLETS_CREATED, guestWalletsCreatedListener);
+    return () => {
+      window.removeEventListener(ParaEvent.LOGIN_EVENT, loginListener);
+      window.removeEventListener(ParaEvent.ACCOUNT_SETUP_EVENT, accountSetupListener);
+      window.removeEventListener(ParaEvent.ACCOUNT_CREATION_EVENT, accountCreationListener);
+      window.removeEventListener(ParaEvent.LOGOUT_EVENT, logoutListener);
+      window.removeEventListener(ParaEvent.SIGN_MESSAGE_EVENT, signMessageListener);
+      window.removeEventListener(ParaEvent.SIGN_TRANSACTION_EVENT, signTransactionListener);
+      window.removeEventListener(ParaEvent.WALLETS_CHANGE_EVENT, walletChangeListener);
+      window.removeEventListener(ParaEvent.EXTERNAL_WALLET_CHANGE_EVENT, externalWalletChangeListener);
+      window.removeEventListener(ParaEvent.WALLET_CREATED, walletCreatedListener);
+      window.removeEventListener(ParaEvent.PREGEN_WALLET_CLAIMED, pregenWalletClaimedListener);
+      window.removeEventListener(ParaEvent.GUEST_WALLETS_CREATED, guestWalletsCreatedListener);
+    };
+  }, [
+    loginListener,
+    accountSetupListener,
+    accountCreationListener,
+    logoutListener,
+    signMessageListener,
+    signTransactionListener,
+    walletChangeListener,
+    externalWalletChangeListener,
+    walletCreatedListener,
+    pregenWalletClaimedListener,
+    guestWalletsCreatedListener
+  ]);
+};
+export {
+  useEventListeners
+};

package/dist/provider/hooks/utils/useFormattedBiometricHints.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Hook for getting formatted biometric hints
+ */
+export declare const useFormattedBiometricHints: () => import("@tanstack/react-query").UseQueryResult<import("@getpara/react-common").BiometricHints | null, Error>;

package/dist/provider/hooks/utils/useFormattedBiometricHints.js

@@ -0,0 +1,27 @@
+"use client";
+import {
+  __async
+} from "../../../chunk-MMUBH76A.js";
+import { useQuery } from "@tanstack/react-query";
+import { useModalStore } from "../../../modal/stores/index.js";
+import { formatBiometricHints } from "@getpara/react-common";
+import { useClient } from "./useClient.js";
+const queryKey = ["FORMATTED_BIOMETRIC_HINTS"];
+const useFormattedBiometricHints = () => {
+  var _a;
+  const client = useClient();
+  const loginState = useModalStore((state) => state.getLoginState());
+  return useQuery({
+    queryKey: [...queryKey, (_a = loginState == null ? void 0 : loginState.biometricHints) != null ? _a : "undefined"],
+    queryFn: () => __async(void 0, null, function* () {
+      if (!client || !(loginState == null ? void 0 : loginState.biometricHints)) {
+        return null;
+      }
+      const isPasskeySupported = yield client.isPasskeySupported();
+      return formatBiometricHints(loginState.biometricHints, isPasskeySupported);
+    })
+  });
+};
+export {
+  useFormattedBiometricHints
+};

package/dist/provider/hooks/utils/useInternalClient.d.ts

@@ -0,0 +1,5 @@
+import { ParaInternal } from '@getpara/react-common';
+/**
+ * Hook for retrieving the Para internal client
+ */
+export declare const useInternalClient: () => ParaInternal;

package/dist/provider/hooks/utils/useInternalClient.js

@@ -0,0 +1,10 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+import { useClient } from "./useClient.js";
+const useInternalClient = () => {
+  const client = useClient();
+  return client;
+};
+export {
+  useInternalClient
+};

package/dist/provider/hooks/utils/useModal.d.ts

@@ -0,0 +1,11 @@
+import { ModalStep } from '../../../modal/index.js';
+/**
+ * Hook for controlling the Para modal
+ */
+export declare const useModal: () => {
+    isOpen: boolean;
+    openModal: ({ step }?: {
+        step?: ModalStep;
+    }) => void;
+    closeModal: () => void;
+};

package/dist/provider/hooks/utils/useModal.js

@@ -0,0 +1,27 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+import { useModalStore } from "../../../modal/stores/index.js";
+import { useStore } from "../../stores/useStore.js";
+const useModal = () => {
+  const isOpen = useStore((state) => state.isOpen);
+  const setIsOpen = useStore((state) => state.setIsOpen);
+  const openedToStep = useStore((state) => state.openedToStep);
+  const setStep = useModalStore((state) => state.setStep);
+  const openModal = ({ step } = {}) => {
+    if (step) {
+      openedToStep.current = step;
+      setStep(step);
+    }
+    if (!isOpen) {
+      setIsOpen(true);
+    }
+  };
+  const closeModal = () => {
+    openedToStep.current = null;
+    setIsOpen(false);
+  };
+  return { isOpen, openModal, closeModal };
+};
+export {
+  useModal
+};

package/dist/provider/hooks/utils/useWalletState.d.ts

@@ -0,0 +1,15 @@
+import { TWalletType } from '@getpara/web-sdk';
+/**
+ * Hook for controlling selected wallet
+ */
+export declare const useWalletState: () => {
+    selectedWallet: {
+        id: string | undefined;
+        type: "EVM" | "SOLANA" | "COSMOS" | undefined;
+    };
+    setSelectedWallet: ({ id, type }: {
+        id?: string;
+        type?: TWalletType;
+    }) => void;
+    updateSelectedWallet: () => void;
+};

package/dist/provider/hooks/utils/useWalletState.js

@@ -0,0 +1,48 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+import { useStore } from "../../stores/useStore.js";
+import { useClient } from "./useClient.js";
+import { useCallback } from "react";
+const useWalletState = () => {
+  const client = useClient();
+  const selectedWalletId = useStore((state) => state.selectedWalletId);
+  const selectedWalletType = useStore((state) => state.selectedWalletType);
+  const setStoredSelectedWallet = useStore((state) => state.setSelectedWallet);
+  const clearSelectedWallet = useStore((state) => state.clearSelectedWallet);
+  const setSelectedWallet = useCallback(
+    ({ id, type }) => {
+      try {
+        const validId = client == null ? void 0 : client.findWalletId(id, type ? { type: [type] } : void 0);
+        if (validId !== id) {
+          clearSelectedWallet();
+        } else {
+          setStoredSelectedWallet(id, type);
+        }
+      } catch (e) {
+        clearSelectedWallet();
+      }
+    },
+    [client, clearSelectedWallet, setStoredSelectedWallet]
+  );
+  const updateSelectedWallet = useCallback(() => {
+    if (!client) {
+      clearSelectedWallet();
+      return;
+    }
+    if (!selectedWalletId || !client.findWallet(selectedWalletId)) {
+      const defaultWallet = client.findWallet(void 0, void 0, { forbidPregen: true });
+      setSelectedWallet({ id: defaultWallet == null ? void 0 : defaultWallet.id, type: defaultWallet == null ? void 0 : defaultWallet.type });
+    }
+  }, [clearSelectedWallet, setSelectedWallet, client, selectedWalletId]);
+  return {
+    selectedWallet: {
+      id: selectedWalletId,
+      type: selectedWalletType
+    },
+    setSelectedWallet,
+    updateSelectedWallet
+  };
+};
+export {
+  useWalletState
+};

package/dist/provider/index.d.ts

@@ -0,0 +1,6 @@
+export { ParaProvider } from './ParaProvider.js';
+export * from './hooks/index.js';
+export * from './stores/getters.js';
+export * from './stores/setters.js';
+export * from './types/externalWalletProviders.js';
+export * from './types/provider.js';

package/dist/provider/index.js

@@ -0,0 +1,11 @@
+"use client";
+import "../chunk-MMUBH76A.js";
+import { ParaProvider } from "./ParaProvider.js";
+export * from "./hooks/index.js";
+export * from "./stores/getters.js";
+export * from "./stores/setters.js";
+export * from "./types/externalWalletProviders.js";
+export * from "./types/provider.js";
+export {
+  ParaProvider
+};

package/dist/provider/providers/AccountLinkProvider.d.ts

@@ -0,0 +1,47 @@
+import { PropsWithChildren } from 'react';
+import { MutationStatus } from '@tanstack/react-query';
+import { AccountLinkError, AccountLinkInProgress as CoreAccountLinkInProgress, LinkedAccount, LinkedAccounts, SupportedAccountLinks, TelegramAuthResponse, TExternalWallet, TLinkedAccountType, Auth, InternalMethodParams } from '@getpara/web-sdk';
+import { TWalletType } from '@getpara/user-management-client';
+type AccountLinkInProgress = Partial<CoreAccountLinkInProgress & {
+    pendingWalletProvider?: TExternalWallet;
+    pendingWalletType?: TWalletType;
+}>;
+export type ModalLinkAccountArgs = undefined | {
+    auth: Auth<'email' | 'phone'>;
+} | {
+    type: Exclude<TLinkedAccountType, 'EXTERNAL_WALLET'> | 'X';
+} | {
+    externalWallet: {
+        internalId: TExternalWallet;
+        type?: TWalletType;
+    };
+} | {
+    options: SupportedAccountLinks;
+};
+type Value = {
+    isEnabled: boolean;
+    accountLinkInProgress: AccountLinkInProgress | undefined;
+    accountLinkOptions: SupportedAccountLinks;
+    linkAccount: (_: ModalLinkAccountArgs) => Promise<void>;
+    isLinkAccountPending: boolean;
+    verifyEmailOrPhoneLink: (verificationCode: string) => void;
+    verifyOAuthLink: (method: InternalMethodParams<'verifyOAuthLink'>['method']) => void;
+    verifyFarcasterLink: () => void;
+    verifyTelegramLink: (telegramAuthResponse: TelegramAuthResponse) => void;
+    verifyLinkedAccount: (accountLinkInProgress: AccountLinkInProgress) => void;
+    linkAccountStatus: MutationStatus;
+    linkAccountError: string | null;
+    setLinkAccountError: (_: AccountLinkError | null) => void;
+    unlinkingAccount: LinkedAccount | undefined;
+    unlinkAccount: (linkedAccount: LinkedAccount) => void;
+    unlinkAccountConfirm: () => void;
+    isUnlinkAccountPending: boolean;
+    cancelLinkAccount: () => void;
+    onAccountLinked: (_: AccountLinkInProgress) => void;
+    onAccountLinkVerified: (_: LinkedAccounts) => void;
+    resetMutations: () => void;
+};
+export declare const AccountLinkContext: import("react").Context<Value>;
+export declare const AccountLinkProvider: ({ children }: PropsWithChildren) => import("react/jsx-runtime").JSX.Element;
+export declare const useAccountLinking: () => Value;
+export {};