@dynamic-labs/message-transport 0.0.0-exp20240808.0

package/src/messageTypes/NetworksModuleMessages.d.ts

@@ -0,0 +1,5 @@
+import { GenericNetwork } from '@dynamic-labs/types';
+export type NetworksModuleState = {
+    evm: GenericNetwork[];
+    solana: GenericNetwork[];
+};

package/src/messageTypes/OtpMessages.d.ts

@@ -0,0 +1,17 @@
+import { OtpDestination, PhoneData } from '@dynamic-labs/types';
+type OtpData = {
+    destination: Extract<OtpDestination, 'email'>;
+    target: string;
+} | {
+    destination: Extract<OtpDestination, 'sms'>;
+    target: PhoneData;
+};
+export type OtpMessages = {
+    /** Request to send an OTP to a destination for verification */
+    sendOTP: (data: OtpData) => Promise<void>;
+    /** Performs verification for the latest send OTP */
+    verifyOTP: (token: string) => Promise<void>;
+    /** Re-sends the OTP for verification */
+    resendOTP: () => Promise<void>;
+};
+export {};

package/src/messageTypes/PasskeyMessages.d.ts

@@ -0,0 +1,32 @@
+type CustomPublicKeyCredentialUserEntity = Omit<PublicKeyCredentialUserEntity, 'id'> & {
+    id: string;
+};
+type CustomPublicKeyCredentialRpEntity = Omit<PublicKeyCredentialRpEntity, 'id'> & {
+    id: string;
+};
+export type PasskeyMessages = {
+    createPasskey: (params: {
+        publicKey: {
+            authenticatorName: string;
+            attestation?: AttestationConveyancePreference;
+            authenticatorSelection?: AuthenticatorSelectionCriteria;
+            challenge?: string;
+            pubKeyCredParams: PublicKeyCredentialParameters[];
+            rp: CustomPublicKeyCredentialRpEntity;
+            timeout?: number;
+            user: CustomPublicKeyCredentialUserEntity;
+        };
+    }) => Promise<{
+        attestation: {
+            credentialId: string;
+            clientDataJson: string;
+            attestationObject: string;
+            transports: ('AUTHENTICATOR_TRANSPORT_BLE' | 'AUTHENTICATOR_TRANSPORT_INTERNAL' | 'AUTHENTICATOR_TRANSPORT_NFC' | 'AUTHENTICATOR_TRANSPORT_USB' | 'AUTHENTICATOR_TRANSPORT_HYBRID')[];
+        };
+    }>;
+    passkeyStamp: (rdId: string, payload: string) => Promise<{
+        stampHeaderName: string;
+        stampHeaderValue: string;
+    }>;
+};
+export {};

package/src/messageTypes/PlatformServiceMessages.d.ts

@@ -0,0 +1,17 @@
+export type PlatformServiceMessages = {
+    /**
+     * Origin: Webview.
+     * Requests that a deeplink be open by whichever platform the client is running in.
+     */
+    openURL: (url: string) => Promise<void>;
+    /**
+     * Origin: Webview.
+     * Opens the URL in a secure browser window for authentication.
+     *
+     * Resolves with the URL used to deeplink back to this app.
+     */
+    openAuthenticationWindow: (props: {
+        url: string;
+        redirectUrl?: string;
+    }) => Promise<string>;
+};

package/src/messageTypes/SdkModuleMessages.cjs

@@ -0,0 +1,9 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/** Easy access to the event name that indicates the SDK has loaded */
+const sdkHasLoadedEventName = 'sdk__loadedChanged';
+
+exports.sdkHasLoadedEventName = sdkHasLoadedEventName;

package/src/messageTypes/SdkModuleMessages.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Defines the settings required by the SDK to be properly initialized
+ * inside the webview
+ */
+export type ClientManifest = {
+    apiBaseUrl?: string;
+    appLogoUrl?: string;
+    appName?: string;
+    appOrigin?: string;
+    clientVersion: string;
+    cssOverrides?: string;
+    environmentId: string;
+    platform: 'browser' | 'react-native' | 'flutter';
+    redirectUrl: string;
+};
+export type SdkModuleState = {
+    /** Indicates the SDK is set up and ready for requests */
+    loaded: boolean;
+};
+export type SdkModuleMessages = {
+    /** Sent from the webview app to request the SDK settings */
+    manifest: () => Promise<ClientManifest>;
+};
+/** Easy access to the event name that indicates the SDK has loaded */
+export declare const sdkHasLoadedEventName = "sdk__loadedChanged";

