@dynamic-labs/message-transport 4.0.0-alpha.0 → 4.0.0-alpha.2

package/CHANGELOG.md

@@ -1,4 +1,29 @@
 
+## [4.0.0-alpha.2](https://github.com/dynamic-labs/DynamicAuth/compare/v4.0.0-alpha.1...v4.0.0-alpha.2) (2024-09-18)
+
+
+### Features
+
+* add iconVariant prop to DynamicBridgeWidget ([#6915](https://github.com/dynamic-labs/DynamicAuth/issues/6915)) ([8aa0f3d](https://github.com/dynamic-labs/DynamicAuth/commit/8aa0f3d8d8c41c7b5c4796106f611f208010cb6d))
+* allow to create extra embedded wallets in react-native ([#6923](https://github.com/dynamic-labs/DynamicAuth/issues/6923)) ([ba22f7b](https://github.com/dynamic-labs/DynamicAuth/commit/ba22f7bcf41a444a4df0aff9b6aec257457e9402))
+* **client:** add hide method for auth and userProfile ui modules ([#6928](https://github.com/dynamic-labs/DynamicAuth/issues/6928)) ([a11a4a5](https://github.com/dynamic-labs/DynamicAuth/commit/a11a4a5d6e25ce2a916ebd52f0b341020dc1a7e5))
+
+## [4.0.0-alpha.1](https://github.com/dynamic-labs/DynamicAuth/compare/v4.0.0-alpha.0...v4.0.0-alpha.1) (2024-09-17)
+
+
+### Features
+
+* blockaid website scanning for global connectivity ([#6874](https://github.com/dynamic-labs/DynamicAuth/issues/6874)) ([f8cbabd](https://github.com/dynamic-labs/DynamicAuth/commit/f8cbabd92fd4b5b096f47ff8e24c572ad7720dd8))
+
+
+### Bug Fixes
+
+* deeplinking on ethereum and bitcoin sats connector ([#6917](https://github.com/dynamic-labs/DynamicAuth/issues/6917)) ([3896c3a](https://github.com/dynamic-labs/DynamicAuth/commit/3896c3a97819459da74dc5b4771796d7991c1f07))
+* emit walletAdded event when createEmbeddedWalletAccount called ([#6922](https://github.com/dynamic-labs/DynamicAuth/issues/6922)) ([2a8bdd6](https://github.com/dynamic-labs/DynamicAuth/commit/2a8bdd68c50efd946c6f9b398dfae2b3585db34f))
+* interface for sendBitcoin on unisat ([37a1bc2](https://github.com/dynamic-labs/DynamicAuth/commit/37a1bc216f43eef817c40e23b9161327f9d29c59))
+* remove ballet crypto and duplicate keplr entry ([#6906](https://github.com/dynamic-labs/DynamicAuth/issues/6906)) ([14aeeea](https://github.com/dynamic-labs/DynamicAuth/commit/14aeeeaa8d906344f4aeddf9e73527df346b9ea0))
+* solana and cosmos signers not working properly ([#6898](https://github.com/dynamic-labs/DynamicAuth/issues/6898)) ([6f07981](https://github.com/dynamic-labs/DynamicAuth/commit/6f079811c0d7e45b97d2dae72f4141268ab4fe0c))
+
 ## [4.0.0-alpha.0](https://github.com/dynamic-labs/DynamicAuth/compare/v3.0.0...v4.0.0-alpha.0) (2024-09-13)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamic-labs/message-transport",
-  "version": "4.0.0-alpha.0",
+  "version": "4.0.0-alpha.2",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/dynamic-labs/dynamic-auth.git",
@@ -26,8 +26,13 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
+    "@dynamic-labs/sdk-api-core": "0.0.530",
     "@vue/reactivity": "3.4.21",
-    "@dynamic-labs/types": "4.0.0-alpha.0",
+    "@dynamic-labs/types": "4.0.0-alpha.2",
     "eventemitter3": "5.0.1"
+  },
+  "peerDependencies": {
+    "@dynamic-labs/logger": "4.0.0-alpha.2",
+    "@dynamic-labs/utils": "4.0.0-alpha.2"
   }
 }

package/src/index.d.ts

@@ -5,4 +5,4 @@ export { parseMessageTransportData } from './utils/parseMessageTransportData';
 export { serializeErrorForTransport } from './utils/serializeErrorForTransport';
 export { createEventEmitterForMessages, createStore, createStoreSetter, type CreateStoreProps, type MessagesForEventEmitter, } from './store';
 export type { Store, StoreEventListeners, StoreKeys, StoreSetter, StoreStateChangeEvent, StoreStateEvents, StoreStateGetters, } from './store/types';
-export { sdkHasLoadedEventName, type AuthModuleMessages, type AuthModuleState, type ClientManifest, type ConsoleMessages, type EmailOtpParams, type EmbeddedWalletsModuleMessages, type EmbeddedWalletsModuleState, type EthMessages, type EthRequestWithAddressParams, type EthRequestWithChainIdParams, type ExternalAuthMessages, type FetchMessages, type NetworksModuleState, type OtpMessages, type PasskeyMessages, type PlatformServiceMessages, type SdkModuleMessages, type SdkModuleState, type SignInWithExternalJwtParams, type SmsOtpParams, type SocialAuthModuleMessages, type SocialProvider, type SolanaMessages, type UserInterfaceModuleMessages, type VerifyWithExternalJwtParams, type WalletsModuleMessages, type WalletsModuleState, type WebViewVisibilityMessages, } from './messageTypes';
+export { sdkHasLoadedEventName, type AuthModuleMessages, type AuthModuleState, type ClientManifest, type ConsoleMessages, type CreateEmbeddedWalletArgs, type EmailOtpParams, type EmbeddedWalletsModuleMessages, type EmbeddedWalletsModuleState, type EthMessages, type EthRequestWithAddressParams, type EthRequestWithChainIdParams, type ExternalAuthMessages, type FetchMessages, type NetworksModuleState, type OtpMessages, type PasskeyMessages, type PlatformServiceMessages, type SdkModuleMessages, type SdkModuleState, type SignInWithExternalJwtParams, type SmsOtpParams, type SecureStorageMessages, type SocialAuthModuleMessages, type SocialProvider, type SolanaMessages, type UserInterfaceModuleMessages, type VerifyWithExternalJwtParams, type WalletsModuleMessages, type WalletsModuleState, type WebViewVisibilityMessages, } from './messageTypes';

package/src/messageTypes/EmbeddedWalletsModuleMessages.d.ts

@@ -1,8 +1,12 @@
+import { EmbeddedWalletChainEnum } from '@dynamic-labs/sdk-api-core';
 import { BaseWallet } from '@dynamic-labs/types';
+export type CreateEmbeddedWalletArgs = {
+    chain?: keyof typeof EmbeddedWalletChainEnum;
+};
 export type EmbeddedWalletsModuleState = {
     hasWallet: boolean;
 };
 export type EmbeddedWalletsModuleMessages = {
     getWallet: () => Promise<BaseWallet | null>;
-    createWallet: () => Promise<BaseWallet>;
+    createWallet: (args?: CreateEmbeddedWalletArgs) => Promise<BaseWallet>;
 };

package/src/messageTypes/SecureStorageMessages.d.ts

@@ -0,0 +1,5 @@
+export type SecureStorageMessages = {
+    getSecureItem: (key: string) => Promise<string | null>;
+    setSecureItem: (key: string, data: string) => Promise<void>;
+    deleteSecureItem: (key: string) => Promise<void>;
+};

package/src/messageTypes/UserInterfaceModuleMessages.d.ts

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

package/src/messageTypes/index.d.ts

@@ -9,6 +9,7 @@ export * from './OtpMessages';
 export * from './PasskeyMessages';
 export * from './PlatformServiceMessages';
 export * from './SdkModuleMessages';
+export * from './SecureStorageMessages';
 export * from './SocialAuthModuleMessages';
 export * from './SolanaMessages';
 export * from './UserInterfaceModuleMessages';

package/src/requestChannel/requestChannel.cjs

@@ -4,14 +4,32 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var _tslib = require('../../_virtual/_tslib.cjs');
+var utils = require('@dynamic-labs/utils');
+var isSerializedError = require('../utils/isSerializedError/isSerializedError.cjs');
+var logger = require('../utils/logger.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`;
+/** Given a request event name, returns the event name for its acknowledgement */
+const getAckMessageType = (type) => `${type}__ack`;
+/** Returns a "no handlers registered" error for a message type */
+const createNoHandlerError = (type, cleanup) => {
+    const message = `No handlers were registered for message of type ${type}`;
+    logger.logger.error(message);
+    cleanup();
+    return new utils.RequestChannelNotHandledError(message);
+};
+/**
+ * When a request is sent, a timer will be started. If it times out before
+ * a corresponding ack message is received, we reject the request with NO_HANDLERS_REGISTERED.
+ *
+ * This controls how many ms we should wait before we time out.
+ */
+const TIMEOUT_DURATION = 3000;
 /**
  * Allows handling and submitting requests to and from a webview.
  * Requests are messages that (can) expect some response.
@@ -37,22 +55,50 @@ const createRequestChannel = (messageTransport) => {
     const idPrefix = Math.random().toString();
     /** Always returns a different string */
     const getUniqueId = () => `${idPrefix}-${uniqueIdCounter++}`;
+    /** Maps a request's session ID to its time out timer */
+    const timeoutMap = {};
     return {
-        emit: (requestName, ...params) => {
+        emit: (requestType, ...params) => new Promise((resolve, reject) => {
             // 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();
+            const ackMessageType = getAckMessageType(requestType);
+            // Before actually emitting the event, we start listening to the
+            // response events
+            const handleMessage = ({ messageSessionId: incomingSessionId, type: incomingType, }) => {
+                if (incomingSessionId !== messageSessionId ||
+                    incomingType !== ackMessageType)
+                    return;
+                clearTimeout(timeoutMap[messageSessionId]);
+                delete timeoutMap[messageSessionId];
+                resolve();
+                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: requestName,
+                type: requestType,
             });
-        },
+            // And start the time out timer
+            const timeoutTimer = setTimeout(() => {
+                reject(createNoHandlerError(requestType, cleanup));
+            }, TIMEOUT_DURATION);
+            timeoutMap[messageSessionId] = timeoutTimer;
+        }),
         handle: (requestType, handler) => {
             const messageHandler = (_a) => _tslib.__awaiter(void 0, [_a], void 0, function* ({ args, messageSessionId, type: incomingType, }) {
                 if (requestType !== incomingType)
                     return;
+                // Emit an Ack since the message will time out unless some handler acks it in time
+                messageTransport.emit({
+                    args: [],
+                    messageSessionId,
+                    type: getAckMessageType(requestType),
+                });
                 const result = handler(...args);
                 // If the handler doesn't return a promise,
                 // that means we don't need to respond.
@@ -79,20 +125,26 @@ const createRequestChannel = (messageTransport) => {
                 messageTransport.off(messageHandler);
             };
         },
-        request: (requestName, ...params) => new Promise((resolve, reject) => {
-            const requestType = requestName;
+        request: (requestType, ...params) => new Promise((resolve, reject) => {
             // Generate the unique id for this message exchange session
             const messageSessionId = getUniqueId();
             const resolveMessageType = getResolveMessageType(requestType);
             const rejectMessageType = getRejectMessageType(requestType);
+            const ackMessageType = getAckMessageType(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 === ackMessageType) {
+                    clearTimeout(timeoutMap[messageSessionId]);
+                    delete timeoutMap[messageSessionId];
+                    return;
+                }
                 if (incomingType === resolveMessageType) {
                     resolve(result);
                     cleanup();
+                    return;
                 }
                 if (incomingType === rejectMessageType) {
                     if (isSerializedError.isSerializedError(result)) {
@@ -106,6 +158,9 @@ const createRequestChannel = (messageTransport) => {
             };
             const cleanup = () => messageTransport.off(handleMessage);
             messageTransport.on(handleMessage);
+            // And start the time out timer
+            const timeoutTimer = setTimeout(() => reject(createNoHandlerError(requestType, cleanup)), TIMEOUT_DURATION);
+            timeoutMap[messageSessionId] = timeoutTimer;
             // Now we emit the event to set off the request
             messageTransport.emit({
                 args: params,
@@ -116,6 +171,8 @@ const createRequestChannel = (messageTransport) => {
     };
 };
 
+exports.TIMEOUT_DURATION = TIMEOUT_DURATION;
 exports.createRequestChannel = createRequestChannel;
+exports.getAckMessageType = getAckMessageType;
 exports.getRejectMessageType = getRejectMessageType;
 exports.getResolveMessageType = getResolveMessageType;

package/src/requestChannel/requestChannel.d.ts

@@ -7,25 +7,49 @@ export type RequestTypes = Record<string, (...params: any[]) => Promise<any> | v
  * Only the request types from T that return promises
  * i.e. those that expect a response
  */
-type TypesExpectingResponse<T extends RequestTypes> = {
+type TypesExpectingResponse<T extends RequestTypes> = Extract<{
     [K in keyof T]: ReturnType<T[K]> extends Promise<any> ? K : never;
-}[keyof T];
+}[keyof T], string>;
 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;
+    handle: <K extends Extract<keyof T, string>>(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.
+     * Doesn't expect a response. Resolves as soon as the message is acknowledged by
+     * any handler.
+     *
+     * If no handlers emit an ack for this message, this will reject.
+     *
+     * Lifetime of an "emit" message:
+     * 1. "Emit" message is sent.
+     * 2. A handler receives the message.
+     * 3. The handler immediately emits an ack message for it, acknowledging it.
+     * 4. This method's promise resolves.
      */
-    emit: <K extends keyof T>(requestName: K, ...params: Parameters<T[K]>) => void;
+    emit: <K extends Extract<keyof T, string>>(requestName: K, ...params: Parameters<T[K]>) => Promise<void>;
     /**
      * Triggers handlers for this request type, with the given params.
-     * @returns a promise that resolves/rejects when a handler fulfills this request.
+     * As opposed to emit, this expects a response message. A handler must still
+     * acknowledge this message, but the promise will only resolve when the handler
+     * emits back a response message. The promise resolves with whatever data was sent
+     * in the response.
+     *
+     * If no handlers emit an ack for this message, or if a handler responds
+     * with a failure, this will reject.
+     *
+     * Lifetime of a "request" message:
+     * 1. "Request" message is sent.
+     * 2. A handler receives the message.
+     * 3. The handler immediately emits an ack message for it, acknowledging it.
+     * 4. The handler performs the requested action.
+     * 5. The handler emits a response message.
+     * 6. This method's promise resolves with the response's data.
      */
     request: <K extends TypesExpectingResponse<T>>(requestName: K, ...params: Parameters<T[K]>) => ReturnType<T[K]>;
 };
@@ -33,6 +57,15 @@ export type RequestChannel<T extends RequestTypes> = {
 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;
+/** Given a request event name, returns the event name for its acknowledgement */
+export declare const getAckMessageType: (type: string) => string;
+/**
+ * When a request is sent, a timer will be started. If it times out before
+ * a corresponding ack message is received, we reject the request with NO_HANDLERS_REGISTERED.
+ *
+ * This controls how many ms we should wait before we time out.
+ */
+export declare const TIMEOUT_DURATION = 3000;
 /**
  * Allows handling and submitting requests to and from a webview.
  * Requests are messages that (can) expect some response.

package/src/requestChannel/requestChannel.js

@@ -1,13 +1,31 @@
 'use client'
 import { __awaiter } from '../../_virtual/_tslib.js';
+import { RequestChannelNotHandledError } from '@dynamic-labs/utils';
+import { isSerializedError } from '../utils/isSerializedError/isSerializedError.js';
+import { logger } from '../utils/logger.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`;
+/** Given a request event name, returns the event name for its acknowledgement */
+const getAckMessageType = (type) => `${type}__ack`;
+/** Returns a "no handlers registered" error for a message type */
+const createNoHandlerError = (type, cleanup) => {
+    const message = `No handlers were registered for message of type ${type}`;
+    logger.error(message);
+    cleanup();
+    return new RequestChannelNotHandledError(message);
+};
+/**
+ * When a request is sent, a timer will be started. If it times out before
+ * a corresponding ack message is received, we reject the request with NO_HANDLERS_REGISTERED.
+ *
+ * This controls how many ms we should wait before we time out.
+ */
+const TIMEOUT_DURATION = 3000;
 /**
  * Allows handling and submitting requests to and from a webview.
  * Requests are messages that (can) expect some response.
@@ -33,22 +51,50 @@ const createRequestChannel = (messageTransport) => {
     const idPrefix = Math.random().toString();
     /** Always returns a different string */
     const getUniqueId = () => `${idPrefix}-${uniqueIdCounter++}`;
+    /** Maps a request's session ID to its time out timer */
+    const timeoutMap = {};
     return {
-        emit: (requestName, ...params) => {
+        emit: (requestType, ...params) => new Promise((resolve, reject) => {
             // 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();
+            const ackMessageType = getAckMessageType(requestType);
+            // Before actually emitting the event, we start listening to the
+            // response events
+            const handleMessage = ({ messageSessionId: incomingSessionId, type: incomingType, }) => {
+                if (incomingSessionId !== messageSessionId ||
+                    incomingType !== ackMessageType)
+                    return;
+                clearTimeout(timeoutMap[messageSessionId]);
+                delete timeoutMap[messageSessionId];
+                resolve();
+                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: requestName,
+                type: requestType,
             });
-        },
+            // And start the time out timer
+            const timeoutTimer = setTimeout(() => {
+                reject(createNoHandlerError(requestType, cleanup));
+            }, TIMEOUT_DURATION);
+            timeoutMap[messageSessionId] = timeoutTimer;
+        }),
         handle: (requestType, handler) => {
             const messageHandler = (_a) => __awaiter(void 0, [_a], void 0, function* ({ args, messageSessionId, type: incomingType, }) {
                 if (requestType !== incomingType)
                     return;
+                // Emit an Ack since the message will time out unless some handler acks it in time
+                messageTransport.emit({
+                    args: [],
+                    messageSessionId,
+                    type: getAckMessageType(requestType),
+                });
                 const result = handler(...args);
                 // If the handler doesn't return a promise,
                 // that means we don't need to respond.
@@ -75,20 +121,26 @@ const createRequestChannel = (messageTransport) => {
                 messageTransport.off(messageHandler);
             };
         },
-        request: (requestName, ...params) => new Promise((resolve, reject) => {
-            const requestType = requestName;
+        request: (requestType, ...params) => new Promise((resolve, reject) => {
             // Generate the unique id for this message exchange session
             const messageSessionId = getUniqueId();
             const resolveMessageType = getResolveMessageType(requestType);
             const rejectMessageType = getRejectMessageType(requestType);
+            const ackMessageType = getAckMessageType(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 === ackMessageType) {
+                    clearTimeout(timeoutMap[messageSessionId]);
+                    delete timeoutMap[messageSessionId];
+                    return;
+                }
                 if (incomingType === resolveMessageType) {
                     resolve(result);
                     cleanup();
+                    return;
                 }
                 if (incomingType === rejectMessageType) {
                     if (isSerializedError(result)) {
@@ -102,6 +154,9 @@ const createRequestChannel = (messageTransport) => {
             };
             const cleanup = () => messageTransport.off(handleMessage);
             messageTransport.on(handleMessage);
+            // And start the time out timer
+            const timeoutTimer = setTimeout(() => reject(createNoHandlerError(requestType, cleanup)), TIMEOUT_DURATION);
+            timeoutMap[messageSessionId] = timeoutTimer;
             // Now we emit the event to set off the request
             messageTransport.emit({
                 args: params,
@@ -112,4 +167,4 @@ const createRequestChannel = (messageTransport) => {
     };
 };
 
-export { createRequestChannel, getRejectMessageType, getResolveMessageType };
+export { TIMEOUT_DURATION, createRequestChannel, getAckMessageType, getRejectMessageType, getResolveMessageType };

package/src/utils/logger.cjs

@@ -0,0 +1,10 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var logger$1 = require('@dynamic-labs/logger');
+
+const logger = new logger$1.Logger('message-transport');
+
+exports.logger = logger;

package/src/utils/logger.d.ts

@@ -0,0 +1,2 @@
+import { Logger } from '@dynamic-labs/logger';
+export declare const logger: Logger;

package/src/utils/logger.js

@@ -0,0 +1,6 @@
+'use client'
+import { Logger } from '@dynamic-labs/logger';
+
+const logger = new Logger('message-transport');
+
+export { logger };