@farcaster/frame-host 0.0.7 → 0.0.9

package/dist/comlink/comlink.d.ts

@@ -0,0 +1,155 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Endpoint, EventSource, PostMessageWithOrigin } from "./protocol";
+export type { Endpoint };
+export declare const proxyMarker: unique symbol;
+export declare const createEndpoint: unique symbol;
+export declare const releaseProxy: unique symbol;
+export declare const finalizer: unique symbol;
+/**
+ * Interface of values that were marked to be proxied with `comlink.proxy()`.
+ * Can also be implemented by classes.
+ */
+export interface ProxyMarked {
+    [proxyMarker]: true;
+}
+/**
+ * Takes a type and wraps it in a Promise, if it not already is one.
+ * This is to avoid `Promise<Promise<T>>`.
+ *
+ * This is the inverse of `Unpromisify<T>`.
+ */
+type Promisify<T> = T extends Promise<unknown> ? T : Promise<T>;
+/**
+ * Takes a type that may be Promise and unwraps the Promise type.
+ * If `P` is not a Promise, it returns `P`.
+ *
+ * This is the inverse of `Promisify<T>`.
+ */
+type Unpromisify<P> = P extends Promise<infer T> ? T : P;
+/**
+ * Takes the raw type of a remote property and returns the type that is visible to the local thread on the proxy.
+ *
+ * Note: This needs to be its own type alias, otherwise it will not distribute over unions.
+ * See https://www.typescriptlang.org/docs/handbook/advanced-types.html#distributive-conditional-types
+ */
+type RemoteProperty<T> = T extends Function | ProxyMarked ? Remote<T> : Promisify<T>;
+/**
+ * Takes the raw type of a property as a remote thread would see it through a proxy (e.g. when passed in as a function
+ * argument) and returns the type that the local thread has to supply.
+ *
+ * This is the inverse of `RemoteProperty<T>`.
+ *
+ * Note: This needs to be its own type alias, otherwise it will not distribute over unions. See
+ * https://www.typescriptlang.org/docs/handbook/advanced-types.html#distributive-conditional-types
+ */
+type LocalProperty<T> = T extends Function | ProxyMarked ? Local<T> : Unpromisify<T>;
+/**
+ * Proxies `T` if it is a `ProxyMarked`, clones it otherwise (as handled by structured cloning and transfer handlers).
+ */
+export type ProxyOrClone<T> = T extends ProxyMarked ? Remote<T> : T;
+/**
+ * Inverse of `ProxyOrClone<T>`.
+ */
+export type UnproxyOrClone<T> = T extends RemoteObject<ProxyMarked> ? Local<T> : T;
+/**
+ * Takes the raw type of a remote object in the other thread and returns the type as it is visible to the local thread
+ * when proxied with `Comlink.proxy()`.
+ *
+ * This does not handle call signatures, which is handled by the more general `Remote<T>` type.
+ *
+ * @template T The raw type of a remote object as seen in the other thread.
+ */
+export type RemoteObject<T> = {
+    [P in keyof T]: RemoteProperty<T[P]>;
+};
+/**
+ * Takes the type of an object as a remote thread would see it through a proxy (e.g. when passed in as a function
+ * argument) and returns the type that the local thread has to supply.
+ *
+ * This does not handle call signatures, which is handled by the more general `Local<T>` type.
+ *
+ * This is the inverse of `RemoteObject<T>`.
+ *
+ * @template T The type of a proxied object.
+ */
+export type LocalObject<T> = {
+    [P in keyof T]: LocalProperty<T[P]>;
+};
+/**
+ * Additional special comlink methods available on each proxy returned by `Comlink.wrap()`.
+ */
+export interface ProxyMethods {
+    [createEndpoint]: () => Promise<MessagePort>;
+    [releaseProxy]: () => void;
+}
+/**
+ * Takes the raw type of a remote object, function or class in the other thread and returns the type as it is visible to
+ * the local thread from the proxy return value of `Comlink.wrap()` or `Comlink.proxy()`.
+ */
+export type Remote<T> = RemoteObject<T> & (T extends (...args: infer TArguments) => infer TReturn ? (...args: {
+    [I in keyof TArguments]: UnproxyOrClone<TArguments[I]>;
+}) => Promisify<ProxyOrClone<Unpromisify<TReturn>>> : unknown) & (T extends {
+    new (...args: infer TArguments): infer TInstance;
+} ? {
+    new (...args: {
+        [I in keyof TArguments]: UnproxyOrClone<TArguments[I]>;
+    }): Promisify<Remote<TInstance>>;
+} : unknown) & ProxyMethods;
+/**
+ * Expresses that a type can be either a sync or async.
+ */
+type MaybePromise<T> = Promise<T> | T;
+/**
+ * Takes the raw type of a remote object, function or class as a remote thread would see it through a proxy (e.g. when
+ * passed in as a function argument) and returns the type the local thread has to supply.
+ *
+ * This is the inverse of `Remote<T>`. It takes a `Remote<T>` and returns its original input `T`.
+ */
+export type Local<T> = Omit<LocalObject<T>, keyof ProxyMethods> & (T extends (...args: infer TArguments) => infer TReturn ? (...args: {
+    [I in keyof TArguments]: ProxyOrClone<TArguments[I]>;
+}) => MaybePromise<UnproxyOrClone<Unpromisify<TReturn>>> : unknown) & (T extends {
+    new (...args: infer TArguments): infer TInstance;
+} ? {
+    new (...args: {
+        [I in keyof TArguments]: ProxyOrClone<TArguments[I]>;
+    }): MaybePromise<Local<Unpromisify<TInstance>>>;
+} : unknown);
+/**
+ * Customizes the serialization of certain values as determined by `canHandle()`.
+ *
+ * @template T The input type being handled by this transfer handler.
+ * @template S The serialized type sent over the wire.
+ */
+export interface TransferHandler<T, S> {
+    /**
+     * Gets called for every value to determine whether this transfer handler
+     * should serialize the value, which includes checking that it is of the right
+     * type (but can perform checks beyond that as well).
+     */
+    canHandle(value: unknown): value is T;
+    /**
+     * Gets called with the value if `canHandle()` returned `true` to produce a
+     * value that can be sent in a message, consisting of structured-cloneable
+     * values and/or transferrable objects.
+     */
+    serialize(value: T): [S, Transferable[]];
+    /**
+     * Gets called to deserialize an incoming value that was serialized in the
+     * other thread with this transfer handler (known through the name it was
+     * registered under).
+     */
+    deserialize(value: S): T;
+}
+/**
+ * Allows customizing the serialization of certain values.
+ */
+export declare const transferHandlers: Map<string, TransferHandler<unknown, unknown>>;
+export declare function expose(obj: any, ep?: Endpoint, allowedOrigins?: (string | RegExp)[]): () => void;
+export declare function wrap<T>(ep: Endpoint, target?: any): Remote<T>;
+export declare function transfer<T>(obj: T, transfers: Transferable[]): T;
+export declare function proxy<T extends {}>(obj: T): T & ProxyMarked;
+export declare function windowEndpoint(w: PostMessageWithOrigin, context?: EventSource, targetOrigin?: string): Endpoint;

