@frak-labs/frame-connector 0.1.0-beta.afa252b0 → 0.1.0-beta.b0bd1f8a

package/dist/index.d.cts

@@ -1,837 +1,410 @@
-import type { Prettify } from 'viem';
-
-/**
- * Union of all message types that can be received
- */
-export declare type AnyMessage = RpcMessage | LifecycleMessage;
-
-/**
- * Lifecycle message format for client-to-iframe communication
- * These messages handle connection lifecycle events (handshake, heartbeat, etc.)
- */
-export declare type ClientLifecycleMessage = {
-    clientLifecycle: string;
-    data?: unknown;
-};
-
-/** @ignore */
-export declare class ClientNotFound extends FrakRpcError {
-    constructor();
-}
-
-/**
- * The received encoded data from a client
- * -> The encoded should contain a HashProtectedData once decoded
- */
-export declare type CompressedData = Uint8Array;
-
-/**
- * Compress JSON data using CBOR encoding
- *
- * @param data - The data to compress
- * @returns CBOR-encoded data
- *
- * @example
- * ```ts
- * const compressed = compressJson({ foo: 'bar' })
- * // Returns Uint8Array with CBOR-encoded data
- * ```
- */
-export declare function compressJson(data: unknown): Uint8Array;
-
-/**
- * Client-side compression middleware
- *
- * Compresses outgoing requests and decompresses incoming responses.
- * Always uses the format: {method: string, params: unknown}
- *
- * @example Client side
- * ```ts
- * const client = createRpcClient({
- *   transport: iframe.contentWindow,
- *   targetOrigin: 'https://wallet.frak.id',
- *   middleware: [createClientCompressionMiddleware()]
- * })
- * ```
- */
-export declare const createClientCompressionMiddleware: <TSchema extends RpcSchema, TContext>() => RpcMiddleware<TSchema, TContext>;
-
-/**
- * Listener-side compression middleware
- *
- * Decompresses incoming requests and compresses outgoing responses.
- * Always uses the format: {method: string, params: unknown}
- *
- * @example Listener side
- * ```ts
- * const listener = createRpcListener({
- *   transport: window,
- *   allowedOrigins: ['https://example.com'],
- *   middleware: [createListenerCompressionMiddleware()]
- * })
- * ```
- */
-export declare const createListenerCompressionMiddleware: <TSchema extends RpcSchema, TContext>() => RpcMiddleware<TSchema, TContext>;
-
-/**
- * Create an RPC client for SDK-side communication
- *
- * @typeParam TSchema - The RPC schema type
- * @typeParam TLifecycleEvent - Lifecycle event union type (e.g., ClientLifecycleEvent | IFrameLifecycleEvent)
- * @param config - Client configuration
- * @returns RPC client instance
- *
- * @example
- * ```ts
- * import type { IFrameRpcSchema, ClientLifecycleEvent, IFrameLifecycleEvent } from '@frak-labs/core-sdk'
- *
- * const client = createRpcClient<IFrameRpcSchema, ClientLifecycleEvent | IFrameLifecycleEvent>({
- *   emittingTransport: window,
- *   listeningTransport: window,
- *   targetOrigin: 'https://wallet.frak.id',
- *   lifecycleHandlers: {
- *     iframeLifecycle: (event, data) => {
- *       // event and data are now strongly typed!
- *     }
- *   }
- * })
- *
- * // One-shot request
- * const result = await client.request('frak_sendInteraction', [productId, interaction])
- *
- * // Listener
- * const unsubscribe = client.listen('frak_listenToWalletStatus', (status) => {
- *   console.log('Wallet status:', status)
- * })
- * ```
- */
-export declare function createRpcClient<TSchema extends RpcSchema, TLifecycleEvent extends LifecycleMessage = LifecycleMessage>(config: RpcClientConfig<TSchema, TLifecycleEvent>): RpcClient<TSchema, TLifecycleEvent>;
-
-/**
- * Create an RPC listener for Wallet-side communication
- *
- * Supports multiple schemas via union types, enabling a single listener to handle
- * different RPC protocols (e.g., IFrameRpcSchema | SsoRpcSchema).
- *
- * @typeParam TSchema - The RPC schema type (can be a union of multiple schemas)
- * @typeParam TContext - Custom context type augmented by middleware
- * @typeParam TLifecycleEvent - Lifecycle event union type (e.g., ClientLifecycleEvent | IFrameLifecycleEvent)
- * @param config - Listener configuration
- * @returns RPC listener instance
- *
- * @example
- * ```ts
- * import type { IFrameRpcSchema, SsoRpcSchema, ClientLifecycleEvent, IFrameLifecycleEvent } from '@frak-labs/core-sdk'
- *
- * // Single schema
- * const listener = createRpcListener<IFrameRpcSchema>({
- *   transport: window,
- *   allowedOrigins: ['https://example.com']
- * })
- *
- * // Multiple schemas (union type) with lifecycle events
- * type CombinedSchema = IFrameRpcSchema | SsoRpcSchema
- * const listener = createRpcListener<CombinedSchema, WalletContext, ClientLifecycleEvent | IFrameLifecycleEvent>({
- *   transport: window,
- *   allowedOrigins: '*',
- *   middleware: [compressionMiddleware, contextMiddleware],
- *   lifecycleHandlers: {
- *     clientLifecycle: (event, data, context) => {
- *       // event and data are now strongly typed!
- *     }
- *   }
- * })
- *
- * // Register handlers for IFrame methods
- * listener.handle('frak_sendInteraction', async (params, context) => {
- *   return { status: 'success', hash: '0x...' }
- * })
- *
- * // Register handlers for SSO methods
- * listener.handle('sso_complete', async (params, context) => {
- *   const [session, sdkJwt, ssoId] = params
- *   return { success: true }
- * })
- * ```
- */
-export declare function createRpcListener<TSchema extends RpcSchema, TContext = Record<string, never>, TLifecycleEvent extends LifecycleMessage = LifecycleMessage>(config: RpcListenerConfig<TSchema, TContext, TLifecycleEvent>): RpcListener<TSchema, TContext>;
-
-/**
- * Decompress and validate hash-protected data
- *
- * Security:
- * - Validates hash to ensure data integrity
- * - Throws RpcError if hash validation fails
- * - Prevents corrupted or tampered messages from processing
- *
- * @param compressedData - The compressed data to decompress
- * @returns The decompressed data with validation hash
- * @throws {Error} If decompression fails or hash validation fails
- *
- * @example
- * ```ts
- * const decompressed = decompressDataAndCheckHash(compressedData)
- * // Returns { foo: 'bar', baz: 123, validationHash: '0x...' }
- * ```
- */
-export declare function decompressDataAndCheckHash<T>(compressedData: CompressedData): HashProtectedData<T>;
-
-/**
- * Decompress CBOR-encoded data
- *
- * @param data - The compressed data
- * @returns Decompressed data or null if decompression fails
- *
- * @example
- * ```ts
- * const decompressed = decompressJson<MyType>(compressedData)
- * if (decompressed) {
- *   // Use decompressed data
- * }
- * ```
- */
-export declare function decompressJson<T>(data: Uint8Array): 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;
-}
-
-/**
- * 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 parameters from a RPC Schema
- * @ignore
- */
-declare type ExtractedSpecificParametersFromRpc<TRpcSchema extends RpcSchema, TMethod extends ExtractMethod<TRpcSchema>> = Extract<ExtractedParametersFromRpc<TRpcSchema>, {
-    method: TMethod;
-}>;
-
-/**
- * Extract method names from a schema
- *
- * @typeParam TSchema - The RPC schema type
- *
- * @example
- * ```ts
- * type Methods = ExtractMethod<MySchema>
- * // "greet" | "watchTime"
- * ```
- */
-export declare type ExtractMethod<TSchema extends RpcSchema> = TSchema[number]["Method"];
-
-/**
- * Extract parameters type for a specific method
- *
- * @typeParam TSchema - The RPC schema type
- * @typeParam TMethod - The method name
- *
- * @example
- * ```ts
- * type GreetParams = ExtractParams<MySchema, "greet">
- * // [name: string]
- * ```
- */
-export declare type ExtractParams<TSchema extends RpcSchema, TMethod extends ExtractMethod<TSchema>> = ExtractSchemaEntry<TSchema, TMethod>["Parameters"];
-
-/**
- * Extract return type for a specific method
- *
- * @typeParam TSchema - The RPC schema type
- * @typeParam TMethod - The method name
- *
- * @example
- * ```ts
- * type GreetReturn = ExtractReturnType<MySchema, "greet">
- * // string
- * ```
- */
-export declare type ExtractReturnType<TSchema extends RpcSchema, TMethod extends ExtractMethod<TSchema>> = ExtractSchemaEntry<TSchema, TMethod>["ReturnType"];
-
-/**
- * Extract a specific schema entry by method name
- *
- * @typeParam TSchema - The RPC schema type
- * @typeParam TMethod - The method name to extract
- *
- * @example
- * ```ts
- * type GreetEntry = ExtractSchemaEntry<MySchema, "greet">
- * // { Method: "greet"; Parameters: [name: string]; ReturnType: string; ResponseType: "promise" }
- * ```
- */
-export declare type ExtractSchemaEntry<TSchema extends RpcSchema, TMethod extends ExtractMethod<TSchema>> = Extract<TSchema[number], {
-    Method: TMethod;
-}>;
-
-/**
- * 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);
-    toJSON(): RpcError;
-}
-
-/**
- * Compress the given data with hash protection to prevent tampering
- *
- * Performance considerations:
- * - CBOR encoding is more compact than JSON and faster to parse
- * - Hash validation prevents man-in-the-middle modifications
- * - Single-pass encoding minimizes allocations
- *
- * @param data - The data to compress and protect
- * @returns Compressed CBOR-encoded data with validation hash
- *
- * @example
- * ```ts
- * const compressed = hashAndCompressData({ foo: 'bar', baz: 123 })
- * // Returns Uint8Array with CBOR-encoded data + validation hash
- * ```
- */
-export declare function hashAndCompressData<T>(data: T): CompressedData;
-
-/**
- * The encoded data to send to a client / received by a client
- */
-export declare type HashProtectedData<DataType> = Readonly<DataType & {
-    validationHash: string;
-}>;
-
-/**
- * Lifecycle message format for iframe-to-client communication
- */
-export declare type IFrameLifecycleMessage = {
-    iframeLifecycle: string;
-    data?: unknown;
-};
-
-/** @ignore */
-export declare class InternalError extends FrakRpcError {
-    constructor(message: string);
-}
-
-/**
- * Lifecycle handler function
- * Handles lifecycle events using discriminated unions for automatic type narrowing
- *
- * @typeParam TLifecycleEvent - The lifecycle event union type (e.g., ClientLifecycleEvent | IFrameLifecycleEvent)
- *
- * @param event - The full lifecycle event object with discriminated union
- * @param context - Request context with origin and source
- *
- * @example
- * ```ts
- * const handler: LifecycleHandler<ClientLifecycleEvent> = (event, context) => {
- *   if (event.clientLifecycle === "modal-css") {
- *     // event.data is automatically typed as { cssLink: string }
- *     console.log(event.data.cssLink)
- *   }
- * }
- * ```
- */
-export declare type LifecycleHandler<TLifecycleEvent = unknown> = (event: TLifecycleEvent, context: RpcRequestContext) => void | Promise<void>;
-
-/**
- * Union of all lifecycle message types
- */
-export declare type LifecycleMessage = ClientLifecycleMessage | IFrameLifecycleMessage;
-
-/** @ignore */
-export declare class MethodNotFoundError extends FrakRpcError<{
-    method: string;
-}> {
-    constructor(message: string, method: string);
-}
-
-/**
- * RPC Client interface
- * Provides methods for making RPC calls to the wallet
- *
- * @typeParam TSchema - The RPC schema type
- */
-export declare type RpcClient<TSchema extends RpcSchema, TLifecycleEvent extends LifecycleMessage> = {
-    /**
-     * Make a one-shot request that returns a promise
-     * Used for methods with ResponseType: "promise"
-     */
-    request: <TMethod extends ExtractMethod<TSchema>>(args: ExtractedSpecificParametersFromRpc<TSchema, TMethod>) => Promise<ExtractReturnType<TSchema, TMethod>>;
-    /**
-     * Subscribe to a listener method with a callback
-     * Used for methods with ResponseType: "stream"
-     * Returns an unsubscribe function
-     *
-     * @example
-     * ```ts
-     * const unsubscribe = client.listen('frak_listenToWalletStatus', (status) => {
-     *   console.log('Status:', status)
-     * })
-     *
-     * // Later, unsubscribe
-     * unsubscribe()
-     * ```
-     */
-    listen: <TMethod extends ExtractMethod<TSchema>>(args: ExtractedSpecificParametersFromRpc<TSchema, TMethod>, callback: (result: ExtractReturnType<TSchema, TMethod>) => void) => () => void;
-    /**
-     * Send a lifecycle event to the server
-     * Bypasses middleware and is used for connection management
-     *
-     * @example
-     * ```ts
-     * client.sendLifecycle({ clientLifecycle: 'heartbeat' })
-     * client.sendLifecycle({ clientLifecycle: 'modal-css', data: { cssLink: '...' } })
-     * ```
-     */
-    sendLifecycle: (message: TLifecycleEvent) => void;
-    /**
-     * Clean up resources and close connections
-     */
-    cleanup: () => void;
-};
-
-/**
- * RPC Client configuration
- *
- * @typeParam TSchema - The RPC schema type
- * @typeParam TLifecycleEvent - Lifecycle event union type (e.g., ClientLifecycleEvent | IFrameLifecycleEvent)
- */
-export declare type RpcClientConfig<TSchema extends RpcSchema, TLifecycleEvent = unknown> = {
-    /**
-     * The transport to use for emitting events (e.g., window or iframe.contentWindow)
-     */
-    emittingTransport: RpcTransport;
-    /**
-     * The transport to use for listening to events (e.g., window or iframe.contentWindow)
-     */
-    listeningTransport: RpcTransport;
-    /**
-     * The target origin for postMessage
-     */
-    targetOrigin: string;
-    /**
-     * Middleware stack (executed in order)
-     * Middleware can transform outgoing requests and incoming responses
-     * Client-side middleware uses empty context {}
-     *
-     * @example
-     * ```ts
-     * middleware: [
-     *   compressionMiddleware,  // Compress outgoing, decompress incoming
-     *   loggingMiddleware,      // Log RPC calls
-     * ]
-     * ```
-     */
-    middleware?: RpcMiddleware<TSchema>[];
-    /**
-     * Lifecycle event handlers
-     * Handles incoming lifecycle events from the server
-     *
-     * @example
-     * ```ts
-     * lifecycleHandlers: {
-     *   iframeLifecycle: (event, data) => {
-     *     if (event === 'connected') {
-     *       console.log('Wallet ready')
-     *     }
-     *   }
-     * }
-     * ```
-     */
-    lifecycleHandlers?: {
-        clientLifecycle?: LifecycleHandler<Extract<TLifecycleEvent, {
-            clientLifecycle: string;
-        }>>;
-        iframeLifecycle?: LifecycleHandler<Extract<TLifecycleEvent, {
-            iframeLifecycle: string;
-        }>>;
-    };
-};
-
-/**
- * RPC error object
- */
-export declare type RpcError = {
-    code: number;
-    message: string;
-    data?: unknown;
-};
-
-/**
- * RPC error codes
- * Follows JSON-RPC 2.0 specification with Frak-specific extensions
- */
-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;
-    readonly userRejected: -32007;
-};
-
-/**
- * RPC Listener interface
- * Handles incoming RPC requests from the SDK
- *
- * @typeParam TSchema - The RPC schema type
- * @typeParam TContext - Custom context type augmented by middleware
- */
-export declare type RpcListener<TSchema extends RpcSchema, TContext = Record<string, never>> = {
-    /**
-     * Register a handler for a promise-based method
-     */
-    handle: <TMethod extends ExtractMethod<TSchema>>(method: TMethod, handler: RpcPromiseHandler<TSchema, TMethod, TContext>) => void;
-    /**
-     * Register a handler for a streaming method
-     */
-    handleStream: <TMethod extends ExtractMethod<TSchema>>(method: TMethod, handler: RpcStreamHandler<TSchema, TMethod, TContext>) => void;
-    /**
-     * Unregister a handler
-     */
-    unregister: (method: ExtractMethod<TSchema>) => void;
-    /**
-     * Clean up resources
-     */
-    cleanup: () => void;
-};
-
-/**
- * RPC Listener configuration
- *
- * @typeParam TSchema - The RPC schema type
- * @typeParam TContext - Custom context type to augment base context
- * @typeParam TLifecycleEvent - Lifecycle event union type (e.g., ClientLifecycleEvent | IFrameLifecycleEvent)
- */
-export declare type RpcListenerConfig<TSchema extends RpcSchema, TContext = Record<string, never>, TLifecycleEvent extends LifecycleMessage = LifecycleMessage> = {
-    /**
-     * The transport to use for communication (e.g., window)
-     */
-    transport: RpcTransport;
-    /**
-     * Allowed origins for security
-     * Can be a single origin or array of origins
-     */
-    allowedOrigins: string | string[];
-    /**
-     * Middleware stack (executed in order)
-     * Middleware can augment context, validate requests, and transform responses
-     *
-     * Note: Middleware only applies to RPC messages, not lifecycle or custom messages
-     *
-     * @example
-     * ```ts
-     * middleware: [
-     *   loggingMiddleware,
-     *   compressionMiddleware,
-     *   contextAugmentationMiddleware
-     * ]
-     * ```
-     */
-    middleware?: RpcMiddleware<TSchema, TContext>[];
-    /**
-     * Lifecycle event handlers
-     * Handles client-to-iframe and iframe-to-client lifecycle events
-     *
-     * @example
-     * ```ts
-     * lifecycleHandlers: {
-     *   clientLifecycle: (event, data, context) => {
-     *     if (event === 'heartbeat') {
-     *       console.log('Client heartbeat received')
-     *     }
-     *   }
-     * }
-     * ```
-     */
-    lifecycleHandlers?: {
-        clientLifecycle?: LifecycleHandler<Extract<TLifecycleEvent, {
-            clientLifecycle: string;
-        }>>;
-        iframeLifecycle?: LifecycleHandler<Extract<TLifecycleEvent, {
-            iframeLifecycle: string;
-        }>>;
-    };
-};
-
-/**
- * RPC message format (maintains backward compatibility)
- * This is the exact format sent over the wire
- *
- * @typeParam TMethod - The method name type (defaults to string for flexibility)
- */
-export declare type RpcMessage<TMethod extends string = string> = {
-    /**
-     * Unique message identifier for correlating requests and responses
-     */
-    id: string;
-    /**
-     * The RPC method name (topic for backward compatibility)
-     */
-    topic: TMethod;
-    /**
-     * The message payload (compressed data) or raw params
-     */
-    data: unknown;
-};
-
-/**
- * Unified middleware function for RPC requests (both listener and client)
- * Works on both listener-side (with context augmentation) and client-side (empty context)
- *
- * Key features:
- * - Can mutate message.data directly for efficiency (compression, validation)
- * - Can mutate response.result directly for transformation
- * - Listener-side: Can augment context by returning modified context
- * - Client-side: Uses TContext = {} (empty context), always returns unchanged
- *
- * @typeParam TSchema - The RPC schema type
- * @typeParam TContext - Custom context type to augment base context (empty {} for client-side)
- *
- * @example Listener-side with context augmentation
- * ```ts
- * type WalletContext = { productId: string, sourceUrl: string }
- * const contextMiddleware: RpcMiddleware<MySchema, WalletContext> = {
- *   onRequest: async (message, context) => {
- *     // Read from store and augment context
- *     const productId = await getProductId(context.origin)
- *     return { ...context, productId, sourceUrl: context.origin }
- *   }
- * }
- * ```
- *
- * @example Client-side (empty context)
- * ```ts
- * const compressionMiddleware: RpcMiddleware<MySchema> = {
- *   onRequest: async (message, context) => {
- *     // Mutate message.data directly
- *     message.data = compress(message.data)
- *     return context  // Empty context, unchanged
- *   },
- *   onResponse: async (message, response, context) => {
- *     // Mutate response.result directly
- *     response.result = decompress(response.result)
- *     return response
- *   }
- * }
- * ```
- *
- * @example Shared middleware (works on both sides)
- * ```ts
- * const loggingMiddleware: RpcMiddleware<MySchema> = {
- *   onRequest: async (message, context) => {
- *     console.log(`[RPC] ${message.topic}`, context.origin || 'client')
- *     return context
- *   },
- *   onResponse: async (message, response, context) => {
- *     console.log(`[RPC] ${message.topic} completed`)
- *     return response
- *   }
- * }
- * ```
- */
-export declare type RpcMiddleware<TSchema extends RpcSchema, TContext = Record<string, never>> = {
-    /**
-     * Called before handler execution (listener) or before sending (client)
-     *
-     * For listener: Can augment context and mutate message
-     * For client: Can mutate message, context is empty {}
-     *
-     * @param message - The RPC message (can be mutated)
-     * @param context - Request context (listener-side) or empty (client-side)
-     * @returns Updated context (listener mutates this, client returns unchanged)
-     * @throws FrakRpcError to reject the request with a specific error code
-     */
-    onRequest?: (message: RpcMessage<ExtractMethod<TSchema>>, context: RpcMiddlewareContext<TContext>) => Promise<RpcMiddlewareContext<TContext>> | RpcMiddlewareContext<TContext>;
-    /**
-     * Called after handler execution (listener) or after receiving (client)
-     *
-     * @param message - The original RPC message
-     * @param response - The response (can be mutated)
-     * @param context - Request context (listener-side) or empty (client-side)
-     * @returns Transformed response
-     * @throws Error to send an error response instead
-     */
-    onResponse?: (message: RpcMessage<ExtractMethod<TSchema>>, response: RpcResponse, context: RpcMiddlewareContext<TContext>) => Promise<RpcResponse> | RpcResponse;
-};
-
-/**
- * Middleware context that can be augmented with custom fields
- * Generic type parameter allows domain-specific context augmentation
- *
- * @typeParam TCustomContext - Custom context fields to merge with base context
- *
- * @example
- * ```ts
- * type WalletContext = RpcMiddlewareContext<{
- *   productId: string
- *   sourceUrl: string
- *   isAutoContext: boolean
- * }>
- * // { origin: string, source: MessageEventSource | null, productId: string, sourceUrl: string, isAutoContext: boolean }
- * ```
- */
-export declare type RpcMiddlewareContext<TCustomContext = Record<string, never>> = RpcRequestContext & TCustomContext;
-
-/**
- * Promise handler function type
- * Handles one-shot requests that return a single promise
- *
- * @typeParam TSchema - The RPC schema type
- * @typeParam TMethod - The method name from the schema
- * @typeParam TContext - Custom context type augmented by middleware
- */
-export declare type RpcPromiseHandler<TSchema extends RpcSchema, TMethod extends ExtractMethod<TSchema>, TContext = Record<string, never>> = (params: ExtractParams<TSchema, TMethod>, context: RpcMiddlewareContext<TContext>) => Promise<ExtractReturnType<TSchema, TMethod>>;
-
-/**
- * Request context for handlers
- * Contains information about the origin and source of the request
- */
-export declare type RpcRequestContext = {
-    /**
-     * Origin of the request
-     */
-    origin: string;
-    /**
-     * Message source (for responding)
-     */
-    source: MessageEventSource | null;
-};
-
-/**
- * RPC response wrapper
- * Contains either a successful result or an error
- */
-export declare type RpcResponse<TResult = unknown> = {
-    result: TResult;
-    error?: never;
-} | {
-    result?: never;
-    error: RpcError;
-};
-
-/**
- * An RPC schema is a readonly array of schema entries
- *
- * @example
- * ```ts
- * type MySchema = [
- *   {
- *     Method: "greet";
- *     Parameters: [name: string];
- *     ReturnType: string;
- *     ResponseType: "promise";
- *   },
- *   {
- *     Method: "watchTime";
- *     Parameters?: undefined;
- *     ReturnType: number;
- *     ResponseType: "stream";
- *   }
- * ]
- * ```
- */
-export declare type RpcSchema = readonly RpcSchemaEntry[];
-
-/**
- * Generic shape of a single RPC schema entry
- *
- * Each entry defines a method with its parameters, return type, and response kind
- *
- * @typeParam TMethod - The method name (string literal)
- * @typeParam TParams - The parameters type (can be undefined for no parameters)
- * @typeParam TReturn - The return type
- * @typeParam TResponseKind - Either "promise" or "stream"
- */
-export declare type RpcSchemaEntry<TMethod extends string = string, TParams = unknown, TReturn = unknown> = {
-    /**
-     * The method name (e.g., "frak_sendInteraction")
-     */
-    Method: TMethod;
-    /**
-     * The parameters type (undefined if no parameters)
-     */
-    Parameters?: TParams;
-    /**
-     * The return type
-     */
-    ReturnType: TReturn;
-};
-
-/**
- * Stream handler function type
- * Handles streaming requests that can emit multiple values
- *
- * @typeParam TSchema - The RPC schema type
- * @typeParam TMethod - The method name from the schema
- * @typeParam TContext - Custom context type augmented by middleware
- */
-export declare type RpcStreamHandler<TSchema extends RpcSchema, TMethod extends ExtractMethod<TSchema>, TContext = Record<string, never>> = (params: ExtractParams<TSchema, TMethod>, emitter: StreamEmitter<ExtractReturnType<TSchema, TMethod>>, context: RpcMiddlewareContext<TContext>) => Promise<void> | void;
-
-/**
- * Transport interface for RPC communication
- * Abstracts the underlying message passing mechanism (postMessage, etc)
- */
-export declare type RpcTransport = {
-    /**
-     * Send a message through the transport
-     */
-    postMessage: (message: RpcMessage, targetOrigin: string) => void;
-    /**
-     * Listen for messages
-     */
-    addEventListener: (type: "message", listener: (event: MessageEvent<RpcMessage>) => void) => void;
-    /**
-     * Remove message listener
-     */
-    removeEventListener: (type: "message", listener: (event: MessageEvent<RpcMessage>) => void) => void;
-};
-
-/**
- * Stream emitter function
- * Used by stream handlers to emit multiple values
- */
-export declare type StreamEmitter<TResult> = (chunk: TResult) => void;
-
-/**
- * Type-safe request parameters
- *
- * @typeParam TSchema - The RPC schema type
- * @typeParam TMethod - The method name from the schema
- */
-export declare type TypedRpcRequest<TSchema extends RpcSchema, TMethod extends ExtractMethod<TSchema>> = {
-    method: TMethod;
-    params: ExtractParams<TSchema, TMethod>;
-};
-
-export { }
+import { C as ExtractedParametersFromRpc, E as RpcSchemaEntry, S as ExtractSchemaEntry, T as RpcSchema, _ as StreamEmitter, a as IFrameLifecycleMessage, b as ExtractParams, c as RpcError, d as RpcMiddlewareContext, f as RpcPromiseHandler, g as RpcTransport, h as RpcStreamHandler, i as ClientLifecycleMessage, l as RpcMessage, m as RpcResponse, n as createListenerCompressionMiddleware, o as LifecycleHandler, p as RpcRequestContext, r as AnyMessage, s as LifecycleMessage, t as createClientCompressionMiddleware, u as RpcMiddleware, v as TypedRpcRequest, w as ExtractedSpecificParametersFromRpc, x as ExtractReturnType, y as ExtractMethod } from "./index-BSzskALu.cjs";
+
+//#region src/client.d.ts
+
+/**
+ * RPC Client configuration
+ *
+ * @typeParam TSchema - The RPC schema type
+ * @typeParam TLifecycleEvent - Lifecycle event union type (e.g., ClientLifecycleEvent | IFrameLifecycleEvent)
+ */
+type RpcClientConfig<TSchema extends RpcSchema, TLifecycleEvent = unknown> = {
+  /**
+   * The transport to use for emitting events (e.g., window or iframe.contentWindow)
+   */
+  emittingTransport: RpcTransport;
+  /**
+   * The transport to use for listening to events (e.g., window or iframe.contentWindow)
+   */
+  listeningTransport: RpcTransport;
+  /**
+   * The target origin for postMessage
+   */
+  targetOrigin: string;
+  /**
+   * Middleware stack (executed in order)
+   * Middleware can transform outgoing requests and incoming responses
+   * Client-side middleware uses empty context {}
+   *
+   * @example
+   * ```ts
+   * middleware: [
+   *   compressionMiddleware,  // Compress outgoing, decompress incoming
+   *   loggingMiddleware,      // Log RPC calls
+   * ]
+   * ```
+   */
+  middleware?: RpcMiddleware<TSchema>[];
+  /**
+   * Lifecycle event handlers
+   * Handles incoming lifecycle events from the server
+   *
+   * @example
+   * ```ts
+   * lifecycleHandlers: {
+   *   iframeLifecycle: (event, data) => {
+   *     if (event === 'connected') {
+   *       console.log('Wallet ready')
+   *     }
+   *   }
+   * }
+   * ```
+   */
+  lifecycleHandlers?: {
+    clientLifecycle?: LifecycleHandler<Extract<TLifecycleEvent, {
+      clientLifecycle: string;
+    }>>;
+    iframeLifecycle?: LifecycleHandler<Extract<TLifecycleEvent, {
+      iframeLifecycle: string;
+    }>>;
+  };
+};
+/**
+ * RPC Client interface
+ * Provides methods for making RPC calls to the wallet
+ *
+ * @typeParam TSchema - The RPC schema type
+ */
+type RpcClient<TSchema extends RpcSchema, TLifecycleEvent extends LifecycleMessage> = {
+  /**
+   * Make a one-shot request that returns a promise
+   * Used for methods with ResponseType: "promise"
+   */
+  request: <TMethod extends ExtractMethod<TSchema>>(args: ExtractedSpecificParametersFromRpc<TSchema, TMethod>) => Promise<ExtractReturnType<TSchema, TMethod>>;
+  /**
+   * Subscribe to a listener method with a callback
+   * Used for methods with ResponseType: "stream"
+   * Returns an unsubscribe function
+   *
+   * @example
+   * ```ts
+   * const unsubscribe = client.listen('frak_listenToWalletStatus', (status) => {
+   *   console.log('Status:', status)
+   * })
+   *
+   * // Later, unsubscribe
+   * unsubscribe()
+   * ```
+   */
+  listen: <TMethod extends ExtractMethod<TSchema>>(args: ExtractedSpecificParametersFromRpc<TSchema, TMethod>, callback: (result: ExtractReturnType<TSchema, TMethod>) => void) => () => void;
+  /**
+   * Send a lifecycle event to the server
+   * Bypasses middleware and is used for connection management
+   *
+   * @example
+   * ```ts
+   * client.sendLifecycle({ clientLifecycle: 'heartbeat' })
+   * client.sendLifecycle({ clientLifecycle: 'modal-css', data: { cssLink: '...' } })
+   * ```
+   */
+  sendLifecycle: (message: TLifecycleEvent) => void;
+  /**
+   * Clean up resources and close connections
+   */
+  cleanup: () => void;
+};
+/**
+ * Create an RPC client for SDK-side communication
+ *
+ * @typeParam TSchema - The RPC schema type
+ * @typeParam TLifecycleEvent - Lifecycle event union type (e.g., ClientLifecycleEvent | IFrameLifecycleEvent)
+ * @param config - Client configuration
+ * @returns RPC client instance
+ *
+ * @example
+ * ```ts
+ * import type { IFrameRpcSchema, ClientLifecycleEvent, IFrameLifecycleEvent } from '@frak-labs/core-sdk'
+ *
+ * const client = createRpcClient<IFrameRpcSchema, ClientLifecycleEvent | IFrameLifecycleEvent>({
+ *   emittingTransport: window,
+ *   listeningTransport: window,
+ *   targetOrigin: 'https://wallet.frak.id',
+ *   lifecycleHandlers: {
+ *     iframeLifecycle: (event, data) => {
+ *       // event and data are now strongly typed!
+ *     }
+ *   }
+ * })
+ *
+ * // One-shot request
+ * const result = await client.request('frak_sendInteraction', [productId, interaction])
+ *
+ * // Listener
+ * const unsubscribe = client.listen('frak_listenToWalletStatus', (status) => {
+ *   console.log('Wallet status:', status)
+ * })
+ * ```
+ */
+declare function createRpcClient<TSchema extends RpcSchema, TLifecycleEvent extends LifecycleMessage = LifecycleMessage>(config: RpcClientConfig<TSchema, TLifecycleEvent>): RpcClient<TSchema, TLifecycleEvent>;
+//#endregion
+//#region src/error.d.ts
+/**
+ * RPC error codes
+ * Follows JSON-RPC 2.0 specification with Frak-specific extensions
+ */
+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;
+  readonly userRejected: -32007;
+};
+/**
+ * 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);
+  toJSON(): RpcError;
+}
+/** @ignore */
+declare class MethodNotFoundError extends FrakRpcError<{
+  method: string;
+}> {
+  constructor(message: string, method: string);
+}
+/** @ignore */
+declare class InternalError extends FrakRpcError {
+  constructor(message: string);
+}
+/** @ignore */
+declare class ClientNotFound extends FrakRpcError {
+  constructor();
+}
+//#endregion
+//#region src/listener.d.ts
+/**
+ * RPC Listener configuration
+ *
+ * @typeParam TSchema - The RPC schema type
+ * @typeParam TContext - Custom context type to augment base context
+ * @typeParam TLifecycleEvent - Lifecycle event union type (e.g., ClientLifecycleEvent | IFrameLifecycleEvent)
+ */
+type RpcListenerConfig<TSchema extends RpcSchema, TContext = Record<string, never>, TLifecycleEvent extends LifecycleMessage = LifecycleMessage> = {
+  /**
+   * The transport to use for communication (e.g., window)
+   */
+  transport: RpcTransport;
+  /**
+   * Allowed origins for security
+   * Can be a single origin or array of origins
+   */
+  allowedOrigins: string | string[];
+  /**
+   * Middleware stack (executed in order)
+   * Middleware can augment context, validate requests, and transform responses
+   *
+   * Note: Middleware only applies to RPC messages, not lifecycle or custom messages
+   *
+   * @example
+   * ```ts
+   * middleware: [
+   *   loggingMiddleware,
+   *   compressionMiddleware,
+   *   contextAugmentationMiddleware
+   * ]
+   * ```
+   */
+  middleware?: RpcMiddleware<TSchema, TContext>[];
+  /**
+   * Lifecycle event handlers
+   * Handles client-to-iframe and iframe-to-client lifecycle events
+   *
+   * @example
+   * ```ts
+   * lifecycleHandlers: {
+   *   clientLifecycle: (event, data, context) => {
+   *     if (event === 'heartbeat') {
+   *       console.log('Client heartbeat received')
+   *     }
+   *   }
+   * }
+   * ```
+   */
+  lifecycleHandlers?: {
+    clientLifecycle?: LifecycleHandler<Extract<TLifecycleEvent, {
+      clientLifecycle: string;
+    }>>;
+    iframeLifecycle?: LifecycleHandler<Extract<TLifecycleEvent, {
+      iframeLifecycle: string;
+    }>>;
+  };
+};
+/**
+ * RPC Listener interface
+ * Handles incoming RPC requests from the SDK
+ *
+ * @typeParam TSchema - The RPC schema type
+ * @typeParam TContext - Custom context type augmented by middleware
+ */
+type RpcListener<TSchema extends RpcSchema, TContext = Record<string, never>> = {
+  /**
+   * Register a handler for a promise-based method
+   */
+  handle: <TMethod extends ExtractMethod<TSchema>>(method: TMethod, handler: RpcPromiseHandler<TSchema, TMethod, TContext>) => void;
+  /**
+   * Register a handler for a streaming method
+   */
+  handleStream: <TMethod extends ExtractMethod<TSchema>>(method: TMethod, handler: RpcStreamHandler<TSchema, TMethod, TContext>) => void;
+  /**
+   * Unregister a handler
+   */
+  unregister: (method: ExtractMethod<TSchema>) => void;
+  /**
+   * Clean up resources
+   */
+  cleanup: () => void;
+};
+/**
+ * Create an RPC listener for Wallet-side communication
+ *
+ * Supports multiple schemas via union types, enabling a single listener to handle
+ * different RPC protocols (e.g., IFrameRpcSchema | SsoRpcSchema).
+ *
+ * @typeParam TSchema - The RPC schema type (can be a union of multiple schemas)
+ * @typeParam TContext - Custom context type augmented by middleware
+ * @typeParam TLifecycleEvent - Lifecycle event union type (e.g., ClientLifecycleEvent | IFrameLifecycleEvent)
+ * @param config - Listener configuration
+ * @returns RPC listener instance
+ *
+ * @example
+ * ```ts
+ * import type { IFrameRpcSchema, SsoRpcSchema, ClientLifecycleEvent, IFrameLifecycleEvent } from '@frak-labs/core-sdk'
+ *
+ * // Single schema
+ * const listener = createRpcListener<IFrameRpcSchema>({
+ *   transport: window,
+ *   allowedOrigins: ['https://example.com']
+ * })
+ *
+ * // Multiple schemas (union type) with lifecycle events
+ * type CombinedSchema = IFrameRpcSchema | SsoRpcSchema
+ * const listener = createRpcListener<CombinedSchema, WalletContext, ClientLifecycleEvent | IFrameLifecycleEvent>({
+ *   transport: window,
+ *   allowedOrigins: '*',
+ *   middleware: [compressionMiddleware, contextMiddleware],
+ *   lifecycleHandlers: {
+ *     clientLifecycle: (event, data, context) => {
+ *       // event and data are now strongly typed!
+ *     }
+ *   }
+ * })
+ *
+ * // Register handlers for IFrame methods
+ * listener.handle('frak_sendInteraction', async (params, context) => {
+ *   return { status: 'success', hash: '0x...' }
+ * })
+ *
+ * // Register handlers for SSO methods
+ * listener.handle('sso_complete', async (params, context) => {
+ *   const [session, sdkJwt, ssoId] = params
+ *   return { success: true }
+ * })
+ * ```
+ */
+declare function createRpcListener<TSchema extends RpcSchema, TContext = Record<string, never>, TLifecycleEvent extends LifecycleMessage = LifecycleMessage>(config: RpcListenerConfig<TSchema, TContext, TLifecycleEvent>): RpcListener<TSchema, TContext>;
+//#endregion
+//#region src/utils/compression.d.ts
+/**
+ * The received encoded data from a client
+ * -> The encoded should contain a HashProtectedData once decoded
+ */
+type CompressedData = Uint8Array;
+/**
+ * The encoded data to send to a client / received by a client
+ */
+type HashProtectedData<DataType> = Readonly<DataType & {
+  validationHash: string;
+}>;
+/**
+ * Compress the given data with hash protection to prevent tampering
+ *
+ * Performance considerations:
+ * - CBOR encoding is more compact than JSON and faster to parse
+ * - Hash validation prevents man-in-the-middle modifications
+ * - Single-pass encoding minimizes allocations
+ *
+ * @param data - The data to compress and protect
+ * @returns Compressed CBOR-encoded data with validation hash
+ *
+ * @example
+ * ```ts
+ * const compressed = hashAndCompressData({ foo: 'bar', baz: 123 })
+ * // Returns Uint8Array with CBOR-encoded data + validation hash
+ * ```
+ */
+declare function hashAndCompressData<T>(data: T): CompressedData;
+/**
+ * Decompress and validate hash-protected data
+ *
+ * Security:
+ * - Validates hash to ensure data integrity
+ * - Throws RpcError if hash validation fails
+ * - Prevents corrupted or tampered messages from processing
+ *
+ * @param compressedData - The compressed data to decompress
+ * @returns The decompressed data with validation hash
+ * @throws {Error} If decompression fails or hash validation fails
+ *
+ * @example
+ * ```ts
+ * const decompressed = decompressDataAndCheckHash(compressedData)
+ * // Returns { foo: 'bar', baz: 123, validationHash: '0x...' }
+ * ```
+ */
+declare function decompressDataAndCheckHash<T>(compressedData: CompressedData): HashProtectedData<T>;
+/**
+ * Compress JSON data using CBOR encoding
+ *
+ * @param data - The data to compress
+ * @returns CBOR-encoded data
+ *
+ * @example
+ * ```ts
+ * const compressed = compressJson({ foo: 'bar' })
+ * // Returns Uint8Array with CBOR-encoded data
+ * ```
+ */
+declare function compressJson(data: unknown): Uint8Array;
+/**
+ * Decompress CBOR-encoded data
+ *
+ * @param data - The compressed data
+ * @returns Decompressed data or null if decompression fails
+ *
+ * @example
+ * ```ts
+ * const decompressed = decompressJson<MyType>(compressedData)
+ * if (decompressed) {
+ *   // Use decompressed data
+ * }
+ * ```
+ */
+declare function decompressJson<T>(data: Uint8Array): T | null;
+//#endregion
+//#region src/utils/deferred-promise.d.ts
+/**
+ * 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;
+}
+//#endregion
+export { type AnyMessage, type ClientLifecycleMessage, ClientNotFound, type CompressedData, Deferred, type ExtractMethod, type ExtractParams, type ExtractReturnType, type ExtractSchemaEntry, type ExtractedParametersFromRpc, FrakRpcError, type HashProtectedData, type IFrameLifecycleMessage, InternalError, type LifecycleHandler, type LifecycleMessage, MethodNotFoundError, type RpcClient, type RpcClientConfig, type RpcError, RpcErrorCodes, type RpcListener, type RpcListenerConfig, type RpcMessage, type RpcMiddleware, type RpcMiddlewareContext, type RpcPromiseHandler, type RpcRequestContext, type RpcResponse, type RpcSchema, type RpcSchemaEntry, type RpcStreamHandler, type RpcTransport, type StreamEmitter, type TypedRpcRequest, compressJson, createClientCompressionMiddleware, createListenerCompressionMiddleware, createRpcClient, createRpcListener, decompressDataAndCheckHash, decompressJson, hashAndCompressData };