@farcaster/miniapp-host 0.0.0-canary-20250630212339

package/dist/comlink/protocol.js

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export var WireValueType;
+(function (WireValueType) {
+    WireValueType["RAW"] = "RAW";
+    WireValueType["PROXY"] = "PROXY";
+    WireValueType["THROW"] = "THROW";
+    WireValueType["HANDLER"] = "HANDLER";
+})(WireValueType || (WireValueType = {}));
+export var MessageType;
+(function (MessageType) {
+    MessageType["GET"] = "GET";
+    MessageType["SET"] = "SET";
+    MessageType["APPLY"] = "APPLY";
+    MessageType["CONSTRUCT"] = "CONSTRUCT";
+    MessageType["ENDPOINT"] = "ENDPOINT";
+    MessageType["RELEASE"] = "RELEASE";
+})(MessageType || (MessageType = {}));

package/dist/helpers/endpoint.d.ts

@@ -0,0 +1,20 @@
+import type { MiniAppHost } from '@farcaster/miniapp-core';
+import type * as Provider from 'ox/Provider';
+import type { HostEndpoint } from '../types.ts';
+/**
+ * @returns function to cleanup provider listeners
+ */
+export declare function exposeToEndpoint({ endpoint, sdk, miniAppOrigin, ethProvider, debug, }: {
+    endpoint: HostEndpoint;
+    sdk: Omit<MiniAppHost, 'ethProviderRequestV2'>;
+    miniAppOrigin: string;
+    ethProvider?: Provider.Provider;
+    debug?: boolean;
+}): () => void;
+export declare function useExposeToEndpoint({ endpoint, sdk, miniAppOrigin, ethProvider, debug, }: {
+    endpoint: HostEndpoint | undefined;
+    sdk: Omit<MiniAppHost, 'ethProviderRequestV2'>;
+    miniAppOrigin: string;
+    ethProvider?: Provider.Provider;
+    debug?: boolean;
+}): void;

package/dist/helpers/endpoint.js

@@ -0,0 +1,38 @@
+import { useEffect } from 'react';
+import * as Comlink from "../comlink/index.js";
+import { forwardEthereumProviderEvents, wrapEthereumProviderRequest, } from "./ethereumProvider.js";
+import { wrapHandlers } from "./sdk.js";
+/**
+ * @returns function to cleanup provider listeners
+ */
+export function exposeToEndpoint({ endpoint, sdk, miniAppOrigin, ethProvider, debug = false, }) {
+    const extendedSdk = wrapHandlers(sdk);
+    let cleanup;
+    if (ethProvider) {
+        extendedSdk.ethProviderRequestV2 = wrapEthereumProviderRequest({
+            provider: ethProvider,
+            debug,
+        });
+        cleanup = forwardEthereumProviderEvents({ provider: ethProvider, endpoint });
+    }
+    const unexpose = Comlink.expose(extendedSdk, endpoint, [miniAppOrigin]);
+    return () => {
+        cleanup?.();
+        unexpose();
+    };
+}
+export function useExposeToEndpoint({ endpoint, sdk, miniAppOrigin, ethProvider, debug = false, }) {
+    useEffect(() => {
+        if (!endpoint) {
+            return;
+        }
+        const cleanup = exposeToEndpoint({
+            endpoint,
+            sdk,
+            miniAppOrigin,
+            ethProvider,
+            debug,
+        });
+        return cleanup;
+    }, [endpoint, sdk, ethProvider, miniAppOrigin, debug]);
+}

package/dist/helpers/ethereumProvider.d.ts