package/src/messageTypes/SdkModuleMessages.js

@@ -0,0 +1,5 @@
+'use client'
+/** Easy access to the event name that indicates the SDK has loaded */
+const sdkHasLoadedEventName = 'sdk__loadedChanged';
+
+export { sdkHasLoadedEventName };

package/src/messageTypes/SocialAuthModuleMessages.d.ts

@@ -0,0 +1,17 @@
+export type SocialProvider = 'apple' | 'coinbaseSocial' | 'discord' | 'facebook' | 'farcaster' | 'github' | 'google' | 'telegram' | 'twitch' | 'twitter';
+export type SocialAuthModuleMessages = {
+    connectWithSocial: (args: {
+        /**
+         * Provider with which to connect
+         */
+        provider: SocialProvider;
+        /**
+         * When using expo-router, which pathname to redirect back to after social connection.
+         *
+         * The router will create another stack when redirecting back to a different pathname than your
+         * app was at originally, which in iOS devices will cause visual flickering. To avoid this, pass
+         * `usePathname()` to this property.
+         */
+        redirectPathname?: string;
+    }) => Promise<void>;
+};

package/src/messageTypes/SolanaMessages.d.ts

@@ -0,0 +1,42 @@
+type Commitment = 'processed' | 'confirmed' | 'finalized' | 'recent' | 'single' | 'singleGossip' | 'root' | 'max';
+type SendOptions = {
+    skipPreflight?: boolean;
+    preflightCommitment?: Commitment;
+    maxRetries?: number;
+    minContextSlot?: number;
+};
+type EncodedTransaction = {
+    type: 'legacy' | 'versioned';
+    transaction: string;
+};
+/**
+ * Messages exchanged for solana requests.
+ */
+export type SolanaMessages = {
+    solana_signMessage: (arg: {
+        message: string;
+        walletId: string;
+    }) => Promise<{
+        signature: string;
+    }>;
+    solana_signAndSendTransaction: (arg: {
+        walletId: string;
+        options?: SendOptions;
+        encodedTransaction: EncodedTransaction;
+    }) => Promise<{
+        signature: string;
+    }>;
+    solana_signTransaction: (arg: {
+        walletId: string;
+        encodedTransaction: EncodedTransaction;
+    }) => Promise<{
+        encodedTransaction: EncodedTransaction;
+    }>;
+    solana_signAllTransactions: (arg: {
+        walletId: string;
+        encodedTransactions: EncodedTransaction[];
+    }) => Promise<{
+        encodedTransactions: EncodedTransaction[];
+    }>;
+};
+export {};

package/src/messageTypes/UserInterfaceModuleMessages.d.ts

@@ -0,0 +1,8 @@
+export type UserInterfaceModuleMessages = {
+    openUserProfile: () => void;
+    openAuthFlow: () => void;
+    /** Opens the secret key export for embedded wallets */
+    revealEmbeddedWalletKey: (params: {
+        type: 'recovery-phrase' | 'private-key';
+    }) => void;
+};

package/src/messageTypes/WalletsModuleMessages.d.ts

@@ -0,0 +1,30 @@
+import { BaseWallet } from '@dynamic-labs/types';
+export type WalletsModuleState = {
+    userWallets: BaseWallet[];
+    primary: BaseWallet | undefined;
+};
+export type WalletsModuleMessages = {
+    getBalance: (params: {
+        wallet: BaseWallet;
+    }) => Promise<{
+        balance: string;
+    }>;
+    signMessage: (params: {
+        wallet: BaseWallet;
+        message: string;
+    }) => Promise<{
+        signedMessage: string;
+    }>;
+    getNetwork: (params: {
+        wallet: BaseWallet;
+    }) => Promise<{
+        network: string | number;
+    }>;
+    switchNetwork: (params: {
+        wallet: BaseWallet;
+        chainId: string | number;
+    }) => Promise<void>;
+    setPrimary: (params: {
+        walletId: string;
+    }) => Promise<void>;
+};

