@frak-labs/core-sdk 0.0.7 → 0.0.9

package/dist/index.d.ts

@@ -1,255 +1,1207 @@
-import { F as FrakWalletSdkConfig, a as FrakClient, I as IFrameEvent, b as FrakContext } from './context-rDsQbSgB.js';
-export { C as ClientLifecycleEvent, D as DisplayEmbededWalletParamsType, j as DisplayModalParamsType, E as EmbededViewAction, H as ExtractedParametersFromRpc, J as ExtractedReturnTypeFromRpc, y as FinalActionType, x as FinalModalStepType, e as FullInteractionTypesKey, G as GetProductInformationReturnType, B as IFrameLifecycleEvent, A as IFrameRpcEvent, f as IFrameRpcSchema, z as IFrameTransport, d as InteractionTypesKey, g as LoggedInEmbededView, L as LoggedOutEmbededView, n as LoginModalStepType, h as ModalRpcMetadata, k as ModalRpcStepsInput, l as ModalRpcStepsResultType, m as ModalStepMetadata, M as ModalStepTypes, w as OpenInteractionSessionModalStepType, v as OpenInteractionSessionReturnType, O as OpenSsoParamsType, P as ProductTypesKey, R as RpcResponse, t as SendTransactionModalStepType, u as SendTransactionReturnType, s as SendTransactionTxType, o as SiweAuthenticateModalStepType, r as SiweAuthenticateReturnType, q as SiweAuthenticationParams, S as SsoMetadata, W as WalletStatusReturnType, i as interactionTypes, p as productTypes, c as productTypesMask } from './context-rDsQbSgB.js';
-export { P as PreparedInteraction, S as SendInteractionParamsType, a as SendInteractionReturnType } from './interaction-CTQ5-kqe.js';
-import 'viem';
-import 'viem/chains';
-import 'viem/siwe';
-
-/**
- * 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 });
- */
-declare function createIFrameFrakClient({ config, iframe, }: {
-    config: FrakWalletSdkConfig;
-    iframe: HTMLIFrameElement;
-}): FrakClient;
-
-/**
- * Generic Frak RPC error
- * @ignore
- */
-declare class FrakRpcError<T = undefined> extends Error {
-    code: number;
-    data?: T | undefined;
-    constructor(code: number, message: string, data?: T | undefined);
-}
-/** @ignore */
-declare class ClientNotFound extends FrakRpcError {
-    constructor();
-}
-/**
- * The different Frak RPC error codes
- */
-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;
-};
-
-/**
- * The received encoded data from a client
- *  -> The encoded should contain a HashProtectedData once decoded
- *  @ignore
- */
-type CompressedData = Readonly<{
-    compressed: string;
-    compressedHash: string;
-}>;
-/**
- * The encoded data to send to a client / received by a client
- *  @ignore
- */
-type HashProtectedData<DataType> = Readonly<DataType & {
-    validationHash: string;
-}>;
-/**
- * Represent a key provider used for the hashed and secure compression
- *  @ignore
- */
-type KeyProvider<DataType> = (value: DataType) => string[];
-
-/**
- * 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 });
- */
-declare function setupClient({ config, }: {
-    config: FrakWalletSdkConfig;
-}): Promise<FrakClient | undefined>;
-
-/** @ignore */
-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;
-}
-
-/**
- * Base props for the iframe
- * @ignore
- */
-declare const baseIframeProps: {
-    id: string;
-    name: string;
-    allow: string;
-    style: {
-        width: string;
-        height: string;
-        border: string;
-        position: string;
-        zIndex: number;
-        top: string;
-        left: 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`.
- */
-declare function createIframe({ walletBaseUrl, config, }: {
-    walletBaseUrl?: string;
-    config?: FrakWalletSdkConfig;
-}): Promise<HTMLIFrameElement | undefined>;
-
-/**
- * Compress the given params, and add hash protection to (rapidly) prevent interception modification
- * @param data The params to encode
- * @ignore
- */
-declare function hashAndCompressData<T>(data: T): Promise<CompressedData>;
-/**
- * Compress json data
- * @param data
- * @ignore
- */
-declare function compressJson(data: unknown): Promise<string>;
-
-/**
- * Decompress the given string
- * @param compressedData The params to encode
- * @ignore
- */
-declare function decompressDataAndCheckHash<T>(compressedData: CompressedData): Promise<HashProtectedData<T>>;
-/**
- * Decompress json data
- * @param data
- * @ignore
- */
-declare function decompressJson<T>(data: string): Promise<T | null>;
-
-/**
- * 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;
-/**
- * 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;
-/**
- * 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;
-/**
- * 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;
-/**
- * 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;
-/**
- * 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;
-/**
- * Export our frak context "class"
- */
-declare const FrakContextManager: {
-    compress: typeof compress;
-    decompress: typeof decompress;
-    parse: typeof parse;
-    update: typeof update;
-    remove: typeof remove;
-    replaceUrl: typeof replaceUrl;
-};
-
-/**
- * Simple deferred promise wrapper
- * @ignore
- */
-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;
-}
-
-export { ClientNotFound, type CompressedData, DebugInfoGatherer, Deferred, FrakClient, FrakContext, FrakContextManager, FrakRpcError, FrakWalletSdkConfig, type HashProtectedData, IFrameEvent, type KeyProvider, RpcErrorCodes, baseIframeProps, compressJson, createIFrameFrakClient, createIframe, decompressDataAndCheckHash, decompressJson, hashAndCompressData, setupClient };
+import type { Address } from 'viem';
+import type { Hex } from 'viem';
+import type { Prettify } from 'viem/chains';
+import type { RpcSchema } from 'viem';
+import type { SiweMessage } from 'viem/siwe';
+
+/**
+ * Base props for the iframe
+ * @ignore
+ */
+export declare const baseIframeProps: {
+    id: string;
+    name: string;
+    allow: string;
+    style: {
+        width: string;
+        height: string;
+        border: string;
+        position: string;
+        zIndex: number;
+        top: string;
+        left: string;
+    };
+};
+
+/**
+ * Event related to the iframe lifecycle
+ * @ignore
+ */
+export declare type ClientLifecycleEvent = CustomCssEvent | 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 = Readonly<{
+    compressed: string;
+    compressedHash: string;
+}>;
+
+/**
+ * Compress json data
+ * @param data
+ * @ignore
+ */
+export declare function compressJson(data: unknown): Promise<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
+ */
+export declare type Currency = "eur" | "usd" | "gbp";
+
+declare type CustomCssEvent = {
+    clientLifecycle: "modal-css";
+    data: {
+        cssLink: string;
+    };
+};
+
+/** @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): Promise<HashProtectedData<T>>;
+
+/**
+ * Decompress json data
+ * @param data
+ * @ignore
+ */
+export declare function decompressJson<T>(data: string): Promise<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;
+}
+
+/**
+ * The params used to display the embeded wallet
+ *
+ * @group Embeded wallet
+ */
+export 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?: {
+        /**
+         * 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";
+    };
+};
+
+/**
+ * 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 different type of action we can have on the embeded view (once the user is logged in)
+ *
+ * @group Embeded wallet
+ */
+export 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
+ */
+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?: {
+        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
+ */
+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;
+    };
+} & IFrameTransport;
+
+/**
+ * The current Frak Context
+ *
+ * For now, only contain a referrer address.
+ */
+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;
+};
+
+/**
+ * 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 Nexus Wallet SDK
+ */
+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;
+        /**
+         * Custom CSS styles to apply to the modals and components
+         */
+        css?: string;
+        /**
+         * Language to display in the modal
+         * If undefined, will default to the browser language
+         */
+        lang?: "fr" | "en";
+        /**
+         * The currency to display in the modal
+         * @defaultValue `"eur"`
+         */
+        currency?: Currency;
+    };
+    /**
+     * 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;
+
+/**
+ * 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): Promise<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";
+};
+
+/**
+ * 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;
+
+/**
+ * Represent an iframe rpc event
+ */
+export declare type IFrameRpcEvent = {
+    id: string;
+    topic: ExtractedParametersFromRpc<IFrameRpcSchema>["method"];
+    data: {
+        compressed: string;
+        compressedHash: string;
+    };
+};
+
+/**
+ * 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
+ */
+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: FrakWalletSdkConfig["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,
+    metadata: FrakWalletSdkConfig["metadata"]
+    ];
+    ReturnType: undefined;
+}
+];
+
+/**
+ * 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[];
+
+/**
+ * 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;
+
+/**
+ * Some configuration options for the embeded view
+ *
+ * @group Embeded wallet
+ */
+export 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
+ */
+export 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
+ */
+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;
+};
+
+/**
+ * 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;
+    };
+    context?: string;
+    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
+ */
+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"];
+};
+
+/**
+ * Metadata that can be used to customise a modal step
+ * @group Modal Display
+ */
+export 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
+ */
+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;
+};
+
+/**
+ * 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;
+};
+
+/**
+ * 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>;
+
+/**
+ * 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;
+    };
+};
+
+/**
+ * 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;
+    };
+};
+
+/**
+ * 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;
+};
+
+/**
+ * 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>;
+
+/**
+ * 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>;
+
+/**
+ * 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;
+};
+
+/**
+ * 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;
+
+export { }