@@ -0,0 +1,41 @@
+import * as Provider from 'ox/Provider';
+import type * as RpcRequest from 'ox/RpcRequest';
+import * as RpcResponse from 'ox/RpcResponse';
+import type { HostEndpoint } from '../types.ts';
+export declare function forwardEthereumProviderEvents({ provider, endpoint, }: {
+    provider: Provider.Provider;
+    endpoint: HostEndpoint;
+}): () => void;
+/**
+ * Wraps a provider's request function with a result format that can transfer
+ * errors across scripting boundaries.
+ */
+export declare const wrapEthereumProviderRequest: ({ provider, debug, }: {
+    provider: Provider.Provider;
+    debug?: boolean;
+}) => (request: RpcRequest.RpcRequest) => Promise<{
+    id: number;
+    jsonrpc: "2.0";
+    error: RpcResponse.ErrorObject;
+    result?: undefined;
+} | {
+    id: number;
+    jsonrpc: "2.0";
+    result: unknown;
+    error?: undefined;
+} | {
+    readonly error: {
+        readonly message: string;
+        readonly code: number;
+        readonly details: string | undefined;
+    };
+    readonly id: number;
+    readonly jsonrpc: "2.0";
+} | {
+    readonly error: {
+        readonly message: string;
+        readonly code: 1000;
+    };
+    readonly id: number;
+    readonly jsonrpc: "2.0";
+}>;

package/dist/helpers/ethereumProvider.js

@@ -0,0 +1,89 @@
+import * as Provider from 'ox/Provider';
+import * as RpcResponse from 'ox/RpcResponse';
+export function forwardEthereumProviderEvents({ provider, endpoint, }) {
+    const accountsChanged = (accounts) => {
+        endpoint.emitEthProvider('accountsChanged', [accounts]);
+    };
+    const chainChanged = (chainId) => {
+        endpoint.emitEthProvider('chainChanged', [chainId]);
+    };
+    const connect = (connectInfo) => {
+        endpoint.emitEthProvider('connect', [connectInfo]);
+    };
+    const disconnect = (providerRpcError) => {
+        endpoint.emitEthProvider('disconnect', [providerRpcError]);
+    };
+    const message = (message) => {
+        endpoint.emitEthProvider('message', [message]);
+    };
+    provider.on('accountsChanged', accountsChanged);
+    provider.on('chainChanged', chainChanged);
+    provider.on('connect', connect);
+    provider.on('disconnect', disconnect);
+    provider.on('message', message);
+    return () => {
+        provider.removeListener('accountsChanged', accountsChanged);
+        provider.removeListener('chainChanged', chainChanged);
+        provider.removeListener('connect', connect);
+        provider.removeListener('disconnect', disconnect);
+        provider.removeListener('message', message);
+    };
+}
+// export type FrameTransport<
+//   raw extends boolean = false,
+//   schema extends RpcSchema.Generic = RpcSchema.Default,
+// > = RP RpcTransport<raw, {}, schema>
+/**
+ * Wraps a provider's request function with a result format that can transfer
+ * errors across scripting boundaries.
+ */
+export const wrapEthereumProviderRequest = ({ provider, debug = false, }) => async (request) => {
+    try {
+        if (debug) {
+            console.debug('[miniapp-host] eth provider req: ', request);
+        }
+        const result = await provider.request(request);
+        const response = RpcResponse.from({ result }, { request });
+        if (debug) {
+            console.debug('[miniapp-host] eth provider res: ', response);
+        }
+        return response;
+    }
+    catch (e) {
+        if (debug) {
+            console.error('provider request error', e);
+        }
+        if (e instanceof Provider.ProviderRpcError) {
+            return RpcResponse.from({
+                error: {
+                    message: e.message,
+                    code: e.code,
+                    details: e.details,
+                },
+            }, { request });
+        }
+        if (e !== null &&
+            typeof e === 'object' &&
+            'message' in e &&
+            typeof e.message === 'string' &&
+            'code' in e &&
+            typeof e.code === 'number') {
+            return RpcResponse.from({
+                error: {
+                    message: e.message,
+                    code: e.code,
+                    details: 'details' in e && typeof e.details === 'string'
+                        ? e.details
+                        : undefined,
+                },
+            }, { request });
+        }
+        const errorMessage = e instanceof Error ? e.message : 'Unknown';
+        return RpcResponse.from({
+            error: {
+                message: errorMessage,
+                code: 1000,
+            },
+        }, { request });
+    }
+};

package/dist/helpers/sdk.d.ts

@@ -0,0 +1,2 @@
+import type { MiniAppHost, WireMiniAppHost } from '@farcaster/miniapp-core';
+export declare function wrapHandlers(host: MiniAppHost): WireMiniAppHost;

package/dist/helpers/sdk.js