package/dist/comlink/comlink.js

@@ -0,0 +1,367 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export const proxyMarker = Symbol("Comlink.proxy");
+export const createEndpoint = Symbol("Comlink.endpoint");
+export const releaseProxy = Symbol("Comlink.releaseProxy");
+export const finalizer = Symbol("Comlink.finalizer");
+const throwMarker = Symbol("Comlink.thrown");
+const isObject = (val) => (typeof val === "object" && val !== null) || typeof val === "function";
+/**
+ * Internal transfer handle to handle objects marked to proxy.
+ */
+const proxyTransferHandler = {
+    canHandle: (val) => isObject(val) && val[proxyMarker],
+    serialize(obj) {
+        const { port1, port2 } = new MessageChannel();
+        expose(obj, port1);
+        return [port2, [port2]];
+    },
+    deserialize(port) {
+        port.start();
+        return wrap(port);
+    },
+};
+/**
+ * Internal transfer handler to handle thrown exceptions.
+ */
+const throwTransferHandler = {
+    canHandle: (value) => isObject(value) && throwMarker in value,
+    serialize({ value }) {
+        let serialized;
+        if (value instanceof Error) {
+            serialized = {
+                isError: true,
+                value: {
+                    message: value.message,
+                    name: value.name,
+                    stack: value.stack,
+                },
+            };
+        }
+        else {
+            serialized = { isError: false, value };
+        }
+        return [serialized, []];
+    },
+    deserialize(serialized) {
+        if (serialized.isError) {
+            throw Object.assign(new Error(serialized.value.message), serialized.value);
+        }
+        throw serialized.value;
+    },
+};
+/**
+ * Allows customizing the serialization of certain values.
+ */
+export const transferHandlers = new Map([
+    ["proxy", proxyTransferHandler],
+    ["throw", throwTransferHandler],
+]);
+function isAllowedOrigin(allowedOrigins, origin) {
+    for (const allowedOrigin of allowedOrigins) {
+        if (origin === allowedOrigin || allowedOrigin === "*") {
+            return true;
+        }
+        if (allowedOrigin instanceof RegExp && allowedOrigin.test(origin)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function expose(obj, ep = globalThis, allowedOrigins = ["*"]) {
+    function callback(ev) {
+        if (!ev || !ev.data) {
+            return;
+        }
+        if (!isAllowedOrigin(allowedOrigins, ev.origin)) {
+            console.warn(`Invalid origin '${ev.origin}' for comlink proxy`);
+            return;
+        }
+        const { id, type, path } = {
+            path: [],
+            ...ev.data,
+        };
+        const argumentList = (ev.data.argumentList || []).map(fromWireValue);
+        let returnValue;
+        try {
+            const parent = path.slice(0, -1).reduce((obj, prop) => obj[prop], obj);
+            const rawValue = path.reduce((obj, prop) => obj[prop], obj);
+            switch (type) {
+                case "GET" /* MessageType.GET */:
+                    {
+                        returnValue = rawValue;
+                    }
+                    break;
+                case "SET" /* MessageType.SET */:
+                    {
+                        parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);
+                        returnValue = true;
+                    }
+                    break;
+                case "APPLY" /* MessageType.APPLY */:
+                    {
+                        returnValue = rawValue.apply(parent, argumentList);
+                    }
+                    break;
+                case "CONSTRUCT" /* MessageType.CONSTRUCT */:
+                    {
+                        const value = new rawValue(...argumentList);
+                        returnValue = proxy(value);
+                    }
+                    break;
+                case "ENDPOINT" /* MessageType.ENDPOINT */:
+                    {
+                        const { port1, port2 } = new MessageChannel();
+                        expose(obj, port2);
+                        returnValue = transfer(port1, [port1]);
+                    }
+                    break;
+                case "RELEASE" /* MessageType.RELEASE */:
+                    {
+                        returnValue = undefined;
+                    }
+                    break;
+                default:
+                    return;
+            }
+        }
+        catch (value) {
+            returnValue = { value, [throwMarker]: 0 };
+        }
+        Promise.resolve(returnValue)
+            .catch((value) => {
+            return { value, [throwMarker]: 0 };
+        })
+            .then((returnValue) => {
+            const [wireValue, transferables] = toWireValue(returnValue);
+            ep.postMessage({ ...wireValue, id }, transferables);
+            if (type === "RELEASE" /* MessageType.RELEASE */) {
+                // detach and deactive after sending release response above.
+                ep.removeEventListener("message", callback);
+                closeEndPoint(ep);
+                if (finalizer in obj && typeof obj[finalizer] === "function") {
+                    obj[finalizer]();
+                }
+            }
+        })
+            .catch((error) => {
+            // Send Serialization Error To Caller
+            const [wireValue, transferables] = toWireValue({
+                value: new TypeError("Unserializable return value"),
+                [throwMarker]: 0,
+            });
+            ep.postMessage({ ...wireValue, id }, transferables);
+        });
+    }
+    ;
+    ep.addEventListener("message", callback);
+    if (ep.start) {
+        ep.start();
+    }
+    return () => {
+        ep.removeEventListener("message", callback);
+        closeEndPoint(ep);
+        if (finalizer in obj && typeof obj[finalizer] === "function") {
+            obj[finalizer]();
+        }
+    };
+}
+function isMessagePort(endpoint) {
+    return endpoint.constructor.name === "MessagePort";
+}
+function closeEndPoint(endpoint) {
+    if (isMessagePort(endpoint))
+        endpoint.close();
+}
+export function wrap(ep, target) {
+    const pendingListeners = new Map();
+    ep.addEventListener("message", function handleMessage(ev) {
+        const { data } = ev;
+        if (!data || !data.id) {
+            return;
+        }
+        const resolver = pendingListeners.get(data.id);
+        if (!resolver) {
+            return;
+        }
+        try {
+            resolver(data);
+        }
+        finally {
+            pendingListeners.delete(data.id);
+        }
+    });
+    return createProxy(ep, pendingListeners, [], target);
+}
+function throwIfProxyReleased(isReleased) {
+    if (isReleased) {
+        throw new Error("Proxy has been released and is not useable");
+    }
+}
+function releaseEndpoint(ep) {
+    return requestResponseMessage(ep, new Map(), {
+        type: "RELEASE" /* MessageType.RELEASE */,
+    }).then(() => {
+        closeEndPoint(ep);
+    });
+}
+const proxyCounter = new WeakMap();
+const proxyFinalizers = "FinalizationRegistry" in globalThis &&
+    new FinalizationRegistry((ep) => {
+        const newCount = (proxyCounter.get(ep) || 0) - 1;
+        proxyCounter.set(ep, newCount);
+        if (newCount === 0) {
+            releaseEndpoint(ep);
+        }
+    });
+function registerProxy(proxy, ep) {
+    const newCount = (proxyCounter.get(ep) || 0) + 1;
+    proxyCounter.set(ep, newCount);
+    if (proxyFinalizers) {
+        proxyFinalizers.register(proxy, ep, proxy);
+    }
+}
+function unregisterProxy(proxy) {
+    if (proxyFinalizers) {
+        proxyFinalizers.unregister(proxy);
+    }
+}
+function createProxy(ep, pendingListeners, path = [], target = function () { }) {
+    let isProxyReleased = false;
+    const proxy = new Proxy(target, {
+        get(_target, prop) {
+            throwIfProxyReleased(isProxyReleased);
+            if (prop === releaseProxy) {
+                return () => {
+                    unregisterProxy(proxy);
+                    releaseEndpoint(ep);
+                    pendingListeners.clear();
+                    isProxyReleased = true;
+                };
+            }
+            if (prop === "then") {
+                if (path.length === 0) {
+                    return { then: () => proxy };
+                }
+                const r = requestResponseMessage(ep, pendingListeners, {
+                    type: "GET" /* MessageType.GET */,
+                    path: path.map((p) => p.toString()),
+                }).then(fromWireValue);
+                return r.then.bind(r);
+            }
+            return createProxy(ep, pendingListeners, [...path, prop]);
+        },
+        set(_target, prop, rawValue) {
+            throwIfProxyReleased(isProxyReleased);
+            // FIXME: ES6 Proxy Handler `set` methods are supposed to return a
+            // boolean. To show good will, we return true asynchronously ¯\_(ツ)_/¯
+            const [value, transferables] = toWireValue(rawValue);
+            return requestResponseMessage(ep, pendingListeners, {
+                type: "SET" /* MessageType.SET */,
+                path: [...path, prop].map((p) => p.toString()),
+                value,
+            }, transferables).then(fromWireValue);
+        },
+        apply(_target, _thisArg, rawArgumentList) {
+            throwIfProxyReleased(isProxyReleased);
+            const last = path[path.length - 1];
+            if (last === createEndpoint) {
+                return requestResponseMessage(ep, pendingListeners, {
+                    type: "ENDPOINT" /* MessageType.ENDPOINT */,
+                }).then(fromWireValue);
+            }
+            // We just pretend that `bind()` didn’t happen.
+            if (last === "bind") {
+                return createProxy(ep, pendingListeners, path.slice(0, -1));
+            }
+            const [argumentList, transferables] = processArguments(rawArgumentList);
+            return requestResponseMessage(ep, pendingListeners, {
+                type: "APPLY" /* MessageType.APPLY */,
+                path: path.map((p) => p.toString()),
+                argumentList,
+            }, transferables).then(fromWireValue);
+        },
+        construct(_target, rawArgumentList) {
+            throwIfProxyReleased(isProxyReleased);
+            const [argumentList, transferables] = processArguments(rawArgumentList);
+            return requestResponseMessage(ep, pendingListeners, {
+                type: "CONSTRUCT" /* MessageType.CONSTRUCT */,
+                path: path.map((p) => p.toString()),
+                argumentList,
+            }, transferables).then(fromWireValue);
+        },
+    });
+    registerProxy(proxy, ep);
+    return proxy;
+}
+function myFlat(arr) {
+    return Array.prototype.concat.apply([], arr);
+}
+function processArguments(argumentList) {
+    const processed = argumentList.map(toWireValue);
+    return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];
+}
+const transferCache = new WeakMap();
+export function transfer(obj, transfers) {
+    transferCache.set(obj, transfers);
+    return obj;
+}
+export function proxy(obj) {
+    return Object.assign(obj, { [proxyMarker]: true });
+}
+export function windowEndpoint(w, context = globalThis, targetOrigin = "*") {
+    return {
+        postMessage: (msg, transferables) => w.postMessage(msg, targetOrigin, transferables),
+        addEventListener: context.addEventListener.bind(context),
+        removeEventListener: context.removeEventListener.bind(context),
+    };
+}
+function toWireValue(value) {
+    for (const [name, handler] of transferHandlers) {
+        if (handler.canHandle(value)) {
+            const [serializedValue, transferables] = handler.serialize(value);
+            return [
+                {
+                    type: "HANDLER" /* WireValueType.HANDLER */,
+                    name,
+                    value: serializedValue,
+                },
+                transferables,
+            ];
+        }
+    }
+    return [
+        {
+            type: "RAW" /* WireValueType.RAW */,
+            value,
+        },
+        transferCache.get(value) || [],
+    ];
+}
+function fromWireValue(value) {
+    switch (value.type) {
+        case "HANDLER" /* WireValueType.HANDLER */:
+            return transferHandlers.get(value.name).deserialize(value.value);
+        case "RAW" /* WireValueType.RAW */:
+            return value.value;
+    }
+}
+function requestResponseMessage(ep, pendingListeners, msg, transfers) {
+    return new Promise((resolve) => {
+        const id = generateUUID();
+        pendingListeners.set(id, resolve);
+        if (ep.start) {
+            ep.start();
+        }
+        ep.postMessage({ id, ...msg }, transfers);
+    });
+}
+function generateUUID() {
+    return new Array(4)
+        .fill(0)
+        .map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16))
+        .join("-");
+}

