@frak-labs/core-sdk 0.0.15 → 0.0.17

package/dist/bundle.d.ts

@@ -0,0 +1,2022 @@
+import { Address } from 'viem';
+import { Hex } from 'viem';
+import type { OpenPanel } from '@openpanel/web';
+import type { Prettify } from 'viem/chains';
+import type { RpcSchema } from 'viem';
+import type { SiweMessage } from 'viem/siwe';
+
+/**
+ * Decode a base64url encoded string
+ * @param value The value to decode
+ * @returns The decoded value
+ */
+export declare function base64urlDecode(value: string): Uint8Array;
+
+/**
+ * Encode a buffer to a base64url encoded string
+ * @param buffer The buffer to encode
+ * @returns The encoded string
+ */
+export declare function base64urlEncode(buffer: Uint8Array): string;
+
+/**
+ * Base props for the iframe
+ * @ignore
+ */
+export declare const baseIframeProps: {
+    id: string;
+    name: string;
+    title: string;
+    allow: string;
+    style: {
+        width: string;
+        height: string;
+        border: string;
+        position: string;
+        zIndex: number;
+        top: string;
+        left: string;
+        colorScheme: string;
+    };
+};
+
+/**
+ * Event related to the iframe lifecycle
+ * @ignore
+ */
+export declare type ClientLifecycleEvent = CustomCssEvent | CustomI18nEvent | RestoreBackupEvent | HearbeatEvent | HandshakeResponse;
+
+/** @ignore */
+export declare class ClientNotFound extends FrakRpcError {
+    constructor();
+}
+
+/**
+ * Compress the current Frak context
+ * @param context - The context to be compressed
+ * @returns A compressed string containing the Frak context
+ */
+declare function compress(context?: Partial<FrakContext>): string | undefined;
+
+/**
+ * The received encoded data from a client
+ *  -> The encoded should contain a HashProtectedData once decoded
+ *  @ignore
+ */
+export declare type CompressedData = Uint8Array;
+
+/**
+ * Compress json data
+ * @param data
+ * @ignore
+ */
+export declare function compressJson(data: unknown): Uint8Array;
+
+/**
+ * Compress json data
+ * @param data
+ * @ignore
+ */
+export declare function compressJsonToB64(data: unknown): string;
+
+/**
+ * Create the Frak iframe
+ * @param args
+ * @param args.walletBaseUrl - Use `config.walletUrl` instead. Will be removed in future versions.
+ * @param args.config - The configuration object containing iframe options, including the replacement for `walletBaseUrl`.
+ */
+export declare function createIframe({ walletBaseUrl, config, }: {
+    walletBaseUrl?: string;
+    config?: FrakWalletSdkConfig;
+}): Promise<HTMLIFrameElement | undefined>;
+
+/**
+ * Create a new iframe Frak client
+ * @param args
+ * @param args.config - The configuration to use for the Frak Wallet SDK
+ * @param args.iframe - The iframe to use for the communication
+ * @returns The created Frak Client
+ *
+ * @example
+ * const frakConfig: FrakWalletSdkConfig = {
+ *     metadata: {
+ *         name: "My app title",
+ *     },
+ * }
+ * const iframe = await createIframe({ config: frakConfig });
+ * const client = createIFrameFrakClient({ config: frakConfig, iframe });
+ */
+export declare function createIFrameFrakClient({ config, iframe, }: {
+    config: FrakWalletSdkConfig;
+    iframe: HTMLIFrameElement;
+}): FrakClient;
+
+/**
+ * All the currencies available
+ * @category Config
+ */
+export declare type Currency = "eur" | "usd" | "gbp";
+
+declare type CustomCssEvent = {
+    clientLifecycle: "modal-css";
+    data: {
+        cssLink: string;
+    };
+};
+
+declare type CustomI18nEvent = {
+    clientLifecycle: "modal-i18n";
+    data: {
+        i18n: I18nConfig;
+    };
+};
+
+/** @ignore */
+export declare class DebugInfoGatherer {
+    private config?;
+    private iframe?;
+    private isSetupDone;
+    private lastResponse;
+    private lastRequest;
+    constructor(config?: FrakWalletSdkConfig, iframe?: HTMLIFrameElement);
+    setLastResponse(event: MessageEvent<IFrameEvent>): void;
+    setLastRequest(event: IFrameEvent, target: string): void;
+    updateSetupStatus(status: boolean): void;
+    private base64Encode;
+    /**
+     * Extract information from the iframe status
+     */
+    private getIframeStatus;
+    private getNavigatorInfo;
+    private gatherDebugInfo;
+    static empty(): DebugInfoGatherer;
+    /**
+     * Format Frak debug information
+     */
+    formatDebugInfo(error: Error | unknown | string): string;
+}
+
+/**
+ * Decompress the given Frak context
+ * @param context - The raw context to be decompressed into a `FrakContext`
+ * @returns The decompressed Frak context, or undefined if it fails
+ */
+declare function decompress(context?: string): FrakContext | undefined;
+
+/**
+ * Decompress the given string
+ * @param compressedData The params to encode
+ * @ignore
+ */
+export declare function decompressDataAndCheckHash<T>(compressedData: CompressedData): HashProtectedData<T>;
+
+/**
+ * Decompress json data
+ * @param data
+ * @ignore
+ */
+export declare function decompressJson<T>(data: Uint8Array): T | null;
+
+/**
+ * Decompress json data
+ * @param data
+ * @ignore
+ */
+export declare function decompressJsonFromB64<T>(data: string): T | null;
+
+/**
+ * Simple deferred promise wrapper
+ * @ignore
+ */
+export declare class Deferred<T> {
+    private readonly _promise;
+    private _resolve;
+    private _reject;
+    constructor();
+    get promise(): Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: unknown) => void;
+}
+
+/**
+ * Function used to display the Frak embedded wallet popup
+ * @param client - The current Frak Client
+ * @param params - The parameter used to customise the embedded wallet
+ */
+export declare function displayEmbeddedWallet(client: FrakClient, params: DisplayEmbeddedWalletParamsType): Promise<DisplayEmbeddedWalletResultType>;
+
+/**
+ * The params used to display the embedded wallet
+ *
+ * @group Embedded wallet
+ */
+export declare type DisplayEmbeddedWalletParamsType = {
+    /**
+     * The embedded view to display once the user is logged in
+     */
+    loggedIn?: LoggedInEmbeddedView;
+    /**
+     * The embedded view to display once the user is logged out
+     */
+    loggedOut?: LoggedOutEmbeddedView;
+    /**
+     * Some metadata to customize the embedded view
+     */
+    metadata?: {
+        /**
+         * The logo to display on the embedded wallet
+         * If undefined, will default to no logo displayed
+         */
+        logo?: string;
+        /**
+         * Link to the homepage of the calling website
+         * If undefined, 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";
+        /**
+         * Some i18n override for the displayed modal (i.e. update the displayed text only for this modal)
+         */
+        i18n?: I18nConfig;
+    };
+};
+
+/**
+ * The result of the display embedded wallet rpc request
+ *
+ * @group Embedded wallet
+ */
+export declare type DisplayEmbeddedWalletResultType = {
+    wallet: Address;
+};
+
+/**
+ * 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 (customization, 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 `customizations.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 customization
+ *         login: { allowSso: false },
+ *         // Simple session opening, with no customization
+ *         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 customization 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",
+ *             },
+ *         },
+ *         // Simple session opening, with no customisation
+ *         openSession: {},
+ *         // Siwe authentication
+ *         siweAuthenticate: {
+ *             siwe: {
+ *                 domain: "my-app.com",
+ *                 uri: "https://my-app.com/",
+ *                 nonce: generateSiweNonce(),
+ *                 version: "1",
+ *             },
+ *         },
+ *         // Send batched transaction
+ *         sendTransaction: {
+ *             tx: [
+ *                 { to: "0xdeadbeef", data: "0xdeadbeef" },
+ *                 { to: "0xdeadbeef", data: "0xdeadbeef" },
+ *             ],
+ *         },
+ *         // 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",
+ *     },
+ * });
+ * ```
+ */
+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
+ */
+export declare type DisplayModalParamsType<T extends ModalStepTypes[]> = {
+    steps: ModalRpcStepsInput<T>;
+    metadata?: ModalRpcMetadata;
+};
+
+declare type DoBackupEvent = {
+    iframeLifecycle: "do-backup";
+    data: {
+        backup?: string;
+    };
+};
+
+/**
+ * The action to display on the logged out embedded view when the user is referred
+ *
+ * @group Embedded wallet
+ */
+export declare type EmbeddedViewActionReferred = {
+    key: "referred";
+    /**
+     * No options for a referred action
+     */
+    options?: never;
+};
+
+/**
+ * The different type of action we can have on the embedded view (once the user is logged in)
+ *
+ * @group Embedded wallet
+ */
+export declare type EmbeddedViewActionSharing = {
+    key: "sharing";
+    /**
+     * Some sharing options
+     */
+    options?: {
+        /**
+         * The title that will be displayed on the system popup once the system sharing window is open
+         * @deprecated Use the top level `config.metadata.i18n` instead
+         */
+        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
+         * @deprecated Use the top level `config.metadata.i18n` instead
+         */
+        text?: string;
+        /**
+         * The link to be shared (will be suffixed with the Frak sharing context)
+         */
+        link?: string;
+    };
+};
+
+declare type EventProps = Record<string, unknown>;
+
+/**
+ * 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
+ */
+export 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
+ */
+export 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
+ */
+export declare type FinalActionType = {
+    key: "sharing";
+    options?: {
+        /**
+         * @deprecated Use the top level `config.metadata.i18n` instead
+         */
+        popupTitle?: string;
+        /**
+         * @deprecated Use the top level `config.metadata.i18n` instead
+         */
+        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
+ */
+export declare type FinalModalStepType = GenericModalStepType<"final", {
+    dismissedMetadata?: ModalStepMetadata["metadata"];
+    action: FinalActionType;
+    autoSkip?: boolean;
+}, object>;
+
+export declare function formatAmount(amount: number, currency?: Currency): string;
+
+/**
+ * Representing a Frak client, used to interact with the Frak Wallet
+ */
+export declare type FrakClient = {
+    config: FrakWalletSdkConfig;
+    debugInfo: {
+        formatDebugInfo: (error: Error | unknown | string) => string;
+    };
+    openPanel?: OpenPanel;
+} & IFrameTransport;
+
+/**
+ * The current Frak Context
+ *
+ * For now, only contain a referrer address.
+ *
+ * @ignore
+ */
+export declare type FrakContext = {
+    r: Address;
+};
+
+/**
+ * Export our frak context "class"
+ */
+export declare const FrakContextManager: {
+    compress: typeof compress;
+    decompress: typeof decompress;
+    parse: typeof parse;
+    update: typeof update;
+    remove: typeof remove;
+    replaceUrl: typeof replaceUrl;
+};
+
+declare type FrakEvent = "share_button_clicked" | "wallet_button_clicked" | "share_modal_error" | "user_referred";
+
+/**
+ * Generic Frak RPC error
+ * @ignore
+ */
+export declare class FrakRpcError<T = undefined> extends Error {
+    code: number;
+    data?: T | undefined;
+    constructor(code: number, message: string, data?: T | undefined);
+}
+
+/**
+ * Configuration for the Frak Wallet SDK
+ * @category Config
+ */
+export 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;
+        /**
+         * Language to display in the modal
+         * If undefined, will default to the browser language
+         */
+        lang?: Language;
+        /**
+         * The currency to display in the modal
+         * @defaultValue `"eur"`
+         */
+        currency?: Currency;
+        /**
+         * The logo URL that will be displayed in a few components
+         */
+        logoUrl?: string;
+        /**
+         * The homepage link that could be displayed in a few components
+         */
+        homepageLink?: string;
+    };
+    /**
+     * Some customization for the modal
+     */
+    customizations?: {
+        /**
+         * Custom CSS styles to apply to the modals and components
+         */
+        css?: `${string}.css`;
+        /**
+         * Custom i18n configuration for the modal
+         */
+        i18n?: I18nConfig;
+    };
+    /**
+     * 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
+ */
+export 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;
+};
+
+/**
+ * Get the currency amount key for a given currency
+ * @param currency - The currency to use
+ * @returns The currency amount key
+ */
+export declare function getCurrencyAmountKey(currency?: Currency): keyof TokenAmountType;
+
+/**
+ * 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
+ */
+export 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 for the referrer
+     */
+    maxReferrer?: TokenAmountType;
+    /**
+     * The max potential reward for the referee
+     */
+    maxReferee?: TokenAmountType;
+    /**
+     * List of all the potentials reward arround this product
+     */
+    rewards: {
+        token: Address;
+        campaign: Address;
+        interactionTypeKey: FullInteractionTypesKey;
+        referrer: TokenAmountType;
+        referee: TokenAmountType;
+    }[];
+};
+
+/**
+ * Get the supported currency for a given currency
+ * @param currency - The currency to use
+ * @returns The supported currency
+ */
+export declare function getSupportedCurrency(currency?: Currency): Currency;
+
+/**
+ * Get the supported locale for a given currency
+ * @param currency - The currency to use
+ * @returns The supported locale
+ */
+export declare function getSupportedLocale(currency?: Currency): (typeof locales)[LocalesKey];
+
+declare type HandshakeRequestEvent = {
+    iframeLifecycle: "handshake";
+    data: {
+        token: string;
+    };
+};
+
+declare type HandshakeResponse = {
+    clientLifecycle: "handshake-response";
+    data: {
+        token: string;
+        currentUrl: string;
+    };
+};
+
+/**
+ * Compress the given params, and add hash protection to (rapidly) prevent interception modification
+ * @param data The params to encode
+ * @ignore
+ */
+export declare function hashAndCompressData<T>(data: T): CompressedData;
+
+/**
+ * The encoded data to send to a client / received by a client
+ *  @ignore
+ */
+export declare type HashProtectedData<DataType> = Readonly<DataType & {
+    validationHash: string;
+}>;
+
+declare type HearbeatEvent = {
+    clientLifecycle: "heartbeat";
+};
+
+/**
+ * Custom i18n configuration for the modal
+ *  See [i18next json format](https://www.i18next.com/misc/json-format#i18next-json-v4)
+ *
+ * Available variables
+ *  - `{{ productName }}` : The name of your website (`metadata.name`)
+ *  - `{{ productOrigin }}` : The origin url of your website
+ *  - `{{ estimatedReward }}` : The estimated reward for the user (based on the specific `targetInteraction` you can specify, or the max referrer reward if no target interaction is specified)
+ *
+ * Context of the translation [see i18n context](https://www.i18next.com/translation-function/context)
+ *  - For modal display, the key of the final action (`sharing`, `reward`, or undefined)
+ *  - For embedded wallet display, the key of the logged in action (`sharing` or undefined)
+ *
+ * @example
+ * ```ts
+ * // Multi language config
+ * const multiI18n = {
+ *  fr: {
+ *      "sdk.modal.title": "Titre de modal",
+ *      "sdk.modal.description": "Description de modal, avec {{ estimatedReward }} de gains possible",
+ *  },
+ *  en: "https://example.com/en.json"
+ * }
+ *
+ * // Single language config
+ * const singleI18n = {
+ *      "sdk.modal.title": "Modal title",
+ *      "sdk.modal.description": "Modal description, with {{ estimatedReward }} of gains possible",
+ * }
+ * ```
+ *
+ * @category Config
+ */
+export declare type I18nConfig = Record<Language, LocalizedI18nConfig> | LocalizedI18nConfig;
+
+/**
+ * Represent an iframe event
+ */
+export declare type IFrameEvent = IFrameRpcEvent | IFrameLifecycleEvent | ClientLifecycleEvent;
+
+/**
+ * Event related to the iframe lifecycle
+ * @ignore
+ */
+export declare type IFrameLifecycleEvent = {
+    iframeLifecycle: "connected" | "show" | "hide";
+    data?: never;
+} | DoBackupEvent | RemoveBackupEvent | HandshakeRequestEvent | RedirectRequestEvent;
+
+/**
+ * Represent an iframe rpc event
+ */
+export declare type IFrameRpcEvent = {
+    id: string;
+    topic: ExtractedParametersFromRpc<IFrameRpcSchema>["method"];
+    data: CompressedData;
+};
+
+/**
+ * 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_displayEmbeddedWallet
+ * - Params: [{@link DisplayEmbeddedWalletParamsType}]
+ * - Returns: {@link DisplayEmbeddedWalletResultType}
+ */
+export 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,
+    metadata: ModalRpcMetadata | undefined,
+    configMetadata: FrakWalletSdkConfig["metadata"]
+    ];
+    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 embedded wallet, with potential customization
+*/
+    {
+    Method: "frak_displayEmbeddedWallet";
+    Parameters: [
+    request: DisplayEmbeddedWalletParamsType,
+    metadata: FrakWalletSdkConfig["metadata"]
+    ];
+    ReturnType: DisplayEmbeddedWalletResultType;
+}
+];
+
+/**
+ * IFrame transport interface
+ */
+export 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
+ */
+export 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";
+    };
+};
+
+/**
+ * The final keys for each interaction types (e.g. `openArticle`) -> interaction type
+ * @inline
+ */
+export declare type InteractionTypesKey = {
+    [K in keyof typeof interactionTypes]: keyof (typeof interactionTypes)[K];
+}[keyof typeof interactionTypes];
+
+/**
+ * Represent a key provider used for the hashed and secure compression
+ *  @ignore
+ */
+export declare type KeyProvider<DataType> = (value: DataType) => string[];
+
+/**
+ * All the languages available
+ * @category Config
+ */
+export declare type Language = "fr" | "en";
+
+/**
+ * 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>;
+
+/**
+ * Map the currency to the locale
+ */
+export declare const locales: {
+    readonly eur: "fr-FR";
+    readonly usd: "en-US";
+    readonly gbp: "en-GB";
+};
+
+/**
+ * The keys for each locales
+ * @inline
+ */
+export declare type LocalesKey = keyof typeof locales;
+
+/**
+ * A localized i18n config
+ * @category Config
+ */
+export declare type LocalizedI18nConfig = `${string}.css` | {
+    [key: string]: string;
+};
+
+/**
+ * Some configuration options for the embedded view
+ *
+ * @group Embedded wallet
+ */
+export declare type LoggedInEmbeddedView = {
+    /**
+     * The main action to display on the logged in embedded view
+     */
+    action?: EmbeddedViewActionSharing | EmbeddedViewActionReferred;
+};
+
+/**
+ * The view when a user is logged out
+ * @group Embedded wallet
+ */
+export declare type LoggedOutEmbeddedView = {
+    /**
+     * Metadata option when displaying the embedded 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 interacting on your website
+         *  - can be formatted in markdown
+         *
+         * If not set, it will default to a internationalized message
+         * @deprecated Use the top level `config.customizations.i18n`, or `metadata.i18n` instead
+         */
+        text?: string;
+        /**
+         * The text that will be displayed on the login button
+         *
+         * If not set, it will default to a internationalized message
+         * @deprecated Use the top level `config.customizations.i18n`, or `metadata.i18n` instead
+         */
+        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
+ */
+export 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
+ */
+export declare type ModalRpcMetadata = {
+    header?: {
+        title?: string;
+        icon?: string;
+    };
+    targetInteraction?: FullInteractionTypesKey;
+    /**
+     * Some i18n override for the displayed modal (i.e. update the displayed text only for this modal)
+     */
+    i18n?: I18nConfig;
+} & ({
+    isDismissible: true;
+    /**
+     * @deprecated Use `config.customizations.i18n` or `metadata.i18n` instead
+     */
+    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
+ */
+export 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
+ */
+export 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 customize a modal step
+ * @group Modal Display
+ * @deprecated Use the top level `config.customizations.i18n`, or `metadata.i18n` instead
+ */
+export declare type ModalStepMetadata = {
+    metadata?: {
+        /**
+         * Custom title for the step
+         * If none provided, it will use an internationalized text
+         * @deprecated Use the top level `config.customizations.i18n`, or `metadata.i18n` instead
+         */
+        title?: string;
+        /**
+         * Custom description for the step
+         * If none provided, it will use an internationalized text
+         * @deprecated Use the top level `config.customizations.i18n`, or `metadata.i18n` instead
+         */
+        description?: string;
+        /**
+         * Custom text for the primary action of the step
+         * If none provided, it will use an internationalized text
+         * @deprecated Use the top level `config.customizations.i18n`, or `metadata.i18n` instead
+         */
+        primaryActionText?: string;
+        /**
+         * Custom text for the secondary action of the step
+         * If none provided, it will use an internationalized text
+         * @deprecated Use the top level `config.customizations.i18n`, or `metadata.i18n` instead
+         */
+        secondaryActionText?: string;
+    };
+};
+
+/**
+ * Generic type of steps we will display in the modal to the end user
+ * @group Modal Display
+ */
+export 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
+ */
+export declare type OpenInteractionSessionModalStepType = GenericModalStepType<"openSession", object, OpenInteractionSessionReturnType>;
+
+/**
+ * Return type of the open session modal step
+ * @inline
+ * @ignore
+ */
+export 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/frak-sso",
+ *     metadata,
+ * });
+ * ```
+ * :::
+ */
+export declare function openSso(client: FrakClient, args: OpenSsoParamsType): Promise<void>;
+
+/**
+ * Params to start a SSO
+ * @group RPC Schema
+ */
+export 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;
+};
+
+/**
+ * Parse the current URL into a Frak Context
+ * @param args
+ * @param args.url - The url to parse
+ * @returns The parsed Frak context
+ */
+declare function parse({ url }: {
+    url: string;
+}): FrakContext | null | undefined;
+
+/**
+ * Represent a prepared user interaction, ready to be sent on-chain via the wallet
+ */
+export declare type PreparedInteraction = {
+    handlerTypeDenominator: Hex;
+    interactionData: Hex;
+};
+
+/**
+ * Press interactions allow you to track user engagement with articles or other press content on your platform.
+ * After setting up these interactions, you can create acquisition campaign based on the user engagement with your press content.
+ *
+ * :::info
+ *   To properly handle press interactions, ensure that the "Press" product type is enabled in your Business dashboard.
+ * :::
+ *
+ * @description Encode press related user interactions
+ *
+ * @group Interactions Encoder
+ *
+ * @see {@link PreparedInteraction} The prepared interaction object that can be sent
+ * @see {@link !actions.sendInteraction | `sendInteraction()`} Action used to send the prepared interaction to the Frak Wallet
+ */
+export declare const PressInteractionEncoder: {
+    /**
+     * Encode an open article interaction
+     * @param args
+     * @param args.articleId - The id of the article the user opened (32 bytes), could be a `keccak256` hash of the article slug, or your internal id
+     */
+    openArticle({ articleId }: {
+        articleId: Hex;
+    }): PreparedInteraction;
+    /**
+     * Encode a read article interaction
+     * @param args
+     * @param args.articleId - The id of the article the user opened (32 bytes), could be a `keccak256` hash of the article slug, or your internal id
+     */
+    readArticle({ articleId }: {
+        articleId: Hex;
+    }): PreparedInteraction;
+};
+
+/**
+ * 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?: DisplayEmbeddedWalletParamsType;
+    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
+ */
+export declare const productTypes: {
+    dapp: number;
+    press: number;
+    webshop: number;
+    retail: number;
+    referral: number;
+    purchase: number;
+};
+
+/**
+ * The keys for each product types
+ * @inline
+ */
+export declare type ProductTypesKey = keyof typeof productTypes;
+
+/**
+ * Bitmask for each product types
+ */
+export declare const productTypesMask: Record<ProductTypesKey, bigint>;
+
+/**
+ * Purchase interactions allow you to track user purchases on your platform.
+ * After setting up these interactions, you can create acquisition campaign based on the user purchase  (starting a new one, completed, or even purchase dropped).
+ *
+ * :::info
+ *   To properly handle purchase interactions, ensure that the "Purchase" product type is enabled in your Business dashboard, and that you have set up everything correctly in the `Purchasetracker` section.
+ * :::
+ *
+ * :::note
+ * The `purchaseId` is used on both interactions. It can be computed like this:
+ *
+ * ```ts
+ * const purchaseId = keccak256(concatHex([productId, toHex(externalPurchaseId)]));
+ * ```
+ *
+ * With:
+ * - `productId`: The id of your product, you can find it in the product dashboard.
+ * - `externalPurchaseId`: The id of the purchase in your system (e.g. the shopify `order_id`).
+ * :::
+ *
+ * @description Encode purchase related user interactions
+ *
+ * @group Interactions Encoder
+ *
+ * @see {@link !actions.sendInteraction | `sendInteraction()`} Action used to send the prepared interaction to the Frak Wallet
+ * @see {@link PreparedInteraction} The prepared interaction object that can be sent
+ * @see {@link !actions.trackPurchaseStatus | `trackPurchaseStatus()`} Action that will automatically send the purchase upon completion
+ * @see [Purchase Webhooks](/wallet-sdk/references-api/webhook) Webhooks to be implemented on your side to confirm a purchase
+ * @see [Purchase Proof](/wallet-sdk/references-api/purchaseProof) Get a merklee proof for the purchase
+ */
+export declare const PurchaseInteractionEncoder: {
+    /**
+     * Encode a start purchase interaction
+     * @param args
+     * @param args.purchaseId - The id of the purchase that is being started.
+     */
+    startPurchase({ purchaseId }: {
+        purchaseId: Hex;
+    }): PreparedInteraction;
+    /**
+     * Encode a complete purchase interaction
+     * @param args
+     * @param args.purchaseId - The id of the purchase that is being completed.
+     * @param args.proof - The merkle proof that the user has completed the purchase (see [Purchase Webhooks](/wallet-sdk/references-api/webhook) for more details).
+     */
+    completedPurchase({ purchaseId, proof, }: {
+        purchaseId: Hex;
+        proof: Hex[];
+    }): PreparedInteraction;
+    /**
+     * Encode an unsafe complete purchase interaction (when we can't provide the proof)
+     * @param args
+     * @param args.purchaseId - The id of the purchase that is being completed.
+     */
+    unsafeCompletedPurchase({ purchaseId, }: {
+        purchaseId: Hex;
+    }): PreparedInteraction;
+};
+
+declare type RedirectRequestEvent = {
+    iframeLifecycle: "redirect";
+    data: {
+        /**
+         * The base url to redirect to (contain a query param `u`, the client need to suffix the current url to the base url)
+         */
+        baseRedirectUrl: string;
+    };
+};
+
+/**
+ * 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?: DisplayEmbeddedWalletParamsType;
+    options?: ProcessReferralOptions;
+}): Promise<("error" | "idle" | "processing" | "success" | "no-wallet" | "no-session" | "no-referrer" | "self-referral") | undefined>;
+
+/**
+ * Referral interactions allow you to track user sharing activities.
+ * These interactions are essential for platforms looking to grow their user base through user-to-user referrals and reward systems.
+ *
+ * :::info
+ *   To properly handle referral interactions, ensure that the "Referral" product type is enabled in your Business dashboard.
+ * :::
+ *
+ * @description Encode referral related user interactions
+ *
+ * @group Interactions Encoder
+ *
+ * @see {@link PreparedInteraction} The prepared interaction object that can be sent
+ * @see {@link !actions.sendInteraction | `sendInteraction()`} Action used to send the prepared interaction to the Frak Wallet
+ */
+export declare const ReferralInteractionEncoder: {
+    /**
+     * Records the event of a user creating a referral link. Note that this interaction doesn't actually create the link itself; it only sends an event to track that a link was created.
+     */
+    createLink(): PreparedInteraction;
+    /**
+     * Encode a referred interaction
+     * @param args
+     * @param args.referrer - The Ethereum address of the user who made the referral
+     */
+    referred({ referrer }: {
+        referrer: Address;
+    }): PreparedInteraction;
+};
+
+/**
+ * The different states of the referral process
+ * @inline
+ */
+declare type ReferralState = "idle" | "processing" | "success" | "no-wallet" | "no-session" | "error" | "no-referrer" | "self-referral";
+
+/**
+ * Remove Frak context from current url
+ * @param url - The url to update
+ * @returns The new url without the Frak context
+ */
+declare function remove(url: string): string;
+
+declare type RemoveBackupEvent = {
+    iframeLifecycle: "remove-backup";
+};
+
+/**
+ * Replace the current url with the given Frak context
+ * @param args
+ * @param args.url - The url to update
+ * @param args.context - The context to update
+ */
+declare function replaceUrl({ url: baseUrl, context, }: {
+    url?: string;
+    context: Partial<FrakContext> | null;
+}): void;
+
+/**
+ * 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>;
+
+declare type RestoreBackupEvent = {
+    clientLifecycle: "restore-backup";
+    data: {
+        backup: string;
+    };
+};
+
+/**
+ * Retail interactions allow you to track user activities on your retails products.
+ *
+ * :::info
+ *   To properly handle retail interactions, ensure that the "Retail" product type is enabled in your Business dashboard.
+ * :::
+ *
+ * @description Encode retail related user interactions
+ *
+ * @group Interactions Encoder
+ *
+ * @see {@link PreparedInteraction} The prepared interaction object that can be sent
+ * @see {@link !actions.sendInteraction | `sendInteraction()`} Action used to send the prepared interaction to the Frak Wallet
+ */
+export declare const RetailInteractionEncoder: {
+    /**
+     * Encode a customer meeting retail interaction
+     * @param args
+     * @param args.agencyId - The id of the agency that the customer is meeting with
+     *
+     */
+    customerMeeting({ agencyId }: {
+        agencyId: Hex;
+    }): PreparedInteraction;
+};
+
+/**
+ * The different Frak RPC error codes
+ */
+export declare const RpcErrorCodes: {
+    readonly parseError: -32700;
+    readonly invalidRequest: -32600;
+    readonly methodNotFound: -32601;
+    readonly invalidParams: -32602;
+    readonly internalError: -32603;
+    readonly serverError: -32000;
+    readonly clientNotConnected: -32001;
+    readonly configError: -32002;
+    readonly corruptedResponse: -32003;
+    readonly clientAborted: -32004;
+    readonly walletNotConnected: -32005;
+    readonly serverErrorForInteractionDelegation: -32006;
+};
+
+/**
+ * Raw response that we will receive after an rpc request
+ * @ignore
+ */
+export declare type RpcResponse<TRpcSchema extends RpcSchema, TMethod extends TRpcSchema[number]["Method"] = TRpcSchema[number]["Method"]> = {
+    result: Extract<TRpcSchema[number], {
+        Method: TMethod;
+    }>["ReturnType"];
+    error?: never;
+} | {
+    result?: never;
+    error: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+};
+
+/**
+ * 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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export declare type SendTransactionReturnType = {
+    hash: Hex;
+};
+
+/**
+ * Generic format representing a tx to be sent
+ */
+export declare type SendTransactionTxType = {
+    to: Address;
+    data?: Hex;
+    value?: Hex;
+};
+
+/**
+ * Directly setup the Frak client with an iframe
+ * Return when the FrakClient is ready (setup and communication estbalished with the wallet)
+ *
+ * @param config - The configuration to use for the Frak Wallet SDK
+ * @returns a Promise with the Frak Client
+ *
+ * @example
+ * const frakConfig: FrakWalletSdkConfig = {
+ *     metadata: {
+ *         name: "My app title",
+ *     },
+ * }
+ * const client = await setupClient({ config: frakConfig });
+ */
+export declare function setupClient({ config, }: {
+    config: FrakWalletSdkConfig;
+}): Promise<FrakClient | undefined>;
+
+/**
+ * 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
+ */
+export declare type SiweAuthenticateModalStepType = GenericModalStepType<"siweAuthenticate", {
+    siwe: SiweAuthenticationParams;
+}, SiweAuthenticateReturnType>;
+
+/**
+ * Return type of the Siwe transaction rpc request
+ * @inline
+ */
+export declare type SiweAuthenticateReturnType = {
+    signature: Hex;
+    message: string;
+};
+
+/**
+ * Parameters used send a SIWE rpc request
+ */
+export declare type SiweAuthenticationParams = Omit<SiweMessage, "address" | "chainId" | "expirationTime" | "issuedAt" | "notBefore"> & {
+    expirationTimeTimestamp?: number;
+    notBeforeTimestamp?: number;
+};
+
+/**
+ * SSO Metadata
+ */
+export 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;
+};
+
+/**
+ * The type for the amount of tokens
+ */
+export declare type TokenAmountType = {
+    amount: number;
+    eurAmount: number;
+    usdAmount: number;
+    gbpAmount: number;
+};
+
+export declare function trackEvent(client: FrakClient | undefined, event: FrakEvent, props?: EventProps): void;
+
+/**
+ * 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>;
+
+/**
+ * Populate the current url with the given Frak context
+ * @param args
+ * @param args.url - The url to update
+ * @param args.context - The context to update
+ * @returns The new url with the Frak context
+ */
+declare function update({ url, context, }: {
+    url?: string;
+    context: Partial<FrakContext>;
+}): string | null;
+
+/**
+ * @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
+ */
+export 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>;
+
+/**
+ * Webshop interactions allow you to track user activities on your webshop.
+ *
+ * :::info
+ *   To properly handle webshop interactions, ensure that the "WebShop" product type is enabled in your Business dashboard.
+ * :::
+ *
+ * @description Encode webshop related user interactions
+ *
+ * @group Interactions Encoder
+ *
+ * @see {@link PreparedInteraction} The prepared interaction object that can be sent
+ * @see {@link !actions.sendInteraction | `sendInteraction()`} Action used to send the prepared interaction to the Frak Wallet
+ */
+export declare const WebShopInteractionEncoder: {
+    /**
+     * Encode an open webshop interaction
+     */
+    open(): PreparedInteraction;
+};
+
+export { }