@farcaster/miniapp-sdk 0.0.0-canary-20250630212339

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-present Merkle Manufactory Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,24 @@
+# @farcaster/miniapp-sdk
+
+Build onchain social apps
+
+## Installation
+
+```bash
+pnpm add @farcaster/miniapp-sdk
+```
+
+Or include via a CDN and access via `miniapp`:
+
+```
+<script src="https://cdn.jsdelivr.net/npm/@farcaster/miniapp-sdk/dist/index.min.js"></script>
+<script>
+  miniapp.sdk.actions.ready();
+</script>
+```
+
+## Documentation
+
+For documentation and guides, visit [miniapps.farcaster.xyz](https://miniapps.farcaster.xyz/docs/getting-started).
+
+

package/dist/back.d.ts

@@ -0,0 +1,15 @@
+import type { WireMiniAppHost } from '@farcaster/miniapp-core';
+import type { Remote } from 'comlink';
+import type { Emitter } from './types.ts';
+export type Back = {
+    visible: boolean;
+    show: () => Promise<void>;
+    hide: () => Promise<void>;
+    onback: (() => unknown) | null;
+    enableWebNavigation: () => Promise<void>;
+    disableWebNavigation: () => Promise<void>;
+};
+export declare const createBack: (options: {
+    emitter: Emitter;
+    miniAppHost: Remote<WireMiniAppHost>;
+}) => Back;

package/dist/back.js

@@ -0,0 +1,88 @@
+export const createBack = ({ miniAppHost, emitter }) => {
+    let teardownWebNavigation = undefined;
+    let backCb = null;
+    return {
+        visible: false,
+        get onback() {
+            return backCb;
+        },
+        set onback(cb) {
+            if (backCb) {
+                emitter.removeListener('backNavigationTriggered', backCb);
+            }
+            backCb = cb;
+            if (cb) {
+                emitter.addListener('backNavigationTriggered', cb);
+            }
+        },
+        async show() {
+            await miniAppHost.updateBackState({
+                visible: true,
+            });
+            this.visible = true;
+        },
+        async hide() {
+            await miniAppHost.updateBackState({
+                visible: false,
+            });
+            this.visible = false;
+        },
+        async enableWebNavigation() {
+            teardownWebNavigation = setupWebBack({
+                back: this,
+                emitter,
+            });
+        },
+        async disableWebNavigation() {
+            teardownWebNavigation?.();
+            teardownWebNavigation = undefined;
+        },
+    };
+};
+function setupWebBack({ emitter, back, }) {
+    const navigation = getWebNavigation();
+    if (navigation) {
+        return setupNavigationApi({ emitter, back, navigation });
+    }
+    if (typeof window !== 'undefined') {
+        return setupFallback({ emitter, back, window });
+    }
+}
+function getWebNavigation() {
+    if (typeof window !== 'undefined' && window.navigation !== undefined) {
+        return window.navigation;
+    }
+}
+function setupNavigationApi({ emitter, back, navigation, }) {
+    function handleNavigateSuccess() {
+        if (navigation.canGoBack) {
+            back.show();
+        }
+        else {
+            back.hide();
+        }
+    }
+    function handleBackNavigationTriggered() {
+        if (back.visible && navigation.canGoBack) {
+            navigation.back();
+        }
+    }
+    navigation.addEventListener('navigatesuccess', handleNavigateSuccess);
+    emitter.addListener('backNavigationTriggered', handleBackNavigationTriggered);
+    return () => {
+        navigation.removeEventListener('navigatesuccess', handleNavigateSuccess);
+        emitter.removeListener('backNavigationTriggered', handleBackNavigationTriggered);
+    };
+}
+function setupFallback({ emitter, back, window, }) {
+    back.show();
+    function handleBackNavigationTriggered() {
+        if (back.visible) {
+            window.history.back();
+        }
+    }
+    emitter.addListener('backNavigationTriggered', handleBackNavigationTriggered);
+    return () => {
+        emitter.removeListener('backNavigationTriggered', handleBackNavigationTriggered);
+    };
+}

package/dist/endpoint.d.ts

@@ -0,0 +1,2 @@
+import { type Endpoint } from 'comlink';
+export declare const endpoint: Endpoint;

package/dist/endpoint.js

@@ -0,0 +1,32 @@
+import { windowEndpoint } from 'comlink';
+const mockEndpoint = {
+    postMessage() {
+        // noop
+    },
+    addEventListener: () => {
+        // noop
+    },
+    removeEventListener: () => {
+        // noop
+    },
+};
+const webViewEndpoint = {
+    postMessage: (data) => {
+        console.debug('[webview:req]', data);
+        window.ReactNativeWebView.postMessage(JSON.stringify(data));
+    },
+    addEventListener: (_, listener, ...args) => {
+        document.addEventListener('FarcasterFrameCallback', listener, ...args);
+    },
+    removeEventListener: (_, listener) => {
+        document.removeEventListener('FarcasterFrameCallback', listener);
+    },
+};
+export const endpoint = (() => {
+    // No actions are actually gonna take place during SSR, thus it's safe to return mocked endpoint
+    if (typeof window === 'undefined')
+        return mockEndpoint;
+    return window?.ReactNativeWebView
+        ? webViewEndpoint
+        : windowEndpoint(window?.parent ?? window);
+})();

package/dist/ethereumProvider.d.ts

@@ -0,0 +1,3 @@
+import * as Provider from 'ox/Provider';
+export declare const ethereumProvider: Provider.Provider;
+export declare function getEthereumProvider(): Promise<Provider.Provider | undefined>;

package/dist/ethereumProvider.js

@@ -0,0 +1,132 @@
+import * as Provider from 'ox/Provider';
+import * as RpcRequest from 'ox/RpcRequest';
+import * as RpcResponse from 'ox/RpcResponse';
+import { miniAppHost } from "./miniAppHost.js";
+const emitter = Provider.createEmitter();
+const store = RpcRequest.createStore();
+function toProviderRpcError({ code, details, }) {
+    switch (code) {
+        case 4001:
+            return new Provider.UserRejectedRequestError();
+        case 4100:
+            return new Provider.UnauthorizedError();
+        case 4200:
+            return new Provider.UnsupportedMethodError();
+        case 4900:
+            return new Provider.DisconnectedError();
+        case 4901:
+            return new Provider.ChainDisconnectedError();
+        default:
+            return new Provider.ProviderRpcError(code, details ?? 'Unknown provider RPC error');
+    }
+}
+export const ethereumProvider = Provider.from({
+    ...emitter,
+    async request(args) {
+        // @ts-expect-error
+        const request = store.prepare(args);
+        try {
+            const response = await miniAppHost
+                .ethProviderRequestV2(request)
+                .then((res) => RpcResponse.parse(res, { request, raw: true }));
+            if (response.error) {
+                throw toProviderRpcError(response.error);
+            }
+            return response.result;
+        }
+        catch (e) {
+            // ethProviderRequestV2 not supported, fall back to v1
+            if (e instanceof Error &&
+                e.message.match(/cannot read property 'apply'/i)) {
+                return await miniAppHost.ethProviderRequest(request);
+            }
+            if (e instanceof Provider.ProviderRpcError ||
+                e instanceof RpcResponse.BaseError) {
+                throw e;
+            }
+            throw new RpcResponse.InternalError({
+                message: e instanceof Error ? e.message : undefined,
+            });
+        }
+    },
+});
+export async function getEthereumProvider() {
+    try {
+        const capabilities = await miniAppHost.getCapabilities();
+        if (!capabilities.includes('wallet.getEthereumProvider') &&
+            !capabilities.includes('wallet.getEvmProvider')) {
+            // We used getEvmProvider for a short period before getEthereumProvider.
+            // In case we're talking to an old host, we check the old key.
+            return undefined;
+        }
+        return ethereumProvider;
+    }
+    catch {
+        // If this is an old frame host that doesn't support getCapabilities,
+        // getEthereumProvider will assume that it's supported
+        return ethereumProvider;
+    }
+}
+function announceEvmProvider(detail) {
+    const event = new CustomEvent('eip6963:announceProvider', { detail: Object.freeze(detail) });
+    window.dispatchEvent(event);
+    const handler = () => window.dispatchEvent(event);
+    window.addEventListener('eip6963:requestProvider', handler);
+    return () => window.removeEventListener('eip6963:requestProvider', handler);
+}
+// Required to pass SSR
+if (typeof document !== 'undefined') {
+    // forward eip6963:requestProvider events to the host
+    document.addEventListener('eip6963:requestProvider', () => {
+        miniAppHost.eip6963RequestProvider();
+    });
+    // react native webview events
+    document.addEventListener('FarcasterFrameEthProviderEvent', (event) => {
+        if (event instanceof MessageEvent) {
+            const ethProviderEvent = event.data;
+            // @ts-expect-error
+            emitter.emit(ethProviderEvent.event, ...ethProviderEvent.params);
+        }
+    });
+    document.addEventListener('FarcasterFrameEvent', (event) => {
+        if (event instanceof MessageEvent) {
+            const miniAppEvent = event.data;
+            if (miniAppEvent.event === 'eip6963:announceProvider') {
+                announceEvmProvider({
+                    info: miniAppEvent.info,
+                    provider: ethereumProvider,
+                });
+            }
+        }
+    });
+}
+// Required to pass SSR
+if (typeof window !== 'undefined') {
+    // forward eip6963:requestProvider events to the host
+    window.addEventListener('eip6963:requestProvider', () => {
+        miniAppHost.eip6963RequestProvider();
+    });
+    // web events
+    window.addEventListener('message', (event) => {
+        if (event instanceof MessageEvent) {
+            if (event.data.type === 'frameEthProviderEvent') {
+                const ethProviderEvent = event.data;
+                // @ts-expect-error
+                emitter.emit(ethProviderEvent.event, ...ethProviderEvent.params);
+            }
+        }
+    });
+    window.addEventListener('message', (event) => {
+        if (event instanceof MessageEvent) {
+            if (event.data.type === 'frameEvent') {
+                const miniAppEvent = event.data.event;
+                if (miniAppEvent.event === 'eip6963:announceProvider') {
+                    announceEvmProvider({
+                        info: miniAppEvent.info,
+                        provider: ethereumProvider,
+                    });
+                }
+            }
+        }
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { sdk } from './sdk.ts';
+export * from './miniAppHost.ts';
+export * from './sdk.ts';
+export * from '@farcaster/miniapp-core';
+export * as QuickAuth from './quickAuth.ts';
+export { quickAuth } from './quickAuth.ts';
+export default sdk;

package/dist/index.js

@@ -0,0 +1,7 @@
+import { sdk } from "./sdk.js";
+export * from "./miniAppHost.js";
+export * from "./sdk.js";
+export * from '@farcaster/miniapp-core';
+export * as QuickAuth from "./quickAuth.js";
+export { quickAuth } from "./quickAuth.js";
+export default sdk;