package/dist/comlink/index.d.ts

@@ -0,0 +1 @@
+export * from "./comlink";

package/dist/comlink/index.js

@@ -0,0 +1 @@
+export * from "./comlink";

package/dist/comlink/node-adapter.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Endpoint } from "./protocol";
+export interface NodeEndpoint {
+    postMessage(message: any, transfer?: any[]): void;
+    on(type: string, listener: EventListenerOrEventListenerObject, options?: {}): void;
+    off(type: string, listener: EventListenerOrEventListenerObject, options?: {}): void;
+    start?: () => void;
+}
+export default function nodeEndpoint(nep: NodeEndpoint): Endpoint;

package/dist/comlink/node-adapter.js

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export default function nodeEndpoint(nep) {
+    const listeners = new WeakMap();
+    return {
+        postMessage: nep.postMessage.bind(nep),
+        addEventListener: (_, eh) => {
+            const l = (data) => {
+                if ("handleEvent" in eh) {
+                    eh.handleEvent({ data });
+                }
+                else {
+                    eh({ data });
+                }
+            };
+            nep.on("message", l);
+            listeners.set(eh, l);
+        },
+        removeEventListener: (_, eh) => {
+            const l = listeners.get(eh);
+            if (!l) {
+                return;
+            }
+            nep.off("message", l);
+            listeners.delete(eh);
+        },
+        start: nep.start && nep.start.bind(nep),
+    };
+}

