@farcaster/frame-host 0.0.8 → 0.0.10

package/src/comlink/protocol.ts

@@ -0,0 +1,111 @@
+/**
+ * @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 const 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 const 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,4 +1,4 @@
-import * as Comlink from "comlink";
+import * as Comlink from "../comlink";
 import { FrameHost } from "@farcaster/frame-core";
 import { Provider } from "ox";
 import { forwardProviderEvents, wrapProviderRequest } from "./provider";
@@ -12,23 +12,26 @@ export function exposeToEndpoint({
   sdk, 
   frameOrigin,
   ethProvider, 
+  debug = false
 }: {
   endpoint: HostEndpoint,
   sdk: Omit<FrameHost, 'ethProviderRequestV2'>,
   frameOrigin: string;
   ethProvider?: Provider.Provider,
+  debug?: boolean
 }) {
   const extendedSdk = sdk as FrameHost;
 
   let cleanup: () => void | undefined;
   if (ethProvider) {
-    extendedSdk.ethProviderRequestV2 = wrapProviderRequest(ethProvider);
-    cleanup = forwardProviderEvents(ethProvider, endpoint);
+    extendedSdk.ethProviderRequestV2 = wrapProviderRequest({ provider: ethProvider, debug });
+    cleanup = forwardProviderEvents({ provider: ethProvider, endpoint });
   }
 
-  Comlink.expose(extendedSdk, endpoint, [frameOrigin]);
+  const unexpose = Comlink.expose(extendedSdk, endpoint, [frameOrigin]);
 
   return () => {
     cleanup?.();
+    unexpose();
   }
 }

package/src/helpers/provider.ts

@@ -1,10 +1,13 @@
 import { Provider, RpcRequest, RpcResponse } from "ox";
 import { HostEndpoint } from "../types";
 
-export function forwardProviderEvents(
+export function forwardProviderEvents({
+  provider,
+  endpoint
+}: {
   provider: Provider.Provider, 
   endpoint: HostEndpoint
-) {
+}) {
   let accountsChanged: Provider.EventMap['accountsChanged'] = (accounts) => {
     endpoint.emitEthProvider('accountsChanged', [accounts]);
   };
@@ -45,16 +48,33 @@ export function forwardProviderEvents(
   * Wraps a provider's request function with a result format that can transfer
   * errors across scripting boundaries.
   */
-export const wrapProviderRequest = (provider: Provider.Provider) => 
+export const wrapProviderRequest = ({
+  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);
-
-    return RpcResponse.from(
+    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(
         {

package/src/iframe.ts

@@ -1,4 +1,4 @@
-import * as Comlink from "comlink";
+import * as Comlink from "./comlink";
 import type { Provider } from "ox";
 import { FrameHost } from "@farcaster/frame-core";
 import { HostEndpoint } from "./types";
@@ -52,18 +52,21 @@ export function exposeToIframe({
   sdk,
   ethProvider,
   frameOrigin, 
+  debug = false
 }: {
   iframe: HTMLIFrameElement;
   sdk: Omit<FrameHost, 'ethProviderRequestV2'>;
   frameOrigin: string;
   ethProvider?: Provider.Provider;
+  debug?: boolean;
 }) {
-  const endpoint = createIframeEndpoint({ iframe, targetOrigin: frameOrigin });
+  const endpoint = createIframeEndpoint({ iframe, targetOrigin: frameOrigin, debug });
   const cleanup = exposeToEndpoint({
     endpoint, 
     sdk, 
     ethProvider,
-    frameOrigin
+    frameOrigin,
+    debug,
   });
 
   return {

package/src/types.ts

@@ -1,7 +1,7 @@
-import type * as Comlink from "comlink";
+import type { Endpoint } from "./comlink";
 import type { EmitEthProvider } from "@farcaster/frame-core";
 
-export type HostEndpoint = Comlink.Endpoint & {
+export type HostEndpoint = Endpoint & {
   emit: (data: any) => void;
   emitEthProvider: EmitEthProvider;
 };