@farcaster/frame-host 0.0.54 → 0.1.1

package/src/comlink/protocol.ts

@@ -1,111 +0,0 @@
-/**
- * @license
- * Copyright 2019 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-export interface EventSource {
-  addEventListener(
-    type: string,
-    listener: EventListenerOrEventListenerObject,
-    options?: {},
-  ): void
-
-  removeEventListener(
-    type: string,
-    listener: EventListenerOrEventListenerObject,
-    options?: {},
-  ): void
-}
-
-export interface PostMessageWithOrigin {
-  postMessage(
-    message: any,
-    targetOrigin: string,
-    transfer?: Transferable[],
-  ): void
-}
-
-export interface Endpoint extends EventSource {
-  postMessage(message: any, transfer?: Transferable[]): void
-
-  start?: () => void
-}
-
-export enum WireValueType {
-  RAW = 'RAW',
-  PROXY = 'PROXY',
-  THROW = 'THROW',
-  HANDLER = 'HANDLER',
-}
-
-export interface RawWireValue {
-  id?: string
-  type: WireValueType.RAW
-  value: {}
-}
-
-export interface HandlerWireValue {
-  id?: string
-  type: WireValueType.HANDLER
-  name: string
-  value: unknown
-}
-
-export type WireValue = RawWireValue | HandlerWireValue
-
-export type MessageID = string
-
-export enum MessageType {
-  GET = 'GET',
-  SET = 'SET',
-  APPLY = 'APPLY',
-  CONSTRUCT = 'CONSTRUCT',
-  ENDPOINT = 'ENDPOINT',
-  RELEASE = 'RELEASE',
-}
-
-export interface GetMessage {
-  id?: MessageID
-  type: MessageType.GET
-  path: string[]
-}
-
-export interface SetMessage {
-  id?: MessageID
-  type: MessageType.SET
-  path: string[]
-  value: WireValue
-}
-
-export interface ApplyMessage {
-  id?: MessageID
-  type: MessageType.APPLY
-  path: string[]
-  argumentList: WireValue[]
-}
-
-export interface ConstructMessage {
-  id?: MessageID
-  type: MessageType.CONSTRUCT
-  path: string[]
-  argumentList: WireValue[]
-}
-
-export interface EndpointMessage {
-  id?: MessageID
-  type: MessageType.ENDPOINT
-}
-
-export interface ReleaseMessage {
-  id?: MessageID
-  type: MessageType.RELEASE
-}
-
-export type Message =
-  | GetMessage
-  | SetMessage
-  | ApplyMessage
-  | ConstructMessage
-  | EndpointMessage
-  | ReleaseMessage

package/src/helpers/endpoint.ts

@@ -1,75 +0,0 @@
-import type { FrameHost } from '@farcaster/frame-core'
-import type * as Provider from 'ox/Provider'
-import { useEffect } from 'react'
-import * as Comlink from '../comlink/index.ts'
-import type { HostEndpoint } from '../types.ts'
-import {
-  forwardEthereumProviderEvents,
-  wrapEthereumProviderRequest,
-} from './ethereumProvider.ts'
-import { wrapHandlers } from './sdk.ts'
-
-/**
- * @returns function to cleanup provider listeners
- */
-export function exposeToEndpoint({
-  endpoint,
-  sdk,
-  frameOrigin,
-  ethProvider,
-  debug = false,
-}: {
-  endpoint: HostEndpoint
-  sdk: Omit<FrameHost, 'ethProviderRequestV2'>
-  frameOrigin: string
-  ethProvider?: Provider.Provider
-  debug?: boolean
-}) {
-  const extendedSdk = wrapHandlers(sdk as FrameHost)
-
-  let cleanup: (() => void) | undefined
-  if (ethProvider) {
-    extendedSdk.ethProviderRequestV2 = wrapEthereumProviderRequest({
-      provider: ethProvider,
-      debug,
-    })
-    cleanup = forwardEthereumProviderEvents({ provider: ethProvider, endpoint })
-  }
-
-  const unexpose = Comlink.expose(extendedSdk, endpoint, [frameOrigin])
-
-  return () => {
-    cleanup?.()
-    unexpose()
-  }
-}
-
-export function useExposeToEndpoint({
-  endpoint,
-  sdk,
-  frameOrigin,
-  ethProvider,
-  debug = false,
-}: {
-  endpoint: HostEndpoint | undefined
-  sdk: Omit<FrameHost, 'ethProviderRequestV2'>
-  frameOrigin: string
-  ethProvider?: Provider.Provider
-  debug?: boolean
-}) {
-  useEffect(() => {
-    if (!endpoint) {
-      return
-    }
-
-    const cleanup = exposeToEndpoint({
-      endpoint,
-      sdk,
-      frameOrigin,
-      ethProvider,
-      debug,
-    })
-
-    return cleanup
-  }, [endpoint, sdk, ethProvider, frameOrigin, debug])
-}