package/src/messageTypes/WebViewVisibilityMessages.d.ts

@@ -0,0 +1,3 @@
+export type WebViewVisibilityMessages = {
+    setVisibility: (visible: boolean) => void;
+};

package/src/messageTypes/index.d.ts

@@ -0,0 +1,16 @@
+export * from './AuthModuleMessages';
+export * from './ConsoleMessages';
+export * from './EmbeddedWalletsModuleMessages';
+export * from './EthMessages';
+export * from './ExternalAuthMessages';
+export * from './FetchMessages';
+export * from './NetworksModuleMessages';
+export * from './OtpMessages';
+export * from './PasskeyMessages';
+export * from './PlatformServiceMessages';
+export * from './SdkModuleMessages';
+export * from './SocialAuthModuleMessages';
+export * from './SolanaMessages';
+export * from './UserInterfaceModuleMessages';
+export * from './WalletsModuleMessages';
+export * from './WebViewVisibilityMessages';

package/src/requestChannel/index.d.ts

@@ -0,0 +1 @@
+export * from './requestChannel';

package/src/requestChannel/requestChannel.cjs

@@ -0,0 +1,121 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var parseErrorFromTransport = require('../utils/parseErrorFromTransport/parseErrorFromTransport.cjs');
+var serializeErrorForTransport = require('../utils/serializeErrorForTransport/serializeErrorForTransport.cjs');
+var isSerializedError = require('../utils/isSerializedError/isSerializedError.cjs');
+
+/** Given a request event name, returns the event name for its resolve */
+const getResolveMessageType = (type) => `${type}__resolve`;
+/** Given a request event name, returns the event name for its reject */
+const getRejectMessageType = (type) => `${type}__reject`;
+/**
+ * Allows handling and submitting requests to and from a webview.
+ * Requests are messages that (can) expect some response.
+ *
+ * Functions similarly to an event emitter, but adds a response feature:
+ * - Emitting an event type is the act of making a "request" of a specific type,
+ * and it returns a promise that will resolve to the request's response.
+ * - Listening to an event type is the act of "handling" requests of a specific type.
+ * This handler callback must return a promise if this request type expects responses.
+ *
+ * Think of it this way:
+ * Whenever I emit an event, I am submitting a request.
+ * Whoever listens to the event will handle my request.
+ * If the request type expects some kind of response, they will
+ * return a promise that resolves (or rejects) after my request is fulfilled.
+ *
+ * This is an abstraction built on top of the MessageTransport interface.
+ */
+const createRequestChannel = (messageTransport) => {
+    /** Used to generated unique ids */
+    let uniqueIdCounter = 0;
+    /** Id prefix unique to this channel */
+    const idPrefix = Math.random().toString();
+    /** Always returns a different string */
+    const getUniqueId = () => `${idPrefix}-${uniqueIdCounter++}`;
+    return {
+        emit: (requestName, ...params) => {
+            // Generate the unique id for this message exchange session
+            // Although we won't listen for a response, it must still be unique
+            // to avoid tangling with other requests.
+            const messageSessionId = getUniqueId();
+            messageTransport.emit({
+                args: params,
+                messageSessionId,
+                type: requestName,
+            });
+        },
+        handle: (requestType, handler) => {
+            const messageHandler = (_a) => _tslib.__awaiter(void 0, [_a], void 0, function* ({ args, messageSessionId, type: incomingType, }) {
+                if (requestType !== incomingType)
+                    return;
+                const result = handler(...args);
+                // If the handler doesn't return a promise,
+                // that means we don't need to respond.
+                if (!(result instanceof Promise))
+                    return;
+                try {
+                    const response = yield result;
+                    messageTransport.emit({
+                        args: [response],
+                        messageSessionId,
+                        type: getResolveMessageType(requestType),
+                    });
+                }
+                catch (error) {
+                    messageTransport.emit({
+                        args: [serializeErrorForTransport.serializeErrorForTransport(error)],
+                        messageSessionId,
+                        type: getRejectMessageType(requestType),
+                    });
+                }
+            });
+            messageTransport.on(messageHandler);
+            return () => {
+                messageTransport.off(messageHandler);
+            };
+        },
+        request: (requestName, ...params) => new Promise((resolve, reject) => {
+            const requestType = requestName;
+            // Generate the unique id for this message exchange session
+            const messageSessionId = getUniqueId();
+            const resolveMessageType = getResolveMessageType(requestType);
+            const rejectMessageType = getRejectMessageType(requestType);
+            // Before actually emitting the event, we start listening to the
+            // response events
+            const handleMessage = ({ args: [result], messageSessionId: incomingSessionId, type: incomingType, }) => {
+                if (incomingSessionId !== messageSessionId)
+                    return;
+                if (incomingType === resolveMessageType) {
+                    resolve(result);
+                    cleanup();
+                }
+                if (incomingType === rejectMessageType) {
+                    if (isSerializedError.isSerializedError(result)) {
+                        reject(parseErrorFromTransport.parseErrorFromTransport(result));
+                    }
+                    else {
+                        reject(result);
+                    }
+                    cleanup();
+                }
+            };
+            const cleanup = () => messageTransport.off(handleMessage);
+            messageTransport.on(handleMessage);
+            // Now we emit the event to set off the request
+            messageTransport.emit({
+                args: params,
+                messageSessionId,
+                type: requestType,
+            });
+        }),
+    };
+};
+
+exports.createRequestChannel = createRequestChannel;
+exports.getRejectMessageType = getRejectMessageType;
+exports.getResolveMessageType = getResolveMessageType;

