@frak-labs/core-sdk 0.0.7 → 0.0.8

package/dist/actions.d.cts

@@ -0,0 +1,1285 @@
+import type { Address } from 'viem';
+import { Hex } from 'viem';
+import type { Prettify } from 'viem/chains';
+import type { RpcSchema } from 'viem';
+import type { SiweMessage } from 'viem/siwe';
+
+/**
+ * Function used to display the Frak embeded wallet popup
+ * @param client - The current Frak Client
+ * @param params - The parameter used to customise the embeded wallet
+ */
+export declare function displayEmbededWallet(client: FrakClient, params: DisplayEmbededWalletParamsType): Promise<void>;
+
+/**
+ * The params used to display the embeded wallet
+ *
+ * @group Embeded wallet
+ */
+declare type DisplayEmbededWalletParamsType = {
+    /**
+     * The embeded view to display once the user is logged in
+     */
+    loggedIn?: LoggedInEmbededView;
+    /**
+     * The embeded view to display once the user is logged out
+     */
+    loggedOut?: LoggedOutEmbededView;
+    /**
+     * Some metadata to customise the embeded view
+     */
+    metadata?: {
+        /**
+         * Language of the embeded wallet
+         * If undefined, will default to the browser language
+         */
+        lang?: "fr" | "en";
+        /**
+         * The logo to display on the embeded wallet
+         * If undefined, will default to no logo displayed
+         */
+        logo?: string;
+        /**
+         * Link to the homepage of the calling website
+         * If unedfined, will default to the domain of the calling website
+         */
+        homepageLink?: string;
+        /**
+         * The target interaction behind this modal
+         */
+        targetInteraction?: FullInteractionTypesKey;
+        /**
+         * The position of the component
+         */
+        position?: "left" | "right";
+    };
+};
+
+/**
+ * Function used to display a modal
+ * @param client - The current Frak Client
+ * @param args
+ * @param args.steps - The different steps of the modal
+ * @param args.metadata - The metadata for the modal (customisation, language etc)
+ * @returns The result of each modal steps
+ *
+ * @description This function will display a modal to the user with the provided steps and metadata.
+ *
+ * @remarks
+ * - The UI of the displayed modal can be configured with the `customCss` property in the `metadata.css` field of the top-level config.
+ * - The `login` and `openSession` steps will be automatically skipped if the user is already logged in or has an active session. It's safe to include these steps in all cases to ensure proper user state.
+ * - Steps are automatically reordered in the following sequence:
+ *     1. `login` (if needed)
+ *     2. `openSession` (if needed)
+ *     3. All other steps in the order specified
+ *     4. `success` (if included, always last)
+ *
+ * @example
+ * Simple sharing modal with steps:
+ *  1. Login (Skipped if already logged in)
+ *  2. Open a session (Skipped if already opened)
+ *  3. Display a success message with sharing link option
+ *
+ * ```ts
+ * const results = await displayModal(frakConfig, {
+ *     steps: {
+ *         // Simple login with no SSO, nor customisation
+ *         login: { allowSso: false },
+ *         // Simple session opening, with no customisation
+ *         openSession: {},
+ *         // Success message
+ *         final: {
+ *             action: { key: "reward" },
+ *             // Skip this step, it will be only displayed in the stepper within the modal
+ *             autoSkip: true,
+ *         },
+ *     },
+ * });
+ *
+ * console.log("Login step - wallet", results.login.wallet);
+ * console.log("Open session step - start + end", {
+ *     start: results.openSession.startTimestamp,
+ *     end: results.openSession.endTimestamp,
+ * });
+ * ```
+ *
+ * @example
+ * A full modal example, with a few customisation options, with the steps:
+ *  1. Login (Skipped if already logged in)
+ *  2. Open a session (Skipped if already opened)
+ *  3. Authenticate via SIWE
+ *  4. Send a transaction
+ *  5. Display a success message with sharing link options
+ *
+ * ```ts
+ * const results = await displayModal(frakConfig, {
+ *     steps: {
+ *         // Login step
+ *         login: {
+ *             allowSso: true,
+ *             ssoMetadata: {
+ *                 logoUrl: "https://my-app.com/logo.png",
+ *                 homepageLink: "https://my-app.com",
+ *             },
+ *             metadata: {
+ *                 // Modal title on desktop
+ *                 title: "Login on My-App",
+ *                 // Modal description (and yep it accept markdown)
+ *                 description: "## Please login to continue",
+ *                 // Primary button text
+ *                 primaryActionText: "Register",
+ *                 // Secondary button text
+ *                 secondaryActionText: "Login",
+ *             },
+ *         },
+ *         // Simple session opening, with no customisation
+ *         openSession: {},
+ *         // Siwe authentication
+ *         siweAuthenticate: {
+ *             siwe: {
+ *                 domain: "my-app.com",
+ *                 uri: "https://my-app.com/",
+ *                 nonce: generateSiweNonce(),
+ *                 version: "1",
+ *             },
+ *             metadata: {
+ *                 title: "Authenticate with SIWE",
+ *                 description: "Please authenticate with SIWE to continue",
+ *                 primaryActionText: "Authenticate",
+ *             },
+ *         },
+ *         // Send batched transaction
+ *         sendTransaction: {
+ *             tx: [
+ *                 { to: "0xdeadbeef", data: "0xdeadbeef" },
+ *                 { to: "0xdeadbeef", data: "0xdeadbeef" },
+ *             ],
+ *             metadata: {
+ *                 title: "Send a transaction",
+ *                 description: "Please send a transaction to continue",
+ *             },
+ *         },
+ *         // Success message with sharing options
+ *         final: {
+ *             action: {
+ *                 key: "sharing",
+ *                 options: {
+ *                     popupTitle: "Share the app",
+ *                     text: "Discover my super app website",
+ *                     link: "https://my-app.com",
+ *                 },
+ *             },
+ *             dismissedMetadata: {
+ *                 title: "Dismiss",
+ *                 description: "You won't be rewarded for this sharing action",
+ *             },
+ *         },
+ *     },
+ *     metadata: {
+ *         // Header of desktop modals
+ *         header: {
+ *             title: "My-App",
+ *             icon: "https://my-app.com/logo.png",
+ *         },
+ *         // Context that will be present in every modal steps
+ *         context: "My-app overkill flow",
+ *         // Language of the modal
+ *         lang: "fr",
+ *     },
+ * });
+ * ```
+ */
+export declare function displayModal<T extends ModalStepTypes[] = ModalStepTypes[]>(client: FrakClient, { steps, metadata }: DisplayModalParamsType<T>): Promise<ModalRpcStepsResultType<T>>;
+
+/**
+ * Params used to display a modal
+ * @typeParam T - The list of modal steps we expect to have in the modal
+ * @group Modal Display
+ */
+declare type DisplayModalParamsType<T extends ModalStepTypes[]> = {
+    steps: ModalRpcStepsInput<T>;
+    metadata?: ModalRpcMetadata;
+};
+
+/**
+ * The different type of action we can have on the embeded view (once the user is logged in)
+ *
+ * @group Embeded wallet
+ */
+declare type EmbededViewAction = {
+    key: "sharing";
+    /**
+     * Some sharing options
+     */
+    options?: {
+        /**
+         * The title that will be displayed on the system popup once the system sharing window is open
+         */
+        popupTitle?: string;
+        /**
+         * The text that will be shared alongside the link.
+         * Can contain the variable {LINK} to specify where the link is placed, otherwise it will be added at the end
+         */
+        text?: string;
+        /**
+         * The link to be shared (will be suffixed with the Frak sharing context)
+         */
+        link?: string;
+    };
+};
+
+/**
+ * Type that extract the possible return type from a RPC Schema
+ * @ignore
+ */
+declare type ExtractedMethodFromRpc<TRpcSchema extends RpcSchema, TMethod extends ExtractedParametersFromRpc<TRpcSchema>["method"] = ExtractedParametersFromRpc<TRpcSchema>["method"]> = Extract<TRpcSchema[number], {
+    Method: TMethod;
+}>;
+
+/**
+ * Type that extract the possible parameters from a RPC Schema
+ * @ignore
+ */
+declare type ExtractedParametersFromRpc<TRpcSchema extends RpcSchema> = {
+    [K in keyof TRpcSchema]: Prettify<{
+        method: TRpcSchema[K] extends TRpcSchema[number] ? TRpcSchema[K]["Method"] : string;
+    } & (TRpcSchema[K] extends TRpcSchema[number] ? TRpcSchema[K]["Parameters"] extends undefined ? {
+        params?: never;
+    } : {
+        params: TRpcSchema[K]["Parameters"];
+    } : never)>;
+}[number];
+
+/**
+ * Type that extract the possible return type from a RPC Schema
+ * @ignore
+ */
+declare type ExtractedReturnTypeFromRpc<TRpcSchema extends RpcSchema, TParameters extends ExtractedParametersFromRpc<TRpcSchema> = ExtractedParametersFromRpc<TRpcSchema>> = ExtractedMethodFromRpc<TRpcSchema, TParameters["method"]>["ReturnType"];
+
+/**
+ * The different types of final actions we can display in the final step
+ * @group Modal Display
+ */
+declare type FinalActionType = {
+    key: "sharing";
+    options?: {
+        popupTitle?: string;
+        text?: string;
+        link?: string;
+    };
+} | {
+    key: "reward";
+    options?: never;
+};
+
+/**
+ * The final modal step type, could be used to display sharing options or a success reward screen.
+ *
+ * **Input**: What type final step to display?
+ * **Output**: None
+ *
+ * @group Modal Display
+ */
+declare type FinalModalStepType = GenericModalStepType<"final", {
+    dismissedMetadata?: ModalStepMetadata["metadata"];
+    action: FinalActionType;
+    autoSkip?: boolean;
+}, object>;
+
+/**
+ * Representing a Frak client, used to interact with the Frak Wallet
+ */
+declare type FrakClient = {
+    config: FrakWalletSdkConfig;
+    debugInfo: {
+        formatDebugInfo: (error: Error | unknown | string) => string;
+    };
+} & IFrameTransport;
+
+/**
+ * The current Frak Context
+ *
+ * For now, only contain a referrer address.
+ */
+declare type FrakContext = {
+    r: Address;
+};
+
+/**
+ * Configuration for the Nexus Wallet SDK
+ */
+declare type FrakWalletSdkConfig = {
+    /**
+     * The Frak wallet url
+     * @defaultValue "https://wallet.frak.id"
+     */
+    walletUrl?: string;
+    /**
+     * Some metadata about your implementation of the Frak SDK
+     */
+    metadata: {
+        /**
+         * Your application name (will be displayed in a few modals and in SSO)
+         */
+        name: string;
+        /**
+         * Custom CSS styles to apply to the modals and components
+         */
+        css?: string;
+    };
+    /**
+     * The domain name of your application
+     * @defaultValue window.location.host
+     */
+    domain?: string;
+};
+
+/**
+ * The keys for each interaction types (e.g. `press.openArticle`) -> category_type.interaction_type
+ * @inline
+ */
+declare type FullInteractionTypesKey = {
+    [Category in keyof typeof interactionTypes]: `${Category & string}.${keyof (typeof interactionTypes)[Category] & string}`;
+}[keyof typeof interactionTypes];
+
+/**
+ * Represent a generic modal step type
+ * @ignore
+ * @inline
+ */
+declare type GenericModalStepType<TKey, TParams, TReturns> = {
+    key: TKey;
+    params: TParams extends never ? ModalStepMetadata : ModalStepMetadata & TParams;
+    returns: TReturns;
+};
+
+/**
+ * Function used to get the current product information
+ * @param client - The current Frak Client
+ * @returns The product information in a promise
+ */
+export declare function getProductInformation(client: FrakClient): Promise<GetProductInformationReturnType>;
+
+/**
+ * Response of the `frak_getProductInformation` RPC method
+ * @group RPC Schema
+ */
+declare type GetProductInformationReturnType = {
+    /**
+     * Current product id
+     */
+    id: Hex;
+    /**
+     * Some metadata
+     */
+    onChainMetadata: {
+        /**
+         * Name of the product on-chain
+         */
+        name: string;
+        /**
+         * Domain of the product on-chain
+         */
+        domain: string;
+        /**
+         * The supported product types
+         */
+        productTypes: ProductTypesKey[];
+    };
+    /**
+     * The max potential reward in EUR for the given product
+     */
+    estimatedEurReward?: string;
+    /**
+     * List of all the potentials reward arround this product
+     */
+    rewards: {
+        token: Address;
+        campaign: Address;
+        interactionTypeKey: FullInteractionTypesKey;
+        referrer: {
+            amount: number;
+            eurAmount: number;
+            usdAmount: number;
+        };
+        referee: {
+            amount: number;
+            eurAmount: number;
+            usdAmount: number;
+        };
+    }[];
+};
+
+/**
+ * RPC interface that's used for the iframe communication
+ *
+ * Define all the methods available within the iFrame RPC client
+ *
+ * @group RPC Schema
+ *
+ * @remarks
+ * Here is the list of methods available:
+ *
+ * ### frak_listenToWalletStatus
+ *  - Params: None
+ *  - Returns: {@link WalletStatusReturnType}
+ *
+ * ### frak_displayModal
+ * - Params: [{@link ModalRpcStepsInput}, name: string, metadata?: {@link ModalRpcMetadata}]
+ * - Returns: {@link ModalRpcStepsResultType}
+ *
+ * ### frak_sendInteraction
+ *  - Params: [productId: Hex, interaction: {@link PreparedInteraction}, signature?: Hex]
+ *  - Returns: {@link SendInteractionReturnType}
+ *
+ * ### frak_sso
+ *  - Params [params: {@link OpenSsoParamsType}, name: string, customCss?: string]
+ *  - Returns: undefined
+ *
+ *  ### frak_getProductInformation
+ *  - Params: None
+ *  - Returns: {@link GetProductInformationReturnType}
+ *
+ * ### frak_displayEmbededWallet
+ * - Params: [{@link DisplayEmbededWalletParamsType}]
+ * - Returns: undefined
+ */
+declare type IFrameRpcSchema = [
+/**
+* Method used to listen to the wallet status
+*/
+    {
+    Method: "frak_listenToWalletStatus";
+    Parameters?: undefined;
+    ReturnType: WalletStatusReturnType;
+},
+/**
+* Method to display a modal with the provided steps
+*/
+    {
+    Method: "frak_displayModal";
+    Parameters: [
+    requests: ModalRpcStepsInput,
+    name: string,
+    metadata?: ModalRpcMetadata
+    ];
+    ReturnType: ModalRpcStepsResultType;
+},
+/**
+* Method to transmit a user interaction
+*/
+    {
+    Method: "frak_sendInteraction";
+    Parameters: [
+    productId: Hex,
+    interaction: PreparedInteraction,
+    signature?: Hex
+    ];
+    ReturnType: SendInteractionReturnType;
+},
+/**
+* Method to start a SSO
+*  todo: Should also support direct tracking via a consumeKey
+*/
+    {
+    Method: "frak_sso";
+    Parameters: [
+    params: OpenSsoParamsType,
+    name: string,
+    customCss?: string
+    ];
+    ReturnType: undefined;
+},
+/**
+* Method to get current product information's
+*  - Is product minted?
+*  - Does it have running campaign?
+*  - Estimated reward on actions
+*/
+    {
+    Method: "frak_getProductInformation";
+    Parameters?: undefined;
+    ReturnType: GetProductInformationReturnType;
+},
+/**
+* Method to show the embeded wallet, with potential customisation
+*/
+    {
+    Method: "frak_displayEmbededWallet";
+    Parameters: [DisplayEmbededWalletParamsType, name: string];
+    ReturnType: undefined;
+}
+];
+
+/**
+ * IFrame transport interface
+ */
+declare type IFrameTransport = {
+    /**
+     * Wait for the connection to be established
+     */
+    waitForConnection: Promise<boolean>;
+    /**
+     * Wait for the setup to be done
+     */
+    waitForSetup: Promise<void>;
+    /**
+     * Function used to perform a single request via the iframe transport
+     */
+    request: RequestFn<IFrameRpcSchema>;
+    /**
+     * Function used to listen to a request response via the iframe transport
+     */
+    listenerRequest: ListenerRequestFn<IFrameRpcSchema>;
+    /**
+     * Function used to destroy the iframe transport
+     */
+    destroy: () => Promise<void>;
+};
+
+/**
+ * Each interactions types according to the product types
+ */
+declare const interactionTypes: {
+    readonly press: {
+        readonly openArticle: "0xc0a24ffb";
+        readonly readArticle: "0xd5bd0fbe";
+    };
+    readonly dapp: {
+        readonly proofVerifiableStorageUpdate: "0x2ab2aeef";
+        readonly callableVerifiableStorageUpdate: "0xa07da986";
+    };
+    readonly webshop: {
+        readonly open: "0xb311798f";
+    };
+    readonly referral: {
+        readonly referred: "0x010cc3b9";
+        readonly createLink: "0xb2c0f17c";
+    };
+    readonly purchase: {
+        readonly started: "0xd87e90c3";
+        readonly completed: "0x8403aeb4";
+        readonly unsafeCompleted: "0x4d5b14e0";
+    };
+    readonly retail: {
+        readonly customerMeeting: "0x74489004";
+    };
+};
+
+/**
+ * Type used for a listening request
+ * @inline
+ */
+declare type ListenerRequestFn<TRpcSchema extends RpcSchema> = <TParameters extends ExtractedParametersFromRpc<TRpcSchema> = ExtractedParametersFromRpc<TRpcSchema>, _ReturnType = ExtractedReturnTypeFromRpc<TRpcSchema, TParameters>>(args: TParameters, callback: (result: _ReturnType) => void) => Promise<void>;
+
+/**
+ * Some configuration options for the embeded view
+ *
+ * @group Embeded wallet
+ */
+declare type LoggedInEmbededView = {
+    /**
+     * The main action to display on the logged in embeded view
+     *  If none specified, the user will see his wallet with the activation button
+     */
+    action?: EmbededViewAction;
+};
+
+/**
+ * The view when a user is logged out
+ * @group Embeded wallet
+ */
+declare type LoggedOutEmbededView = {
+    /**
+     * Metadata option when displaying the embeded view
+     */
+    metadata?: {
+        /**
+         * The main CTA for the logged out view
+         *  - can include some variable, available ones are:
+         *      - {REWARD} -> The maximum reward a user can receive when itneracting on your website
+         *  - can be formatted in markdown
+         *
+         * If not sert, it will default to a internalised message
+         */
+        text?: string;
+        /**
+         * The text that will be displayed on the login button
+         *
+         * If not set, it will default to a internalised message
+         */
+        buttonText?: string;
+    };
+};
+
+/**
+ * The login step for a Modal
+ *
+ * **Input**: Do we allow SSO or not? Is yes then the SSO metadata
+ * **Output**: The logged in wallet address
+ *
+ * @group Modal Display
+ */
+declare type LoginModalStepType = GenericModalStepType<"login", LoginWithSso | LoginWithoutSso, {
+    wallet: Address;
+}>;
+
+/** @inline */
+declare type LoginWithoutSso = {
+    allowSso?: false;
+    ssoMetadata?: never;
+};
+
+/** @inline */
+declare type LoginWithSso = {
+    allowSso: true;
+    ssoMetadata: SsoMetadata;
+};
+
+/**
+ * Represent the output type of the modal builder
+ */
+export declare type ModalBuilder = ModalStepBuilder<[
+LoginModalStepType,
+OpenInteractionSessionModalStepType
+]>;
+
+/**
+ * Helper to craft Frak modal, and share a base initial config
+ * @param client - The current Frak Client
+ * @param args
+ * @param args.metadata - Common modal metadata (customisation, language etc)
+ * @param args.login - Login step parameters
+ * @param args.openSession - Open session step parameters
+ *
+ * @description This function will create a modal builder with the provided metadata, login and open session parameters.
+ *
+ * @example
+ * Here is an example of how to use the `modalBuilder` to create and display a sharing modal:
+ *
+ * ```js
+ * // Create the modal builder
+ * const modalBuilder = window.FrakSDK.modalBuilder(frakClient, baseModalConfig);
+ *
+ * // Configure the information to be shared via the sharing link
+ * const sharingConfig = {
+ *   popupTitle: "Share this with your friends",
+ *   text: "Discover our product!",
+ *   link: window.location.href,
+ * };
+ *
+ * // Display the sharing modal
+ * function modalShare() {
+ *   modalBuilder.sharing(sharingConfig).display();
+ * }
+ * ```
+ *
+ * @see {@link ModalStepTypes} for more info about each modal step types and their parameters
+ * @see {@link ModalRpcMetadata} for more info about the metadata that can be passed to the modal
+ * @see {@link ModalRpcStepsResultType} for more info about the result of each modal steps
+ * @see {@link displayModal} for more info about how the modal is displayed
+ */
+export declare function modalBuilder(client: FrakClient, { metadata, login, openSession, }: {
+    metadata?: ModalRpcMetadata;
+    login?: LoginModalStepType["params"];
+    openSession?: OpenInteractionSessionModalStepType["params"];
+}): ModalBuilder;
+
+/**
+ * RPC metadata for the modal, used on top level modal configuration
+ * @group Modal Display
+ * @group RPC Schema
+ */
+declare type ModalRpcMetadata = {
+    header?: {
+        title?: string;
+        icon?: string;
+    };
+    context?: string;
+    lang?: "en" | "fr";
+    targetInteraction?: FullInteractionTypesKey;
+} & ({
+    isDismissible: true;
+    dismissActionTxt?: string;
+} | {
+    isDismissible?: false;
+    dismissActionTxt?: never;
+});
+
+/**
+ * Type for the RPC input of a modal
+ * Just the `params` type of each `ModalStepTypes`
+ * @typeParam T - The list of modal steps we expect to have in the modal
+ * @group Modal Display
+ * @group RPC Schema
+ */
+declare type ModalRpcStepsInput<T extends ModalStepTypes[] = ModalStepTypes[]> = {
+    [K in T[number]["key"]]?: Extract<T[number], {
+        key: K;
+    }>["params"];
+};
+
+/**
+ * Type for the result of a modal request
+ * Just the `returns` type of each `ModalStepTypes`
+ * @typeParam T - The list of modal steps we expect to have in the modal
+ * @group Modal Display
+ * @group RPC Schema
+ */
+declare type ModalRpcStepsResultType<T extends ModalStepTypes[] = ModalStepTypes[]> = {
+    [K in T[number]["key"]]: Extract<T[number], {
+        key: K;
+    }>["returns"];
+};
+
+/**
+ * Represent the type of the modal step builder
+ */
+export declare type ModalStepBuilder<Steps extends ModalStepTypes[] = ModalStepTypes[]> = {
+    /**
+     * The current modal params
+     */
+    params: DisplayModalParamsType<Steps>;
+    /**
+     * Add a send transaction step to the modal
+     */
+    sendTx: (options: SendTransactionModalStepType["params"]) => ModalStepBuilder<[...Steps, SendTransactionModalStepType]>;
+    /**
+     * Add a final step of type reward to the modal
+     */
+    reward: (options?: Omit<FinalModalStepType["params"], "action">) => ModalStepBuilder<[...Steps, FinalModalStepType]>;
+    /**
+     * Add a final step of type sharing to the modal
+     */
+    sharing: (sharingOptions?: Extract<FinalActionType, {
+        key: "sharing";
+    }>["options"], options?: Omit<FinalModalStepType["params"], "action">) => ModalStepBuilder<[...Steps, FinalModalStepType]>;
+    /**
+     * Display the modal
+     * @param metadataOverride - Function returning optional metadata to override the current modal metadata
+     */
+    display: (metadataOverride?: (current?: ModalRpcMetadata) => ModalRpcMetadata | undefined) => Promise<ModalRpcStepsResultType<Steps>>;
+};
+
+/**
+ * Metadata that can be used to customise a modal step
+ * @group Modal Display
+ */
+declare type ModalStepMetadata = {
+    metadata?: {
+        /**
+         * Custom title for the step
+         * If none provided, it will use an internationalised text
+         */
+        title?: string;
+        /**
+         * Custom description for the step
+         * If none provided, it will use an internationalised text
+         */
+        description?: string;
+        /**
+         * Custom text for the primary action of the step
+         * If none provided, it will use an internationalised text
+         */
+        primaryActionText?: string;
+        /**
+         * Custom text for the secondary action of the step
+         * If none provided, it will use an internationalised text
+         */
+        secondaryActionText?: string;
+    };
+};
+
+/**
+ * Generic type of steps we will display in the modal to the end user
+ * @group Modal Display
+ */
+declare type ModalStepTypes = LoginModalStepType | SiweAuthenticateModalStepType | SendTransactionModalStepType | OpenInteractionSessionModalStepType | FinalModalStepType;
+
+/**
+ * The open interaction session step for a Modal
+ *
+ * **Input**: None
+ * **Output**: The interactions session period (start and end timestamp)
+ *
+ * @group Modal Display
+ */
+declare type OpenInteractionSessionModalStepType = GenericModalStepType<"openSession", object, OpenInteractionSessionReturnType>;
+
+/**
+ * Return type of the open session modal step
+ * @inline
+ * @ignore
+ */
+declare type OpenInteractionSessionReturnType = {
+    startTimestamp: number;
+    endTimestamp: number;
+};
+
+/**
+ * Function used to open the SSO
+ * @param client - The current Frak Client
+ * @param args - The SSO parameters
+ *
+ * @description This function will open the SSO with the provided parameters.
+ *
+ * @example
+ * First we build the sso metadata
+ * ```ts
+ * // Build the metadata
+ * const metadata: SsoMetadata = {
+ *     logoUrl: "https://my-app.com/logo.png",
+ *     homepageLink: "https://my-app.com",
+ * };
+ * ```
+ *
+ * Then, either use it with direct exit (and so user is directly redirected to your website), or a custom redirect URL
+ * :::code-group
+ * ```ts [Direct exit]
+ * // Trigger an sso opening with redirection
+ * await openSso(frakConfig, {
+ *     directExit: true,
+ *     metadata,
+ * });
+ * ```
+ * ```ts [Redirection]
+ * // Trigger an sso opening within a popup with direct exit
+ * await openSso(frakConfig, {
+ *     redirectUrl: "https://my-app.com/nexus-sso",
+ *     metadata,
+ * });
+ * ```
+ * :::
+ */
+export declare function openSso(client: FrakClient, args: OpenSsoParamsType): Promise<void>;
+
+/**
+ * Params to start a SSO
+ * @group RPC Schema
+ */
+declare type OpenSsoParamsType = {
+    /**
+     * Redirect URL after the SSO (optional)
+     */
+    redirectUrl?: string;
+    /**
+     * If the SSO should directly exit after completion
+     * @defaultValue true
+     */
+    directExit?: boolean;
+    /**
+     * Language of the SSO page (optional)
+     * It will default to the current user language (or "en" if unsupported language)
+     */
+    lang?: "en" | "fr";
+    /**
+     * Custom SSO metadata
+     */
+    metadata: SsoMetadata;
+};
+
+/**
+ * Represent a prepared user interaction, ready to be sent on-chain via the wallet
+ */
+declare type PreparedInteraction = {
+    handlerTypeDenominator: Hex;
+    interactionData: Hex;
+};
+
+/**
+ * This function handle all the heavy lifting of the referral interaction process
+ *  1. Check if the user has been referred or not (if not, early exit)
+ *  2. Then check if the user is logged in or not
+ *  2.1 If not logged in, try a soft login, if it fail, display a modal for the user to login
+ *  3. Check if that's not a self-referral (if yes, early exit)
+ *  4. Check if the user has an interaction session or not
+ *  4.1 If not, display a modal for the user to open a session
+ *  5. Push the referred interaction
+ *  6. Update the current url with the right data
+ *  7. Return the resulting referral state
+ *
+ *  If any error occurs during the process, the function will catch it and return an error state
+ *
+ * @param client - The current Frak Client
+ * @param args
+ * @param args.walletStatus - The current user wallet status
+ * @param args.frakContext - The current frak context
+ * @param args.modalConfig - The modal configuration to display if the user is not logged in
+ * @param args.productId - The product id to interact with (if not specified will be recomputed from the current domain)
+ * @param args.options - Some options for the referral interaction
+ * @returns  A promise with the resulting referral state
+ *
+ * @see {@link displayModal} for more details about the displayed modal
+ * @see {@link sendInteraction} for more details on the interaction submission part
+ * @see {@link ReferralInteractionEncoder} for more details about the referred interaction
+ * @see {@link ModalStepTypes} for more details on each modal steps types
+ */
+export declare function processReferral(client: FrakClient, { walletStatus, frakContext, modalConfig, productId, options, }: {
+    walletStatus?: WalletStatusReturnType;
+    frakContext?: Partial<FrakContext> | null;
+    modalConfig?: DisplayModalParamsType<ModalStepTypes[]>;
+    productId?: Hex;
+    options?: ProcessReferralOptions;
+}): Promise<ReferralState>;
+
+/**
+ * Options for the referral auto-interaction process
+ */
+export declare type ProcessReferralOptions = {
+    /**
+     * If we want to always append the url with the frak context or not
+     * @defaultValue false
+     */
+    alwaysAppendUrl?: boolean;
+};
+
+/**
+ * List of the product types per denominator
+ */
+declare const productTypes: {
+    dapp: number;
+    press: number;
+    webshop: number;
+    retail: number;
+    referral: number;
+    purchase: number;
+};
+
+/**
+ * The keys for each product types
+ * @inline
+ */
+declare type ProductTypesKey = keyof typeof productTypes;
+
+/**
+ * Function used to display a modal
+ * @param client - The current Frak Client
+ * @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  A promise with the resulting referral state, or undefined in case of an error
+ *
+ * @description This function will automatically handle the referral interaction process
+ *
+ * @see {@link processReferral} for more details on the automatic referral handling process
+ * @see {@link ModalStepTypes} for more details on each modal steps types
+ */
+export declare function referralInteraction(client: FrakClient, { productId, modalConfig, options, }?: {
+    productId?: Hex;
+    modalConfig?: DisplayModalParamsType<ModalStepTypes[]>;
+    options?: ProcessReferralOptions;
+}): Promise<("error" | "idle" | "processing" | "success" | "no-wallet" | "no-session" | "no-referrer" | "self-referral") | undefined>;
+
+/**
+ * The different states of the referral process
+ * @inline
+ */
+declare type ReferralState = "idle" | "processing" | "success" | "no-wallet" | "no-session" | "error" | "no-referrer" | "self-referral";
+
+/**
+ * Type used for a one shot request function
+ * @inline
+ */
+declare type RequestFn<TRpcSchema extends RpcSchema> = <TParameters extends ExtractedParametersFromRpc<TRpcSchema> = ExtractedParametersFromRpc<TRpcSchema>, _ReturnType = ExtractedReturnTypeFromRpc<TRpcSchema, TParameters>>(args: TParameters) => Promise<_ReturnType>;
+
+/**
+ * Function used to send an interaction
+ * @param client - The current Frak Client
+ * @param args
+ *
+ * @example
+ * const interaction = PressInteractionEncoder.openArticle({
+ *     articleId: keccak256(toHex("article-slug")),
+ * });
+ * const { delegationId } = await sendInteraction(frakConfig, {
+ *     interaction,
+ * });
+ * console.log("Delegated interaction id", delegationId);
+ */
+export declare function sendInteraction(client: FrakClient, { productId, interaction, validation }: SendInteractionParamsType): Promise<SendInteractionReturnType>;
+
+/**
+ * Parameters that will be used to send an interaction to the blockchain
+ * @inline
+ */
+declare type SendInteractionParamsType = {
+    /**
+     * The product id where this interaction has been made
+     * @defaultValue keccak256(toHex(window.location.host))
+     */
+    productId?: Hex;
+    /**
+     * The prepared interaction, built from an Interaction Encoder
+     */
+    interaction: PreparedInteraction;
+    /**
+     * A pre-computed interaction signature
+     * If none provided, the delegated interaction validator of your product will sign it (you can manage it in the business dashboard)
+     *
+     * @defaultValue undefined
+     */
+    validation?: Hex;
+};
+
+/**
+ * Return type of the send interaction rpc request
+ * @group RPC Schema
+ */
+declare type SendInteractionReturnType = {
+    /**
+     * The id of the interaction in the interaction pool
+     */
+    delegationId: string;
+};
+
+/**
+ * Function used to send a user transaction, simple wrapper around the displayModal function to ease the send transaction process
+ * @param client - The current Frak Client
+ * @param args - The parameters
+ * @returns The hash of the transaction that was sent in a promise
+ *
+ * @description This function will display a modal to the user with the provided transaction and metadata.
+ *
+ * @example
+ * const { hash } = await sendTransaction(frakConfig, {
+ *     tx: {
+ *         to: "0xdeadbeef",
+ *         value: toHex(100n),
+ *     },
+ *     metadata: {
+ *         header: {
+ *             title: "Sending eth",
+ *         },
+ *         context: "Send 100wei to 0xdeadbeef",
+ *     },
+ * });
+ * console.log("Transaction hash:", hash);
+ */
+export declare function sendTransaction(client: FrakClient, { tx, metadata }: SendTransactionParams): Promise<SendTransactionReturnType>;
+
+/**
+ * The send transaction step for a Modal
+ *
+ * **Input**: Either a single tx or an array of tx to be sent
+ * **Output**: The hash of the tx(s) hash (in case of multiple tx, still returns a single hash because it's bundled on the wallet level)
+ *
+ * @group Modal Display
+ */
+declare type SendTransactionModalStepType = GenericModalStepType<"sendTransaction", {
+    tx: SendTransactionTxType | SendTransactionTxType[];
+}, SendTransactionReturnType>;
+
+/**
+ * Parameters to directly show a modal used to send a transaction
+ * @inline
+ */
+export declare type SendTransactionParams = {
+    /**
+     * The transaction to be sent (either a single tx or multiple ones)
+     */
+    tx: SendTransactionModalStepType["params"]["tx"];
+    /**
+     * Custom metadata to be passed to the modal
+     */
+    metadata?: ModalRpcMetadata;
+};
+
+/**
+ * Return type of the send transaction rpc request
+ * @inline
+ */
+declare type SendTransactionReturnType = {
+    hash: Hex;
+};
+
+/**
+ * Generic format representing a tx to be sent
+ */
+declare type SendTransactionTxType = {
+    to: Address;
+    data?: Hex;
+    value?: Hex;
+};
+
+/**
+ * Function used to launch a siwe authentication
+ * @param client - The current Frak Client
+ * @param args - The parameters
+ * @returns The SIWE authentication result (message + signature) in a promise
+ *
+ * @description This function will display a modal to the user with the provided SIWE parameters and metadata.
+ *
+ * @example
+ * import { siweAuthenticate } from "@frak-labs/core-sdk/actions";
+ * import { parseSiweMessage } from "viem/siwe";
+ *
+ * const { signature, message } = await siweAuthenticate(frakConfig, {
+ *     siwe: {
+ *         statement: "Sign in to My App",
+ *         domain: "my-app.com",
+ *         expirationTimeTimestamp: Date.now() + 1000 * 60 * 5,
+ *     },
+ *     metadata: {
+ *         header: {
+ *             title: "Sign in",
+ *         },
+ *         context: "Sign in to My App",
+ *     },
+ * });
+ * console.log("Parsed final message:", parseSiweMessage(message));
+ * console.log("Siwe signature:", signature);
+ */
+export declare function siweAuthenticate(client: FrakClient, { siwe, metadata }: SiweAuthenticateModalParams): Promise<SiweAuthenticateReturnType>;
+
+/**
+ * Parameter used to directly show a modal used to authenticate with SIWE
+ * @inline
+ */
+export declare type SiweAuthenticateModalParams = {
+    /**
+     * Partial SIWE params, since we can rebuild them from the SDK if they are empty
+     *
+     * If no parameters provider, some fields will be recomputed from the current configuration and environment.
+     *  - `statement` will be set to a default value
+     *  - `nonce` will be generated
+     *  - `uri` will be set to the current domain
+     *  - `version` will be set to "1"
+     *  - `domain` will be set to the current window domain
+     *
+     * @default {}
+     */
+    siwe?: Partial<SiweAuthenticationParams>;
+    /**
+     * Custom metadata to be passed to the modal
+     */
+    metadata?: ModalRpcMetadata;
+};
+
+/**
+ * The SIWE authentication step for a Modal
+ *
+ * **Input**: SIWE message parameters
+ * **Output**: SIWE result (message signed and wallet signature)
+ *
+ * @group Modal Display
+ */
+declare type SiweAuthenticateModalStepType = GenericModalStepType<"siweAuthenticate", {
+    siwe: SiweAuthenticationParams;
+}, SiweAuthenticateReturnType>;
+
+/**
+ * Return type of the Siwe transaction rpc request
+ * @inline
+ */
+declare type SiweAuthenticateReturnType = {
+    signature: Hex;
+    message: string;
+};
+
+/**
+ * Parameters used send a SIWE rpc request
+ */
+declare type SiweAuthenticationParams = Omit<SiweMessage, "address" | "chainId" | "expirationTime" | "issuedAt" | "notBefore"> & {
+    expirationTimeTimestamp?: number;
+    notBeforeTimestamp?: number;
+};
+
+/**
+ * SSO Metadata
+ */
+declare type SsoMetadata = {
+    /**
+     * URL to your client, if provided will be displayed in the SSO header
+     */
+    logoUrl?: string;
+    /**
+     * Link to your homepage, if referenced your app name will contain a link on the sso page
+     */
+    homepageLink?: string;
+};
+
+/**
+ * Function used to track the status of a purchase
+ * when a purchase is tracked, the `purchaseCompleted` interactions will be automatically send for the user when we receive the purchase confirmation via webhook.
+ *
+ * @param args.customerId - The customer id that made the purchase (on your side)
+ * @param args.orderId - The order id of the purchase (on your side)
+ * @param args.token - The token of the purchase
+ *
+ * @description This function will send a request to the backend to listen for the purchase status.
+ *
+ * @example
+ * async function trackPurchase(checkout) {
+ *   const payload = {
+ *     customerId: checkout.order.customer.id,
+ *     orderId: checkout.order.id,
+ *     token: checkout.token,
+ *   };
+ *
+ *   await trackPurchaseStatus(payload);
+ * }
+ *
+ * @remarks
+ * - The `trackPurchaseStatus` function requires the `frak-wallet-interaction-token` stored in the session storage to authenticate the request.
+ * - This function will print a warning if used in a non-browser environment or if the wallet interaction token is not available.
+ */
+export declare function trackPurchaseStatus(args: {
+    customerId: string | number;
+    orderId: string | number;
+    token: string;
+}): Promise<void>;
+
+/**
+ * @ignore
+ * @inline
+ */
+declare type WalletConnected = {
+    key: "connected";
+    wallet: Address;
+    interactionToken?: string;
+    interactionSession?: {
+        startTimestamp: number;
+        endTimestamp: number;
+    };
+};
+
+/**
+ * @ignore
+ * @inline
+ */
+declare type WalletNotConnected = {
+    key: "not-connected";
+    wallet?: never;
+    interactionToken?: never;
+    interactionSession?: never;
+};
+
+/**
+ * RPC Response for the method `frak_listenToWalletStatus`
+ * @group RPC Schema
+ */
+declare type WalletStatusReturnType = WalletConnected | WalletNotConnected;
+
+/**
+ * Function used to watch the current frak wallet status
+ * @param client - The current Frak Client
+ * @param callback - The callback that will receive any wallet status change
+ * @returns A rpomise resolving with the initial wallet status
+ *
+ * @description This function will return the current wallet status, and will listen to any change in the wallet status.
+ *
+ * @example
+ * await watchWalletStatus(frakConfig, (status: WalletStatusReturnType) => {
+ *     if (status.key === "connected") {
+ *         console.log("Wallet connected:", status.wallet);
+ *         console.log("Current interaction session:", status.interactionSession);
+ *     } else {
+ *         console.log("Wallet not connected");
+ *     }
+ * });
+ */
+export declare function watchWalletStatus(client: FrakClient, callback?: (status: WalletStatusReturnType) => void): Promise<WalletStatusReturnType>;
+
+export { }