package/src/helpers/ethereumProvider.ts

@@ -1,125 +0,0 @@
-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 function forwardEthereumProviderEvents({
-  provider,
-  endpoint,
-}: {
-  provider: Provider.Provider
-  endpoint: HostEndpoint
-}) {
-  const accountsChanged: Provider.EventMap['accountsChanged'] = (accounts) => {
-    endpoint.emitEthProvider('accountsChanged', [accounts])
-  }
-  const chainChanged: Provider.EventMap['chainChanged'] = (chainId) => {
-    endpoint.emitEthProvider('chainChanged', [chainId])
-  }
-  const connect: Provider.EventMap['connect'] = (connectInfo) => {
-    endpoint.emitEthProvider('connect', [connectInfo])
-  }
-  const disconnect: Provider.EventMap['disconnect'] = (providerRpcError) => {
-    endpoint.emitEthProvider('disconnect', [providerRpcError])
-  }
-  const message: Provider.EventMap['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,
-  }: {
-    provider: Provider.Provider
-    debug?: boolean
-  }) =>
-  async (request: RpcRequest.RpcRequest) => {
-    try {
-      if (debug) {
-        console.debug('[frame-host] eth provider req: ', request)
-      }
-      const result = await provider.request(request)
-      const response = RpcResponse.from({ result }, { request })
-
-      if (debug) {
-        console.debug('[frame-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/src/helpers/sdk.ts

@@ -1,59 +0,0 @@
-import type { FrameHost, WireFrameHost } from '@farcaster/frame-core'
-import {
-  AddMiniApp,
-  SignIn,
-  wrapSolanaProviderRequest,
-} from '@farcaster/frame-core'
-
-export function wrapHandlers(host: FrameHost): WireFrameHost {
-  return {
-    ...host,
-    addFrame: async () => {
-      try {
-        const result = await host.addFrame()
-        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/src/iframe.ts

@@ -1,80 +0,0 @@
-import type { FrameHost } from '@farcaster/frame-core'
-import type { Provider } from 'ox/Provider'
-import * as Comlink from './comlink/index.ts'
-import { exposeToEndpoint } from './helpers/endpoint.ts'
-import type { HostEndpoint } from './types.ts'
-
-/**
- * An endpoint of communicating with an iFrame
- */
-export function createIframeEndpoint({
-  iframe,
-  targetOrigin,
-  debug = true,
-}: {
-  iframe: HTMLIFrameElement
-  targetOrigin: string
-  debug?: boolean
-}): HostEndpoint {
-  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,
-  frameOrigin,
-  debug = false,
-}: {
-  iframe: HTMLIFrameElement
-  sdk: Omit<FrameHost, 'ethProviderRequestV2'>
-  frameOrigin: string
-  ethProvider?: Provider
-  debug?: boolean
-}) {
-  const endpoint = createIframeEndpoint({
-    iframe,
-    targetOrigin: frameOrigin,
-    debug,
-  })
-  const cleanup = exposeToEndpoint({
-    endpoint,
-    sdk,
-    ethProvider,
-    frameOrigin,
-    debug,
-  })
-
-  return {
-    endpoint,
-    cleanup,
-  }
-}

package/src/types.ts

@@ -1,7 +0,0 @@
-import type { EmitEthProvider, FrameClientEvent } from '@farcaster/frame-core'
-import type { Endpoint } from './comlink/protocol.ts'
-
-export type HostEndpoint = Endpoint & {
-  emit: (event: FrameClientEvent) => void
-  emitEthProvider: EmitEthProvider
-}