package/src/requestChannel/requestChannel.d.ts

@@ -0,0 +1,55 @@
+import { MessageTransportWithDefaultOrigin } from '../messageTransport/decorators/applyDefaultMessageOrigin/applyDefaultMessageOrigin';
+/**
+ * An object that defines request types, and whether they expect a response
+ */
+export type RequestTypes = Record<string, (...params: any[]) => Promise<any> | void>;
+/**
+ * Only the request types from T that return promises
+ * i.e. those that expect a response
+ */
+type TypesExpectingResponse<T extends RequestTypes> = {
+    [K in keyof T]: ReturnType<T[K]> extends Promise<any> ? K : never;
+}[keyof T];
+export type RequestChannel<T extends RequestTypes> = {
+    /**
+     * Listens to incoming requests of this type, and calls the handler when they arrive.
+     * If the type of this request expects some response, the handler must return a promise
+     * that resolves to this response.
+     * @returns an unsubscribe function.
+     */
+    handle: <K extends keyof T>(requestType: K, handler: T[K]) => VoidFunction;
+    /**
+     * Triggers handlers for this request type, with the given params.
+     * Doesn't care whether this request will have a response or not, so returns void.
+     */
+    emit: <K extends keyof T>(requestName: K, ...params: Parameters<T[K]>) => void;
+    /**
+     * Triggers handlers for this request type, with the given params.
+     * @returns a promise that resolves/rejects when a handler fulfills this request.
+     */
+    request: <K extends TypesExpectingResponse<T>>(requestName: K, ...params: Parameters<T[K]>) => ReturnType<T[K]>;
+};
+/** Given a request event name, returns the event name for its resolve */
+export declare const getResolveMessageType: (type: string) => string;
+/** Given a request event name, returns the event name for its reject */
+export declare const getRejectMessageType: (type: string) => string;
+/**
+ * Allows handling and submitting requests to and from a webview.
+ * Requests are messages that (can) expect some response.
+ *
+ * Functions similarly to an event emitter, but adds a response feature:
+ * - Emitting an event type is the act of making a "request" of a specific type,
+ * and it returns a promise that will resolve to the request's response.
+ * - Listening to an event type is the act of "handling" requests of a specific type.
+ * This handler callback must return a promise if this request type expects responses.
+ *
+ * Think of it this way:
+ * Whenever I emit an event, I am submitting a request.
+ * Whoever listens to the event will handle my request.
+ * If the request type expects some kind of response, they will
+ * return a promise that resolves (or rejects) after my request is fulfilled.
+ *
+ * This is an abstraction built on top of the MessageTransport interface.
+ */
+export declare const createRequestChannel: <T extends RequestTypes = never>(messageTransport: MessageTransportWithDefaultOrigin) => RequestChannel<T>;
+export {};

