@frak-labs/react-sdk 0.0.3

package/README.md

@@ -0,0 +1,8 @@
+# Frak Wallet React SDK
+
+This SDK help any dApps, or gated content provider, use the [Frak Wallet](https://wallet.frak.id/) as a regular wallet, with smoother UX for your end-users (pay for his gas fees, check the paywall options, track his consumption etc.)
+
+Checkout our documentation for more information's about the usage:
+- [React client usage](https://docs.frak.id/wallet-sdk/getting-started/react)
+- [Core client usage](https://docs.frak.id/wallet-sdk/getting-started/javascript)
+- [CDN / Browser usage](https://docs.frak.id/wallet-sdk/getting-started/cdn)

package/dist/index.cjs

@@ -0,0 +1,389 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/provider/FrakConfigProvider.ts
+var _react = require('react');
+var FrakConfigContext = _react.createContext.call(void 0, 
+  void 0
+);
+function FrakConfigProvider(parameters) {
+  const { children, config } = parameters;
+  return _react.createElement.call(void 0, 
+    FrakConfigContext.Provider,
+    {
+      value: {
+        ...config,
+        walletUrl: _nullishCoalesce(config.walletUrl, () => ( "https://wallet.frak.id")),
+        domain: _nullishCoalesce(_nullishCoalesce(config.domain, () => ( (typeof window !== "undefined" ? _optionalChain([window, 'optionalAccess', _ => _.location, 'optionalAccess', _2 => _2.host]) : void 0))), () => ( "not-found"))
+      }
+    },
+    children
+  );
+}
+
+// src/provider/FrakIFrameClientProvider.ts
+
+
+
+var _coresdk = require('@frak-labs/core-sdk');
+
+
+
+
+
+
+
+// src/hook/useFrakConfig.ts
+
+
+function useFrakConfig() {
+  const config = _react.useContext.call(void 0, FrakConfigContext);
+  if (!config) {
+    throw new (0, _coresdk.FrakRpcError)(
+      _coresdk.RpcErrorCodes.configError,
+      "Frak config not found"
+    );
+  }
+  return config;
+}
+
+// src/hook/useFrakClient.ts
+
+function useFrakClient() {
+  return _react.useContext.call(void 0, FrakIFrameClientContext);
+}
+
+// src/hook/useWalletStatus.ts
+
+
+
+var _actions = require('@frak-labs/core-sdk/actions');
+var _reactquery = require('@tanstack/react-query');
+
+function useWalletStatus() {
+  const queryClient = _reactquery.useQueryClient.call(void 0, );
+  const client = useFrakClient();
+  const newStatusUpdated = _react.useCallback.call(void 0, 
+    (event) => {
+      queryClient.setQueryData(
+        ["frak-sdk", "wallet-status-listener"],
+        event
+      );
+    },
+    [queryClient]
+  );
+  return _reactquery.useQuery.call(void 0, {
+    gcTime: 0,
+    staleTime: 0,
+    queryKey: ["frak-sdk", "wallet-status-listener"],
+    queryFn: async () => {
+      if (!client) {
+        throw new (0, _coresdk.ClientNotFound)();
+      }
+      return _actions.watchWalletStatus.call(void 0, client, newStatusUpdated);
+    },
+    enabled: !!client
+  });
+}
+
+// src/hook/useSendTransaction.ts
+
+
+
+
+
+
+
+function useSendTransactionAction({
+  mutations
+} = {}) {
+  const client = useFrakClient();
+  return _reactquery.useMutation.call(void 0, {
+    ...mutations,
+    mutationKey: ["frak-sdk", "send-transaction"],
+    mutationFn: async (params) => {
+      if (!client) {
+        throw new (0, _coresdk.ClientNotFound)();
+      }
+      return _actions.sendTransaction.call(void 0, client, params);
+    }
+  });
+}
+
+// src/hook/useSiweAuthenticate.ts
+
+
+
+
+
+
+
+function useSiweAuthenticate({
+  mutations
+} = {}) {
+  const client = useFrakClient();
+  return _reactquery.useMutation.call(void 0, {
+    ...mutations,
+    mutationKey: [
+      "frak-sdk",
+      "siwe-authenticate",
+      _nullishCoalesce(_optionalChain([client, 'optionalAccess', _3 => _3.config, 'access', _4 => _4.domain]), () => ( "no-domain"))
+    ],
+    mutationFn: async (params) => {
+      if (!client) {
+        throw new (0, _coresdk.ClientNotFound)();
+      }
+      return _actions.siweAuthenticate.call(void 0, client, params);
+    }
+  });
+}
+
+// src/hook/helper/useReferralInteraction.ts
+
+
+
+
+
+
+
+
+
+// src/hook/utils/useFrakContext.ts
+
+
+
+// src/hook/utils/useWindowLocation.ts
+
+
+// src/hook/utils/useMounted.ts
+
+function useMounted() {
+  const [mounted, setMounted] = _react.useState.call(void 0, false);
+  _react.useEffect.call(void 0, () => {
+    setMounted(true);
+  }, []);
+  return mounted;
+}
+
+// src/hook/utils/useWindowLocation.ts
+function useWindowLocation() {
+  const isMounted = useMounted();
+  const [location, setLocation] = _react.useState.call(void 0, 
+    isMounted ? window.location : void 0
+  );
+  _react.useEffect.call(void 0, () => {
+    if (!isMounted) return;
+    function setWindowLocation() {
+      setLocation(window.location);
+    }
+    if (!location) {
+      setWindowLocation();
+    }
+    window.addEventListener("popstate", setWindowLocation);
+    return () => {
+      window.removeEventListener("popstate", setWindowLocation);
+    };
+  }, [isMounted, location]);
+  const href = _react.useMemo.call(void 0, () => _optionalChain([location, 'optionalAccess', _5 => _5.href]), [_optionalChain([location, 'optionalAccess', _6 => _6.href])]);
+  return { location, href };
+}
+
+// src/hook/utils/useFrakContext.ts
+function useFrakContext() {
+  const { location } = useWindowLocation();
+  const frakContext = _react.useMemo.call(void 0, () => {
+    if (!_optionalChain([location, 'optionalAccess', _7 => _7.href])) return null;
+    return _coresdk.FrakContextManager.parse({ url: location.href });
+  }, [_optionalChain([location, 'optionalAccess', _8 => _8.href])]);
+  const updateContext = _react.useCallback.call(void 0, 
+    (newContext) => {
+      console.log("Updating context", { newContext });
+      _coresdk.FrakContextManager.replaceUrl({
+        url: _optionalChain([location, 'optionalAccess', _9 => _9.href]),
+        context: newContext
+      });
+    },
+    [_optionalChain([location, 'optionalAccess', _10 => _10.href])]
+  );
+  return {
+    frakContext,
+    updateContext
+  };
+}
+
+// src/hook/helper/useReferralInteraction.ts
+function useReferralInteraction({
+  productId,
+  modalConfig,
+  options
+} = {}) {
+  const client = useFrakClient();
+  const { frakContext } = useFrakContext();
+  const { data: walletStatus } = useWalletStatus();
+  const {
+    data: referralState,
+    error,
+    status
+  } = _reactquery.useQuery.call(void 0, {
+    gcTime: 0,
+    staleTime: 0,
+    queryKey: [
+      "frak-sdk",
+      "auto-referral-interaction",
+      _nullishCoalesce(_optionalChain([frakContext, 'optionalAccess', _11 => _11.r]), () => ( "no-referrer")),
+      _nullishCoalesce(_optionalChain([walletStatus, 'optionalAccess', _12 => _12.key]), () => ( "no-wallet-status")),
+      _nullishCoalesce(productId, () => ( "no-product-id"))
+    ],
+    queryFn: () => {
+      if (!client) {
+        throw new (0, _coresdk.ClientNotFound)();
+      }
+      return _actions.processReferral.call(void 0, client, {
+        walletStatus,
+        frakContext,
+        modalConfig,
+        productId,
+        options
+      });
+    },
+    enabled: !!walletStatus
+  });
+  return _react.useMemo.call(void 0, () => {
+    if (status === "pending") return "processing";
+    if (status === "error") return error;
+    return referralState || "idle";
+  }, [referralState, status, error]);
+}
+
+// src/hook/useSendInteraction.ts
+
+
+
+
+
+function useSendInteraction({
+  mutations
+} = {}) {
+  const client = useFrakClient();
+  return _reactquery.useMutation.call(void 0, {
+    ...mutations,
+    mutationKey: ["frak-sdk", "send-interaction"],
+    mutationFn: async (params) => {
+      if (!client) {
+        throw new (0, _coresdk.ClientNotFound)();
+      }
+      return _actions.sendInteraction.call(void 0, client, params);
+    }
+  });
+}
+
+// src/hook/useDisplayModal.ts
+
+
+
+
+
+function useDisplayModal({
+  mutations
+} = {}) {
+  const client = useFrakClient();
+  return _reactquery.useMutation.call(void 0, {
+    ...mutations,
+    mutationKey: ["frak-sdk", "display-modal"],
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new (0, _coresdk.ClientNotFound)();
+      }
+      return _actions.displayModal.call(void 0, client, args);
+    }
+  });
+}
+
+// src/hook/useOpenSso.ts
+
+
+
+
+
+function useOpenSso({ mutations } = {}) {
+  const client = useFrakClient();
+  return _reactquery.useMutation.call(void 0, {
+    ...mutations,
+    mutationKey: ["frak-sdk", "open-sso"],
+    mutationFn: async (params) => {
+      if (!client) {
+        throw new (0, _coresdk.ClientNotFound)();
+      }
+      return _actions.openSso.call(void 0, client, params);
+    }
+  });
+}
+
+// src/hook/useGetProductInformation.ts
+
+
+
+
+
+function useGetProductInformation({
+  query
+} = {}) {
+  const client = useFrakClient();
+  return _reactquery.useQuery.call(void 0, {
+    ...query,
+    queryKey: ["frak-sdk", "get-product-information"],
+    queryFn: async () => {
+      if (!client) {
+        throw new (0, _coresdk.ClientNotFound)();
+      }
+      return _actions.getProductInformation.call(void 0, client);
+    }
+  });
+}
+
+// src/provider/FrakIFrameClientProvider.ts
+var FrakIFrameClientContext = _react.createContext.call(void 0, 
+  void 0
+);
+function FrakIFrameClientProvider({
+  style,
+  children
+}) {
+  const config = useFrakConfig();
+  const [client, setClient] = _react.useState.call(void 0, void 0);
+  const iFrame = _react.createElement.call(void 0, "iframe", {
+    ..._coresdk.baseIframeProps,
+    src: `${config.walletUrl}/listener`,
+    style: _nullishCoalesce(style, () => ( _coresdk.baseIframeProps.style)),
+    ref: (iframe) => {
+      if (!iframe || client) {
+        return;
+      }
+      setClient(
+        _coresdk.createIFrameFrakClient.call(void 0, {
+          iframe,
+          config
+        })
+      );
+    }
+  });
+  const providerComponent = _react.createElement.call(void 0, 
+    FrakIFrameClientContext.Provider,
+    { value: client },
+    children
+  );
+  return _react.createElement.call(void 0, _react.Fragment, null, iFrame, providerComponent);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.FrakConfigContext = FrakConfigContext; exports.FrakConfigProvider = FrakConfigProvider; exports.FrakIFrameClientContext = FrakIFrameClientContext; exports.FrakIFrameClientProvider = FrakIFrameClientProvider; exports.useDisplayModal = useDisplayModal; exports.useFrakClient = useFrakClient; exports.useFrakConfig = useFrakConfig; exports.useGetProductInformation = useGetProductInformation; exports.useOpenSso = useOpenSso; exports.useReferralInteraction = useReferralInteraction; exports.useSendInteraction = useSendInteraction; exports.useSendTransactionAction = useSendTransactionAction; exports.useSiweAuthenticate = useSiweAuthenticate; exports.useWalletStatus = useWalletStatus;

package/dist/index.d.cts

@@ -0,0 +1,298 @@
+import * as react from 'react';
+import { PropsWithChildren, CSSProperties, ReactNode } from 'react';
+import * as _frak_labs_core_sdk from '@frak-labs/core-sdk';
+import { FrakWalletSdkConfig, FrakClient, WalletStatusReturnType, SendTransactionReturnType, FrakRpcError, SiweAuthenticateReturnType, DisplayModalParamsType, ModalStepTypes, SendInteractionReturnType, SendInteractionParamsType, ModalRpcStepsResultType, OpenSsoParamsType, GetProductInformationReturnType } from '@frak-labs/core-sdk';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { UseMutationOptions, UseQueryOptions } from '@tanstack/react-query';
+import { SendTransactionParams, SiweAuthenticateModalParams, ProcessReferralOptions } from '@frak-labs/core-sdk/actions';
+import { Hex } from 'viem';
+
+/**
+ * The context that will keep the Frak Wallet SDK configuration
+ * @ignore
+ */
+declare const FrakConfigContext: react.Context<FrakWalletSdkConfig | undefined>;
+/**
+ * Props to instantiate the Frak Wallet SDK configuration provider
+ *
+ * @group provider
+ */
+type FrakConfigProviderProps = {
+    /**
+     * The wanted Frak configuration
+     * @see {@link @frak-labs/core-sdk!index.FrakWalletSdkConfig | FrakWalletSdkConfig}
+     */
+    config: FrakWalletSdkConfig;
+};
+/**
+ * Simple config provider for the Frak Wallet SDK
+ *
+ * Should be wrapped within a {@link @tanstack/react-query!QueryClientProvider | `QueryClientProvider`}
+ *
+ * @group provider
+ *
+ * @param parameters
+ */
+declare function FrakConfigProvider(parameters: PropsWithChildren<FrakConfigProviderProps>): react.FunctionComponentElement<react.ProviderProps<FrakWalletSdkConfig | undefined>>;
+
+/**
+ * The context that will keep the Frak Wallet SDK client
+ * @ignore
+ */
+declare const FrakIFrameClientContext: react.Context<FrakClient | undefined>;
+/**
+ * Props to instantiate the Frak Wallet SDK configuration provider
+ *
+ * @group provider
+ */
+type FrakIFrameClientProps = {
+    config: FrakWalletSdkConfig;
+};
+/**
+ * IFrame client provider for the Frak Wallet SDK
+ * It will automatically create the frak wallet iFrame (required for the wallet to communicate with the SDK securely), and provide it in the context
+ *
+ * @group provider
+ *
+ * @remarks
+ * This provider must be wrapped within a {@link FrakConfigProvider} to work properly
+ *
+ * @param args
+ * @param args.style - Some custom styles to apply to the iFrame
+ * @param args.children - Descedant components that will have access to the Frak Client
+ */
+declare function FrakIFrameClientProvider({ style, children, }: {
+    style?: CSSProperties;
+    children?: ReactNode;
+}): react.FunctionComponentElement<{
+    children?: ReactNode | undefined;
+}>;
+
+/**
+ * Get the current Frak config
+ * @throws {FrakRpcError} if the config is not found (only if this hooks is used outside a FrakConfigProvider)
+ * @group hooks
+ *
+ * @see {@link @frak-labs/react-sdk!FrakConfigProvider | FrakConfigProvider} for the config provider
+ * @see {@link @frak-labs/core-sdk!index.FrakWalletSdkConfig | FrakWalletSdkConfig} for the config type
+ */
+declare function useFrakConfig(): _frak_labs_core_sdk.FrakWalletSdkConfig;
+
+/**
+ * Get the current Frak client
+ *
+ * @group hooks
+ */
+declare function useFrakClient(): _frak_labs_core_sdk.FrakClient | undefined;
+
+/**
+ * Hook that return a query helping to get the current wallet status.
+ *
+ * It's a {@link @tanstack/react-query!home | `tanstack`} wrapper around the {@link @frak-labs/core-sdk!actions.watchWalletStatus | `watchWalletStatus()`} action
+ *
+ * @group hooks
+ *
+ * @returns
+ * The query hook wrapping the `watchWalletStatus()` action
+ * The `data` result is a {@link @frak-labs/core-sdk!index.WalletStatusReturnType | `WalletStatusReturnType`}
+ *
+ * @see {@link @frak-labs/core-sdk!actions.watchWalletStatus | `watchWalletStatus()`} for more info about the underlying action
+ * @see {@link @tanstack/react-query!useQuery | `useQuery()`} for more info about the useQuery response
+ */
+declare function useWalletStatus(): _tanstack_react_query.UseQueryResult<WalletStatusReturnType, Error>;
+
+/** @ignore */
+type MutationOptions$4 = Omit<UseMutationOptions<SendTransactionReturnType, FrakRpcError, SendTransactionParams>, "mutationFn" | "mutationKey">;
+/** @inline */
+interface UseSendTransactionParams {
+    /**
+     * Optional mutation options, see {@link @tanstack/react-query!useMutation | `useMutation()`} for more infos
+     */
+    mutations?: MutationOptions$4;
+}
+/**
+ * Hook that return a mutation helping to send a transaction
+ *
+ * It's a {@link @tanstack/react-query!home | `tanstack`} wrapper around the {@link @frak-labs/core-sdk!actions.sendTransaction | `sendTransaction()`} action
+ *
+ * @param args
+ *
+ * @group hooks
+ *
+ * @returns
+ * The mutation hook wrapping the `sendTransaction()` action
+ * The `mutate` and `mutateAsync` argument is of type {@link @frak-labs/core-sdk!actions.SendTransactionParams | `SendTransactionParams`}
+ * The `data` result is a {@link @frak-labs/core-sdk!index.SendTransactionReturnType | `SendTransactionReturnType`}
+ *
+ * @see {@link @frak-labs/core-sdk!actions.sendTransaction | `sendTransaction()`} for more info about the underlying action
+ * @see {@link @tanstack/react-query!useMutation | `useMutation()`} for more info about the mutation options and response
+ */
+declare function useSendTransactionAction({ mutations, }?: UseSendTransactionParams): _tanstack_react_query.UseMutationResult<SendTransactionReturnType, FrakRpcError<undefined>, SendTransactionParams, unknown>;
+
+/** @inline */
+type MutationOptions$3 = Omit<UseMutationOptions<SiweAuthenticateReturnType, FrakRpcError, SiweAuthenticateModalParams>, "mutationFn" | "mutationKey">;
+/** @ignore */
+interface UseSiweAuthenticateParams {
+    /**
+     * Optional mutation options, see {@link @tanstack/react-query!useMutation | `useMutation()`} for more infos
+     */
+    mutations?: MutationOptions$3;
+}
+/**
+ * Hook that return a mutation helping to send perform a SIWE authentication
+ *
+ * It's a {@link @tanstack/react-query!home | `tanstack`} wrapper around the {@link @frak-labs/core-sdk!actions.sendTransaction | `sendTransaction()`} action
+ *
+ * @param args
+ *
+ * @group hooks
+ *
+ * @returns
+ * The mutation hook wrapping the `siweAuthenticate()` action
+ * The `mutate` and `mutateAsync` argument is of type {@link @frak-labs/core-sdk!actions.SiweAuthenticateModalParams | `SiweAuthenticateModalParams`}
+ * The `data` result is a {@link @frak-labs/core-sdk!index.SiweAuthenticateReturnType | `SiweAuthenticateReturnType`}
+ *
+ * @see {@link @frak-labs/core-sdk!actions.siweAuthenticate | `siweAuthenticate()`} for more info about the underlying action
+ * @see {@link @tanstack/react-query!useMutation | `useMutation()`} for more info about the mutation options and response
+ */
+declare function useSiweAuthenticate({ mutations, }?: UseSiweAuthenticateParams): _tanstack_react_query.UseMutationResult<SiweAuthenticateReturnType, FrakRpcError<undefined>, SiweAuthenticateModalParams, unknown>;
+
+/**
+ * Helper hook to automatically submit a referral interaction when detected
+ *
+ * @group hooks
+ *
+ * @param args
+ * @param args.productId - The product id to interact with (if not specified will be recomputed from the current domain)
+ * @param args.modalConfig - The modal configuration to display if the user is not logged in
+ * @param args.options - Some options for the referral interaction
+ *
+ * @returns  The resulting referral state, or a potential error
+ *
+ * @description This function will automatically handle the referral interaction process
+ *
+ * @see {@link @frak-labs/core-sdk!actions.processReferral | `processReferral()`} for more details on the automatic referral handling process
+ */
+declare function useReferralInteraction({ productId, modalConfig, options, }?: {
+    productId?: Hex;
+    modalConfig?: DisplayModalParamsType<ModalStepTypes[]>;
+    options?: ProcessReferralOptions;
+}): Error | ("error" | "no-referrer" | "idle" | "processing" | "success" | "no-wallet" | "no-session" | "self-referral");
+
+/** @ignore */
+type MutationOptions$2 = Omit<UseMutationOptions<SendInteractionReturnType, FrakRpcError, SendInteractionParamsType>, "mutationFn" | "mutationKey">;
+/** @inline */
+interface UseSendInteractionParams$1 {
+    /**
+     * Optional mutation options, see {@link @tanstack/react-query!useMutation | `useMutation()`} for more infos
+     */
+    mutations?: MutationOptions$2;
+}
+/**
+ * Hook that return a mutation helping to send a user interaction
+ *
+ * It's a {@link @tanstack/react-query!home | `tanstack`} wrapper around the {@link @frak-labs/core-sdk!actions.sendInteraction | `sendInteraction()`} action
+ *
+ * @param args
+ *
+ * @group hooks
+ *
+ * @returns
+ * The mutation hook wrapping the `sendInteraction()` action
+ * The `mutate` and `mutateAsync` argument is of type {@link @frak-labs/core-sdk!index.SendInteractionParamsType | `SendInteractionParamsType`}
+ * The `data` result is a {@link @frak-labs/core-sdk!index.SendInteractionReturnType | `SendInteractionReturnType`}
+ *
+ * @see {@link @frak-labs/core-sdk!actions.sendInteraction | `sendInteraction()`} for more info about the underlying action
+ * @see {@link @tanstack/react-query!useMutation | `useMutation()`} for more info about the mutation options and response
+ */
+declare function useSendInteraction({ mutations, }?: UseSendInteractionParams$1): _tanstack_react_query.UseMutationResult<SendInteractionReturnType, FrakRpcError<undefined>, SendInteractionParamsType, unknown>;
+
+/** @ignore */
+type MutationOptions$1<T extends ModalStepTypes[]> = Omit<UseMutationOptions<ModalRpcStepsResultType<T>, FrakRpcError, DisplayModalParamsType<T>>, "mutationFn" | "mutationKey">;
+/** @inline */
+interface UseDisplayModalParams<T extends ModalStepTypes[] = ModalStepTypes[]> {
+    /**
+     * Optional mutation options, see {@link @tanstack/react-query!useMutation | `useMutation()`} for more infos
+     */
+    mutations?: MutationOptions$1<T>;
+}
+/**
+ * Hook that return a mutation helping to display a modal to the user
+ *
+ * It's a {@link @tanstack/react-query!home | `tanstack`} wrapper around the {@link @frak-labs/core-sdk!actions.displayModal | `displayModal()`} action
+ *
+ * @param args
+ *
+ * @typeParam T
+ * The modal steps types to display (the result will correspond to the steps types asked in params)
+ * An array of {@link @frak-labs/core-sdk!index.ModalStepTypes | `ModalStepTypes`}
+ * If not provided, it will default to a generic array of `ModalStepTypes`
+ *
+ * @group hooks
+ *
+ * @returns
+ * The mutation hook wrapping the `displayModal()` action
+ * The `mutate` and `mutateAsync` argument is of type {@link @frak-labs/core-sdk!index.DisplayModalParamsType | `DisplayModalParamsType<T>`}, with type params `T` being the modal steps types to display
+ * The `data` result is a {@link @frak-labs/core-sdk!index.ModalRpcStepsResultType | `ModalRpcStepsResultType`}
+ *
+ * @see {@link @frak-labs/core-sdk!actions.displayModal | `displayModal()`} for more info about the underlying action
+ * @see {@link @tanstack/react-query!useMutation | `useMutation()`} for more info about the mutation options and response
+ */
+declare function useDisplayModal<T extends ModalStepTypes[] = ModalStepTypes[]>({ mutations, }?: UseDisplayModalParams<T>): _tanstack_react_query.UseMutationResult<ModalRpcStepsResultType<T>, FrakRpcError<undefined>, DisplayModalParamsType<T>, unknown>;
+
+/** @ignore */
+type MutationOptions = Omit<UseMutationOptions<void, FrakRpcError, OpenSsoParamsType>, "mutationFn" | "mutationKey">;
+/** @inline */
+interface UseSendInteractionParams {
+    /**
+     * Optional mutation options, see {@link @tanstack/react-query!useMutation | `useMutation()`} for more infos
+     */
+    mutations?: MutationOptions;
+}
+/**
+ * Hook that return a mutation helping to open the SSO page
+ *
+ * It's a {@link @tanstack/react-query!home | `tanstack`} wrapper around the {@link @frak-labs/core-sdk!actions.openSso | `openSso()`} action
+ *
+ * @param args
+ *
+ * @group hooks
+ *
+ * @returns
+ * The mutation hook wrapping the `openSso()` action
+ * The `mutate` and `mutateAsync` argument is of type {@link @frak-labs/core-sdk!index.OpenSsoParamsType | `OpenSsoParamsType`}
+ * The mutation doesn't output any value
+ *
+ * @see {@link @frak-labs/core-sdk!actions.openSso | `openSso()`} for more info about the underlying action
+ * @see {@link @tanstack/react-query!useMutation | `useMutation()`} for more info about the mutation options and response
+ */
+declare function useOpenSso({ mutations }?: UseSendInteractionParams): _tanstack_react_query.UseMutationResult<void, FrakRpcError<undefined>, OpenSsoParamsType, unknown>;
+
+/** @ignore */
+type QueryOptions = Omit<UseQueryOptions<GetProductInformationReturnType, FrakRpcError, undefined>, "queryKey" | "queryFn">;
+/** @inline */
+interface UseGetProductInformationParams {
+    /**
+     * Optional query options, see {@link @tanstack/react-query!useQuery | `useQuery()`} for more infos
+     */
+    query?: QueryOptions;
+}
+/**
+ * Hook that return a query helping to get the current product information
+ *
+ * It's a {@link @tanstack/react-query!home | `tanstack`} wrapper around the {@link @frak-labs/core-sdk!actions.getProductInformation | `getProductInformation()`} action
+ *
+ * @param args
+ *
+ * @group hooks
+ *
+ * @returns
+ * The query hook wrapping the `getProductInformation()` action
+ * The `data` result is a {@link @frak-labs/core-sdk!index.GetProductInformationReturnType | `GetProductInformationReturnType`}
+ *
+ * @see {@link @frak-labs/core-sdk!actions.getProductInformation | `getProductInformation()`} for more info about the underlying action
+ * @see {@link @tanstack/react-query!useQuery | `useQuery()`} for more info about the useQuery options and response
+ */
+declare function useGetProductInformation({ query, }?: UseGetProductInformationParams): _tanstack_react_query.UseQueryResult<undefined, FrakRpcError<undefined>>;
+
+export { FrakConfigContext, FrakConfigProvider, type FrakConfigProviderProps, FrakIFrameClientContext, type FrakIFrameClientProps, FrakIFrameClientProvider, useDisplayModal, useFrakClient, useFrakConfig, useGetProductInformation, useOpenSso, useReferralInteraction, useSendInteraction, useSendTransactionAction, useSiweAuthenticate, useWalletStatus };