@farcaster/frame-sdk 0.0.0-canary-20250430150627

package/dist/provider.d.ts

@@ -0,0 +1,2 @@
+import * as Provider from 'ox/Provider';
+export declare const provider: Provider.Provider;

package/dist/provider.js

@@ -0,0 +1,115 @@
+import * as Provider from 'ox/Provider';
+import * as RpcRequest from 'ox/RpcRequest';
+import * as RpcResponse from 'ox/RpcResponse';
+import { frameHost } from './frameHost';
+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 provider = Provider.from({
+    ...emitter,
+    async request(args) {
+        // @ts-expect-error
+        const request = store.prepare(args);
+        try {
+            const response = await frameHost
+                .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 frameHost.ethProviderRequest(request);
+            }
+            if (e instanceof Provider.ProviderRpcError ||
+                e instanceof RpcResponse.BaseError) {
+                throw e;
+            }
+            throw new RpcResponse.InternalError({
+                message: e instanceof Error ? e.message : undefined,
+            });
+        }
+    },
+});
+function announceProvider(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', () => {
+        frameHost.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 frameEvent = event.data;
+            if (frameEvent.event === 'eip6963:announceProvider') {
+                announceProvider({
+                    info: frameEvent.info,
+                    provider: provider,
+                });
+            }
+        }
+    });
+}
+// Required to pass SSR
+if (typeof window !== 'undefined') {
+    // forward eip6963:requestProvider events to the host
+    window.addEventListener('eip6963:requestProvider', () => {
+        frameHost.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 frameEvent = event.data.event;
+                if (frameEvent.event === 'eip6963:announceProvider') {
+                    announceProvider({
+                        info: frameEvent.info,
+                        provider: provider,
+                    });
+                }
+            }
+        }
+    });
+}

package/dist/sdk.d.ts

@@ -0,0 +1,3 @@
+import type { Emitter, FrameSDK } from './types';
+export declare function createEmitter(): Emitter;
+export declare const sdk: FrameSDK;

package/dist/sdk.js

@@ -0,0 +1,138 @@
+import { AddFrame, SignIn } from '@farcaster/frame-core';
+import { EventEmitter } from 'eventemitter3';
+import { frameHost } from './frameHost';
+import { provider } from './provider';
+export function createEmitter() {
+    const emitter = new EventEmitter();
+    return {
+        get eventNames() {
+            return emitter.eventNames.bind(emitter);
+        },
+        get listenerCount() {
+            return emitter.listenerCount.bind(emitter);
+        },
+        get listeners() {
+            return emitter.listeners.bind(emitter);
+        },
+        addListener: emitter.addListener.bind(emitter),
+        emit: emitter.emit.bind(emitter),
+        off: emitter.off.bind(emitter),
+        on: emitter.on.bind(emitter),
+        once: emitter.once.bind(emitter),
+        removeAllListeners: emitter.removeAllListeners.bind(emitter),
+        removeListener: emitter.removeListener.bind(emitter),
+    };
+}
+const emitter = createEmitter();
+export const sdk = {
+    ...emitter,
+    context: frameHost.context,
+    actions: {
+        setPrimaryButton: frameHost.setPrimaryButton.bind(frameHost),
+        ready: frameHost.ready.bind(frameHost),
+        close: frameHost.close.bind(frameHost),
+        viewProfile: frameHost.viewProfile.bind(frameHost),
+        signIn: async (options) => {
+            const response = await frameHost.signIn(options);
+            if (response.result) {
+                return response.result;
+            }
+            if (response.error.type === 'rejected_by_user') {
+                throw new SignIn.RejectedByUser();
+            }
+            throw new Error('Unreachable');
+        },
+        openUrl: (urlArg) => {
+            const url = typeof urlArg === 'string' ? urlArg : urlArg.url;
+            return frameHost.openUrl(url.trim());
+        },
+        addFrame: async () => {
+            const response = await frameHost.addFrame();
+            if (response.result) {
+                return response.result;
+            }
+            if (response.error.type === 'invalid_domain_manifest') {
+                throw new AddFrame.InvalidDomainManifest();
+            }
+            if (response.error.type === 'rejected_by_user') {
+                throw new AddFrame.RejectedByUser();
+            }
+            throw new Error('Unreachable');
+        },
+        composeCast(options = {}) {
+            return frameHost.composeCast(options);
+        },
+    },
+    experimental: {
+        viewToken: frameHost.viewToken.bind(frameHost),
+        sendToken: frameHost.sendToken.bind(frameHost),
+        swapToken: frameHost.swapToken.bind(frameHost),
+    },
+    wallet: {
+        ethProvider: provider,
+    },
+};
+// Required to pass SSR
+if (typeof document !== 'undefined') {
+    // react native webview events
+    document.addEventListener('FarcasterFrameEvent', (event) => {
+        if (event instanceof MessageEvent) {
+            const frameEvent = event.data;
+            if (frameEvent.event === 'primary_button_clicked') {
+                emitter.emit('primaryButtonClicked');
+            }
+            else if (frameEvent.event === 'frame_added') {
+                emitter.emit('frameAdded', {
+                    notificationDetails: frameEvent.notificationDetails,
+                });
+            }
+            else if (frameEvent.event === 'frame_add_rejected') {
+                emitter.emit('frameAddRejected', { reason: frameEvent.reason });
+            }
+            else if (frameEvent.event === 'frame_removed') {
+                emitter.emit('frameRemoved');
+            }
+            else if (frameEvent.event === 'notifications_enabled') {
+                emitter.emit('notificationsEnabled', {
+                    notificationDetails: frameEvent.notificationDetails,
+                });
+            }
+            else if (frameEvent.event === 'notifications_disabled') {
+                emitter.emit('notificationsDisabled');
+            }
+        }
+    });
+}
+// Required to pass SSR
+if (typeof window !== 'undefined') {
+    // web events
+    window.addEventListener('message', (event) => {
+        if (event instanceof MessageEvent) {
+            if (event.data.type === 'frameEvent') {
+                const frameEvent = event.data.event;
+                if (frameEvent.event === 'primary_button_clicked') {
+                    emitter.emit('primaryButtonClicked');
+                }
+                else if (frameEvent.event === 'frame_added') {
+                    emitter.emit('frameAdded', {
+                        notificationDetails: frameEvent.notificationDetails,
+                    });
+                }
+                else if (frameEvent.event === 'frame_add_rejected') {
+                    emitter.emit('frameAddRejected', { reason: frameEvent.reason });
+                }
+                else if (frameEvent.event === 'frame_removed') {
+                    emitter.emit('frameRemoved');
+                }
+                else if (frameEvent.event === 'notifications_enabled') {
+                    emitter.emit('notificationsEnabled', {
+                        notificationDetails: frameEvent.notificationDetails,
+                    });
+                }
+                else if (frameEvent.event === 'notifications_disabled') {
+                    emitter.emit('notificationsDisabled');
+                }
+            }
+        }
+    });
+}