@@ -0,0 +1,52 @@
+import { AddMiniApp, SignIn, wrapSolanaProviderRequest, } from '@farcaster/miniapp-core';
+export function wrapHandlers(host) {
+    return {
+        ...host,
+        addMiniApp: async () => {
+            try {
+                const result = await host.addMiniApp();
+                return { result };
+            }
+            catch (e) {
+                if (e instanceof AddMiniApp.RejectedByUser) {
+                    return {
+                        error: {
+                            type: 'rejected_by_user',
+                        },
+                    };
+                }
+                if (e instanceof AddMiniApp.InvalidDomainManifest) {
+                    return {
+                        error: {
+                            type: 'invalid_domain_manifest',
+                        },
+                    };
+                }
+                throw e;
+            }
+        },
+        signIn: async (options) => {
+            try {
+                const result = await host.signIn(options);
+                return { result };
+            }
+            catch (e) {
+                if (e instanceof SignIn.RejectedByUser) {
+                    return {
+                        error: {
+                            type: 'rejected_by_user',
+                        },
+                    };
+                }
+                throw e;
+            }
+        },
+        solanaProviderRequest: host.solanaProviderRequest
+            ? wrapSolanaProviderRequest(host.solanaProviderRequest)
+            : undefined,
+        // Pass through haptics methods directly
+        impactOccurred: host.impactOccurred,
+        notificationOccurred: host.notificationOccurred,
+        selectionChanged: host.selectionChanged,
+    };
+}

package/dist/iframe.d.ts

@@ -0,0 +1,21 @@
+import type { MiniAppHost } from '@farcaster/miniapp-core';
+import type { Provider } from 'ox/Provider';
+import type { HostEndpoint } from './types.ts';
+/**
+ * An endpoint of communicating with an iFrame
+ */
+export declare function createIframeEndpoint({ iframe, targetOrigin, debug, }: {
+    iframe: HTMLIFrameElement;
+    targetOrigin: string;
+    debug?: boolean;
+}): HostEndpoint;
+export declare function exposeToIframe({ iframe, sdk, ethProvider, miniAppOrigin, debug, }: {
+    iframe: HTMLIFrameElement;
+    sdk: Omit<MiniAppHost, 'ethProviderRequestV2'>;
+    miniAppOrigin: string;
+    ethProvider?: Provider;
+    debug?: boolean;
+}): {
+    endpoint: HostEndpoint;
+    cleanup: () => void;
+};

package/dist/iframe.js

@@ -0,0 +1,50 @@
+import * as Comlink from "./comlink/index.js";
+import { exposeToEndpoint } from "./helpers/endpoint.js";
+/**
+ * An endpoint of communicating with an iFrame
+ */
+export function createIframeEndpoint({ iframe, targetOrigin, debug = true, }) {
+    return {
+        // when is contentWindow null
+        ...Comlink.windowEndpoint(iframe.contentWindow),
+        emit: (event) => {
+            if (debug) {
+                console.debug('frameEvent', event);
+            }
+            const wireEvent = {
+                type: 'frameEvent',
+                event,
+            };
+            iframe.contentWindow?.postMessage(wireEvent, targetOrigin);
+        },
+        emitEthProvider: (event, params) => {
+            if (debug) {
+                console.debug('fc:emitEthProvider', event, params);
+            }
+            const wireEvent = {
+                type: 'frameEthProviderEvent',
+                event,
+                params,
+            };
+            iframe.contentWindow?.postMessage(wireEvent, targetOrigin);
+        },
+    };
+}
+export function exposeToIframe({ iframe, sdk, ethProvider, miniAppOrigin, debug = false, }) {
+    const endpoint = createIframeEndpoint({
+        iframe,
+        targetOrigin: miniAppOrigin,
+        debug,
+    });
+    const cleanup = exposeToEndpoint({
+        endpoint,
+        sdk,
+        ethProvider,
+        miniAppOrigin,
+        debug,
+    });
+    return {
+        endpoint,
+        cleanup,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from '@farcaster/miniapp-core';
+export * from './types.ts';
+export * from './iframe.ts';
+export * from './helpers/endpoint.ts';

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from '@farcaster/miniapp-core';
+export * from "./types.js";
+export * from "./iframe.js";
+export * from "./helpers/endpoint.js";