package/src/requestChannel/requestChannel.js

@@ -0,0 +1,115 @@
+'use client'
+import { __awaiter } from '../../_virtual/_tslib.js';
+import { parseErrorFromTransport } from '../utils/parseErrorFromTransport/parseErrorFromTransport.js';
+import { serializeErrorForTransport } from '../utils/serializeErrorForTransport/serializeErrorForTransport.js';
+import { isSerializedError } from '../utils/isSerializedError/isSerializedError.js';
+
+/** Given a request event name, returns the event name for its resolve */
+const getResolveMessageType = (type) => `${type}__resolve`;
+/** Given a request event name, returns the event name for its reject */
+const getRejectMessageType = (type) => `${type}__reject`;
+/**
+ * Allows handling and submitting requests to and from a webview.
+ * Requests are messages that (can) expect some response.
+ *
+ * Functions similarly to an event emitter, but adds a response feature:
+ * - Emitting an event type is the act of making a "request" of a specific type,
+ * and it returns a promise that will resolve to the request's response.
+ * - Listening to an event type is the act of "handling" requests of a specific type.
+ * This handler callback must return a promise if this request type expects responses.
+ *
+ * Think of it this way:
+ * Whenever I emit an event, I am submitting a request.
+ * Whoever listens to the event will handle my request.
+ * If the request type expects some kind of response, they will
+ * return a promise that resolves (or rejects) after my request is fulfilled.
+ *
+ * This is an abstraction built on top of the MessageTransport interface.
+ */
+const createRequestChannel = (messageTransport) => {
+    /** Used to generated unique ids */
+    let uniqueIdCounter = 0;
+    /** Id prefix unique to this channel */
+    const idPrefix = Math.random().toString();
+    /** Always returns a different string */
+    const getUniqueId = () => `${idPrefix}-${uniqueIdCounter++}`;
+    return {
+        emit: (requestName, ...params) => {
+            // Generate the unique id for this message exchange session
+            // Although we won't listen for a response, it must still be unique
+            // to avoid tangling with other requests.
+            const messageSessionId = getUniqueId();
+            messageTransport.emit({
+                args: params,
+                messageSessionId,
+                type: requestName,
+            });
+        },
+        handle: (requestType, handler) => {
+            const messageHandler = (_a) => __awaiter(void 0, [_a], void 0, function* ({ args, messageSessionId, type: incomingType, }) {
+                if (requestType !== incomingType)
+                    return;
+                const result = handler(...args);
+                // If the handler doesn't return a promise,
+                // that means we don't need to respond.
+                if (!(result instanceof Promise))
+                    return;
+                try {
+                    const response = yield result;
+                    messageTransport.emit({
+                        args: [response],
+                        messageSessionId,
+                        type: getResolveMessageType(requestType),
+                    });
+                }
+                catch (error) {
+                    messageTransport.emit({
+                        args: [serializeErrorForTransport(error)],
+                        messageSessionId,
+                        type: getRejectMessageType(requestType),
+                    });
+                }
+            });
+            messageTransport.on(messageHandler);
+            return () => {
+                messageTransport.off(messageHandler);
+            };
+        },
+        request: (requestName, ...params) => new Promise((resolve, reject) => {
+            const requestType = requestName;
+            // Generate the unique id for this message exchange session
+            const messageSessionId = getUniqueId();
+            const resolveMessageType = getResolveMessageType(requestType);
+            const rejectMessageType = getRejectMessageType(requestType);
+            // Before actually emitting the event, we start listening to the
+            // response events
+            const handleMessage = ({ args: [result], messageSessionId: incomingSessionId, type: incomingType, }) => {
+                if (incomingSessionId !== messageSessionId)
+                    return;
+                if (incomingType === resolveMessageType) {
+                    resolve(result);
+                    cleanup();
+                }
+                if (incomingType === rejectMessageType) {
+                    if (isSerializedError(result)) {
+                        reject(parseErrorFromTransport(result));
+                    }
+                    else {
+                        reject(result);
+                    }
+                    cleanup();
+                }
+            };
+            const cleanup = () => messageTransport.off(handleMessage);
+            messageTransport.on(handleMessage);
+            // Now we emit the event to set off the request
+            messageTransport.emit({
+                args: params,
+                messageSessionId,
+                type: requestType,
+            });
+        }),
+    };
+};
+
+export { createRequestChannel, getRejectMessageType, getResolveMessageType };

