@frak-labs/react-sdk 0.0.3

package/dist/index.d.ts

@@ -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 };

package/dist/index.js

@@ -0,0 +1,389 @@
+// src/provider/FrakConfigProvider.ts
+import { createContext, createElement } from "react";
+var FrakConfigContext = createContext(
+  void 0
+);
+function FrakConfigProvider(parameters) {
+  const { children, config } = parameters;
+  return createElement(
+    FrakConfigContext.Provider,
+    {
+      value: {
+        ...config,
+        walletUrl: config.walletUrl ?? "https://wallet.frak.id",
+        domain: config.domain ?? (typeof window !== "undefined" ? window?.location?.host : void 0) ?? "not-found"
+      }
+    },
+    children
+  );
+}
+
+// src/provider/FrakIFrameClientProvider.ts
+import {
+  baseIframeProps,
+  createIFrameFrakClient
+} from "@frak-labs/core-sdk";
+import {
+  Fragment,
+  createContext as createContext2,
+  createElement as createElement2,
+  useState as useState3
+} from "react";
+
+// src/hook/useFrakConfig.ts
+import { FrakRpcError, RpcErrorCodes } from "@frak-labs/core-sdk";
+import { useContext } from "react";
+function useFrakConfig() {
+  const config = useContext(FrakConfigContext);
+  if (!config) {
+    throw new FrakRpcError(
+      RpcErrorCodes.configError,
+      "Frak config not found"
+    );
+  }
+  return config;
+}
+
+// src/hook/useFrakClient.ts
+import { useContext as useContext2 } from "react";
+function useFrakClient() {
+  return useContext2(FrakIFrameClientContext);
+}
+
+// src/hook/useWalletStatus.ts
+import {
+  ClientNotFound
+} from "@frak-labs/core-sdk";
+import { watchWalletStatus } from "@frak-labs/core-sdk/actions";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { useCallback } from "react";
+function useWalletStatus() {
+  const queryClient = useQueryClient();
+  const client = useFrakClient();
+  const newStatusUpdated = useCallback(
+    (event) => {
+      queryClient.setQueryData(
+        ["frak-sdk", "wallet-status-listener"],
+        event
+      );
+    },
+    [queryClient]
+  );
+  return useQuery({
+    gcTime: 0,
+    staleTime: 0,
+    queryKey: ["frak-sdk", "wallet-status-listener"],
+    queryFn: async () => {
+      if (!client) {
+        throw new ClientNotFound();
+      }
+      return watchWalletStatus(client, newStatusUpdated);
+    },
+    enabled: !!client
+  });
+}
+
+// src/hook/useSendTransaction.ts
+import {
+  ClientNotFound as ClientNotFound2
+} from "@frak-labs/core-sdk";
+import {
+  sendTransaction
+} from "@frak-labs/core-sdk/actions";
+import { useMutation } from "@tanstack/react-query";
+function useSendTransactionAction({
+  mutations
+} = {}) {
+  const client = useFrakClient();
+  return useMutation({
+    ...mutations,
+    mutationKey: ["frak-sdk", "send-transaction"],
+    mutationFn: async (params) => {
+      if (!client) {
+        throw new ClientNotFound2();
+      }
+      return sendTransaction(client, params);
+    }
+  });
+}
+
+// src/hook/useSiweAuthenticate.ts
+import {
+  ClientNotFound as ClientNotFound3
+} from "@frak-labs/core-sdk";
+import {
+  siweAuthenticate
+} from "@frak-labs/core-sdk/actions";
+import { useMutation as useMutation2 } from "@tanstack/react-query";
+function useSiweAuthenticate({
+  mutations
+} = {}) {
+  const client = useFrakClient();
+  return useMutation2({
+    ...mutations,
+    mutationKey: [
+      "frak-sdk",
+      "siwe-authenticate",
+      client?.config.domain ?? "no-domain"
+    ],
+    mutationFn: async (params) => {
+      if (!client) {
+        throw new ClientNotFound3();
+      }
+      return siweAuthenticate(client, params);
+    }
+  });
+}
+
+// src/hook/helper/useReferralInteraction.ts
+import {
+  ClientNotFound as ClientNotFound4
+} from "@frak-labs/core-sdk";
+import {
+  processReferral
+} from "@frak-labs/core-sdk/actions";
+import { useQuery as useQuery2 } from "@tanstack/react-query";
+import { useMemo as useMemo3 } from "react";
+
+// src/hook/utils/useFrakContext.ts
+import { FrakContextManager } from "@frak-labs/core-sdk";
+import { useCallback as useCallback2, useMemo as useMemo2 } from "react";
+
+// src/hook/utils/useWindowLocation.ts
+import { useEffect as useEffect2, useMemo, useState as useState2 } from "react";
+
+// src/hook/utils/useMounted.ts
+import { useEffect, useState } from "react";
+function useMounted() {
+  const [mounted, setMounted] = useState(false);
+  useEffect(() => {
+    setMounted(true);
+  }, []);
+  return mounted;
+}
+
+// src/hook/utils/useWindowLocation.ts
+function useWindowLocation() {
+  const isMounted = useMounted();
+  const [location, setLocation] = useState2(
+    isMounted ? window.location : void 0
+  );
+  useEffect2(() => {
+    if (!isMounted) return;
+    function setWindowLocation() {
+      setLocation(window.location);
+    }
+    if (!location) {
+      setWindowLocation();
+    }
+    window.addEventListener("popstate", setWindowLocation);
+    return () => {
+      window.removeEventListener("popstate", setWindowLocation);
+    };
+  }, [isMounted, location]);
+  const href = useMemo(() => location?.href, [location?.href]);
+  return { location, href };
+}
+
+// src/hook/utils/useFrakContext.ts
+function useFrakContext() {
+  const { location } = useWindowLocation();
+  const frakContext = useMemo2(() => {
+    if (!location?.href) return null;
+    return FrakContextManager.parse({ url: location.href });
+  }, [location?.href]);
+  const updateContext = useCallback2(
+    (newContext) => {
+      console.log("Updating context", { newContext });
+      FrakContextManager.replaceUrl({
+        url: location?.href,
+        context: newContext
+      });
+    },
+    [location?.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
+  } = useQuery2({
+    gcTime: 0,
+    staleTime: 0,
+    queryKey: [
+      "frak-sdk",
+      "auto-referral-interaction",
+      frakContext?.r ?? "no-referrer",
+      walletStatus?.key ?? "no-wallet-status",
+      productId ?? "no-product-id"
+    ],
+    queryFn: () => {
+      if (!client) {
+        throw new ClientNotFound4();
+      }
+      return processReferral(client, {
+        walletStatus,
+        frakContext,
+        modalConfig,
+        productId,
+        options
+      });
+    },
+    enabled: !!walletStatus
+  });
+  return useMemo3(() => {
+    if (status === "pending") return "processing";
+    if (status === "error") return error;
+    return referralState || "idle";
+  }, [referralState, status, error]);
+}
+
+// src/hook/useSendInteraction.ts
+import {
+  ClientNotFound as ClientNotFound5
+} from "@frak-labs/core-sdk";
+import { sendInteraction } from "@frak-labs/core-sdk/actions";
+import { useMutation as useMutation3 } from "@tanstack/react-query";
+function useSendInteraction({
+  mutations
+} = {}) {
+  const client = useFrakClient();
+  return useMutation3({
+    ...mutations,
+    mutationKey: ["frak-sdk", "send-interaction"],
+    mutationFn: async (params) => {
+      if (!client) {
+        throw new ClientNotFound5();
+      }
+      return sendInteraction(client, params);
+    }
+  });
+}
+
+// src/hook/useDisplayModal.ts
+import {
+  ClientNotFound as ClientNotFound6
+} from "@frak-labs/core-sdk";
+import { displayModal } from "@frak-labs/core-sdk/actions";
+import { useMutation as useMutation4 } from "@tanstack/react-query";
+function useDisplayModal({
+  mutations
+} = {}) {
+  const client = useFrakClient();
+  return useMutation4({
+    ...mutations,
+    mutationKey: ["frak-sdk", "display-modal"],
+    mutationFn: async (args) => {
+      if (!client) {
+        throw new ClientNotFound6();
+      }
+      return displayModal(client, args);
+    }
+  });
+}
+
+// src/hook/useOpenSso.ts
+import {
+  ClientNotFound as ClientNotFound7
+} from "@frak-labs/core-sdk";
+import { openSso } from "@frak-labs/core-sdk/actions";
+import { useMutation as useMutation5 } from "@tanstack/react-query";
+function useOpenSso({ mutations } = {}) {
+  const client = useFrakClient();
+  return useMutation5({
+    ...mutations,
+    mutationKey: ["frak-sdk", "open-sso"],
+    mutationFn: async (params) => {
+      if (!client) {
+        throw new ClientNotFound7();
+      }
+      return openSso(client, params);
+    }
+  });
+}
+
+// src/hook/useGetProductInformation.ts
+import {
+  ClientNotFound as ClientNotFound8
+} from "@frak-labs/core-sdk";
+import { getProductInformation } from "@frak-labs/core-sdk/actions";
+import { useQuery as useQuery3 } from "@tanstack/react-query";
+function useGetProductInformation({
+  query
+} = {}) {
+  const client = useFrakClient();
+  return useQuery3({
+    ...query,
+    queryKey: ["frak-sdk", "get-product-information"],
+    queryFn: async () => {
+      if (!client) {
+        throw new ClientNotFound8();
+      }
+      return getProductInformation(client);
+    }
+  });
+}
+
+// src/provider/FrakIFrameClientProvider.ts
+var FrakIFrameClientContext = createContext2(
+  void 0
+);
+function FrakIFrameClientProvider({
+  style,
+  children
+}) {
+  const config = useFrakConfig();
+  const [client, setClient] = useState3(void 0);
+  const iFrame = createElement2("iframe", {
+    ...baseIframeProps,
+    src: `${config.walletUrl}/listener`,
+    style: style ?? baseIframeProps.style,
+    ref: (iframe) => {
+      if (!iframe || client) {
+        return;
+      }
+      setClient(
+        createIFrameFrakClient({
+          iframe,
+          config
+        })
+      );
+    }
+  });
+  const providerComponent = createElement2(
+    FrakIFrameClientContext.Provider,
+    { value: client },
+    children
+  );
+  return createElement2(Fragment, null, iFrame, providerComponent);
+}
+export {
+  FrakConfigContext,
+  FrakConfigProvider,
+  FrakIFrameClientContext,
+  FrakIFrameClientProvider,
+  useDisplayModal,
+  useFrakClient,
+  useFrakConfig,
+  useGetProductInformation,
+  useOpenSso,
+  useReferralInteraction,
+  useSendInteraction,
+  useSendTransactionAction,
+  useSiweAuthenticate,
+  useWalletStatus
+};