package/dist/comlink/protocol.d.ts

@@ -0,0 +1,75 @@
+/**
+ * @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 declare 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 declare 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/dist/comlink/protocol.js

@@ -0,0 +1,6 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};

package/dist/helpers/endpoint.d.ts

@@ -4,4 +4,9 @@ import { HostEndpoint } from "../types";
 /**
   * @returns function to cleanup provider listeners
   */
-export declare function exposeToEndpoint(endpoint: HostEndpoint, sdk: Omit<FrameHost, 'ethProviderRequestV2'>, provider?: Provider.Provider): () => void;
+export declare function exposeToEndpoint({ endpoint, sdk, frameOrigin, ethProvider, }: {
+    endpoint: HostEndpoint;
+    sdk: Omit<FrameHost, 'ethProviderRequestV2'>;
+    frameOrigin: string;
+    ethProvider?: Provider.Provider;
+}): () => void;

package/dist/helpers/endpoint.js

@@ -1,17 +1,18 @@
-import * as Comlink from "comlink";
+import * as Comlink from "../comlink";
 import { forwardProviderEvents, wrapProviderRequest } from "./provider";
 /**
   * @returns function to cleanup provider listeners
   */
-export function exposeToEndpoint(endpoint, sdk, provider) {
+export function exposeToEndpoint({ endpoint, sdk, frameOrigin, ethProvider, }) {
     const extendedSdk = sdk;
     let cleanup;
-    if (provider) {
-        extendedSdk.ethProviderRequestV2 = wrapProviderRequest(provider);
-        cleanup = forwardProviderEvents(provider, endpoint);
+    if (ethProvider) {
+        extendedSdk.ethProviderRequestV2 = wrapProviderRequest(ethProvider);
+        cleanup = forwardProviderEvents(ethProvider, endpoint);
     }
-    Comlink.expose(extendedSdk, endpoint);
+    const unexpose = Comlink.expose(extendedSdk, endpoint, [frameOrigin]);
     return () => {
         cleanup === null || cleanup === void 0 ? void 0 : cleanup();
+        unexpose();
     };
 }