package/src/store/createEventEmitterForMessages/createEventEmitterForMessages.cjs

@@ -0,0 +1,24 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var EventEmitter = require('eventemitter3');
+var requestChannel = require('../../requestChannel/requestChannel.cjs');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var EventEmitter__default = /*#__PURE__*/_interopDefaultLegacy(EventEmitter);
+
+// There are way too many "any"s in this file. They are necessary because otherwise the generics won't work
+function createEventEmitterForMessages({ messageTransport, initialEventEmitter, key, }) {
+    const events = initialEventEmitter !== null && initialEventEmitter !== void 0 ? initialEventEmitter : new EventEmitter__default["default"]();
+    const requestChannel$1 = requestChannel.createRequestChannel(messageTransport);
+    requestChannel$1.handle('eventEmitted', (eventKey, eventName, payload) => {
+        if (eventKey === key)
+            events.emit(eventName, ...payload);
+    });
+    return events;
+}
+
+exports.createEventEmitterForMessages = createEventEmitterForMessages;

package/src/store/createEventEmitterForMessages/createEventEmitterForMessages.d.ts

@@ -0,0 +1,22 @@
+import EventEmitter from 'eventemitter3';
+import { MessageTransportWithDefaultOrigin } from '../../messageTransport';
+export type MessagesForEventEmitter<T extends Record<string, (...args: any[]) => any>, U extends string> = {
+    eventEmitted: <E extends keyof T>(key: U, eventName: E, payload: Parameters<T[E]>) => void;
+};
+/**
+ * Use this function when you want to get an event emitter that will raise events for
+ * messages of type MessagesForEventEmitter
+ */
+export declare function createEventEmitterForMessages<T extends Record<string, (...args: any[]) => any> = never, U extends string = never>(params: {
+    messageTransport: MessageTransportWithDefaultOrigin;
+    key: U;
+}): EventEmitter<T>;
+/**
+ * Use this function when you want to get an event emitter that will raise events for
+ * messages of type MessagesForEventEmitter
+ */
+export declare function createEventEmitterForMessages<T extends Record<string, (...args: any[]) => any> = never, U extends string = never, E extends EventEmitter<any> = never>(params: {
+    messageTransport: MessageTransportWithDefaultOrigin;
+    initialEventEmitter: E;
+    key: U;
+}): E extends EventEmitter<infer V> ? EventEmitter<T & V> : never;

package/src/store/createEventEmitterForMessages/createEventEmitterForMessages.js

@@ -0,0 +1,16 @@
+'use client'
+import EventEmitter from 'eventemitter3';
+import { createRequestChannel } from '../../requestChannel/requestChannel.js';
+
+// There are way too many "any"s in this file. They are necessary because otherwise the generics won't work
+function createEventEmitterForMessages({ messageTransport, initialEventEmitter, key, }) {
+    const events = initialEventEmitter !== null && initialEventEmitter !== void 0 ? initialEventEmitter : new EventEmitter();
+    const requestChannel = createRequestChannel(messageTransport);
+    requestChannel.handle('eventEmitted', (eventKey, eventName, payload) => {
+        if (eventKey === key)
+            events.emit(eventName, ...payload);
+    });
+    return events;
+}
+
+export { createEventEmitterForMessages };

package/src/store/createEventEmitterForMessages/index.d.ts

@@ -0,0 +1 @@
+export * from './createEventEmitterForMessages';

package/src/store/index.d.ts

@@ -0,0 +1,3 @@
+export * from './createEventEmitterForMessages';
+export * from './store';
+export * from './storeSetter';