@dynamic-labs/message-transport 4.0.0-alpha.3 → 4.0.0-alpha.31

package/src/messageTypes/AuthModuleMessages.d.ts

@@ -1,8 +1,19 @@
-import type { UserProfile } from '@dynamic-labs/types';
+import type { AuthEventPayload, UserProfile } from '@dynamic-labs/types';
 export type AuthModuleState = {
     token: string | null;
     authenticatedUser: UserProfile | null;
 };
 export type AuthModuleMessages = {
     logout: () => Promise<void>;
+    handleAuthenticatedUser: (params: {
+        user: UserProfile;
+    }) => Promise<void>;
+    authSuccess: (user: UserProfile) => void;
+    authFailed: (data: AuthEventPayload, reason: 'user-cancelled' | {
+        error: unknown;
+    }) => void;
+    authInit: (data: AuthEventPayload) => void;
+    loggedOut: (user: UserProfile | null) => void;
+    userProfileUpdated: (user: UserProfile) => void;
 };
+export declare const authEventNames: ("authSuccess" | "authFailed" | "authInit" | "loggedOut" | "userProfileUpdated")[];

package/src/messageTypes/AuthModuleMessages.js

@@ -0,0 +1,10 @@
+'use client'
+const authEventNames = [
+    'authSuccess',
+    'authFailed',
+    'authInit',
+    'loggedOut',
+    'userProfileUpdated',
+];
+
+export { authEventNames };

package/src/messageTypes/EmbeddedWalletsModuleMessages.cjs

@@ -0,0 +1,10 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const embeddedWalletsEventNames = [
+    'embeddedWalletCreated',
+];
+
+exports.embeddedWalletsEventNames = embeddedWalletsEventNames;

package/src/messageTypes/EmbeddedWalletsModuleMessages.d.ts

@@ -1,4 +1,4 @@
-import { EmbeddedWalletChainEnum } from '@dynamic-labs/sdk-api-core';
+import { EmbeddedWalletChainEnum, JwtVerifiedCredential } from '@dynamic-labs/sdk-api-core';
 import { BaseWallet } from '@dynamic-labs/types';
 export type CreateEmbeddedWalletArgs = {
     chain?: keyof typeof EmbeddedWalletChainEnum;
@@ -9,4 +9,8 @@ export type EmbeddedWalletsModuleState = {
 export type EmbeddedWalletsModuleMessages = {
     getWallet: () => Promise<BaseWallet | null>;
     createWallet: (args?: CreateEmbeddedWalletArgs) => Promise<BaseWallet>;
+    embeddedWalletCreated: (verifiedCredential: JwtVerifiedCredential | null) => void;
 };
+type EmbeddedWalletsEventNames = 'embeddedWalletCreated';
+export declare const embeddedWalletsEventNames: EmbeddedWalletsEventNames[];
+export {};

package/src/messageTypes/EmbeddedWalletsModuleMessages.js

@@ -0,0 +1,6 @@
+'use client'
+const embeddedWalletsEventNames = [
+    'embeddedWalletCreated',
+];
+
+export { embeddedWalletsEventNames };

package/src/messageTypes/ExternalAuthMessages.d.ts

@@ -1,3 +1,4 @@
+import { UserProfile } from '@dynamic-labs/types';
 export type SignInWithExternalJwtParams = {
     externalUserId: string;
     externalJwt: string;
@@ -10,9 +11,9 @@ export type ExternalAuthMessages = {
     /**
      * Initiates sign in with an externally provided JWT
      */
-    signInWithExternalJwt: (props: SignInWithExternalJwtParams) => Promise<void>;
+    signInWithExternalJwt: (props: SignInWithExternalJwtParams) => Promise<UserProfile | null>;
     /**
      * Initiates verification with an externally provided JWT
      */
-    verifyWithExternalJwt: (props: VerifyWithExternalJwtParams) => Promise<void>;
+    verifyWithExternalJwt: (props: VerifyWithExternalJwtParams) => Promise<UserProfile | null>;
 };

package/src/messageTypes/OtpMessages.cjs

@@ -0,0 +1,14 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const emailEventNames = [
+    'emailVerificationFinished',
+];
+const smsEventNames = [
+    'smsVerificationFinished',
+];
+
+exports.emailEventNames = emailEventNames;
+exports.smsEventNames = smsEventNames;

package/src/messageTypes/OtpMessages.d.ts

@@ -15,4 +15,14 @@ export type OtpMessages = {
     verifyOTP: (token: string) => Promise<void>;
     /** Re-sends the OTP for verification */
     resendOTP: () => Promise<void>;
+    emailVerificationFinished: (params: {
+        isSuccess: boolean;
+        destination: string;
+    }) => void;
+    smsVerificationFinished: (params: {
+        isSuccess: boolean;
+        destination: PhoneData;
+    }) => void;
 };
+export declare const emailEventNames: "emailVerificationFinished"[];
+export declare const smsEventNames: "smsVerificationFinished"[];

package/src/messageTypes/OtpMessages.js

@@ -0,0 +1,9 @@
+'use client'
+const emailEventNames = [
+    'emailVerificationFinished',
+];
+const smsEventNames = [
+    'smsVerificationFinished',
+];
+
+export { emailEventNames, smsEventNames };

package/src/messageTypes/PasskeyMessages.d.ts

@@ -1,3 +1,4 @@
+import { CreateWebauthnCredentialOptions, convertAttestationResultToTurnkey } from '@dynamic-labs/webauthn';
 type CustomPublicKeyCredentialUserEntity = Omit<PublicKeyCredentialUserEntity, 'id'> & {
     id: string;
 };
@@ -24,6 +25,11 @@ export type PasskeyMessages = {
             transports: ('AUTHENTICATOR_TRANSPORT_BLE' | 'AUTHENTICATOR_TRANSPORT_INTERNAL' | 'AUTHENTICATOR_TRANSPORT_NFC' | 'AUTHENTICATOR_TRANSPORT_USB' | 'AUTHENTICATOR_TRANSPORT_HYBRID')[];
         };
     }>;
+    createPasskeyOnBrowser: (params: {
+        publicKey: CreateWebauthnCredentialOptions;
+    }) => Promise<{
+        attestation: ReturnType<typeof convertAttestationResultToTurnkey>;
+    }>;
     passkeyStamp: (rdId: string, payload: string) => Promise<{
         stampHeaderName: string;
         stampHeaderValue: string;

package/src/messageTypes/ProjectSettingsMessages.d.ts

@@ -0,0 +1,6 @@
+import { ProjectSettings } from '@dynamic-labs/sdk-api-core';
+export type ProjectSettingsMessages = {
+    getProjectSettings: () => Promise<{
+        projectSettings: ProjectSettings;
+    }>;
+};

package/src/messageTypes/SocialAuthModuleMessages.d.ts

@@ -1,4 +1,11 @@
-export type SocialProvider = 'apple' | 'coinbaseSocial' | 'discord' | 'facebook' | 'farcaster' | 'github' | 'google' | 'telegram' | 'twitch' | 'twitter';
+import { ProviderEnum } from '@dynamic-labs/sdk-api-core';
+export type SocialProvider = 'apple' | 'coinbaseSocial' | 'discord' | 'epicgames' | 'facebook' | 'farcaster' | 'github' | 'google' | 'line' | 'telegram' | 'twitch' | 'twitter' | 'spotify';
+type ConnectWithSocialOnHostArgs = {
+    clientId?: string;
+    oauthLoginUrl: string;
+    provider: ProviderEnum;
+    state: string;
+};
 export type SocialAuthModuleMessages = {
     connectWithSocial: (args: {
         /**
@@ -14,4 +21,9 @@ export type SocialAuthModuleMessages = {
          */
         redirectPathname?: string;
     }) => Promise<void>;
+    /**
+     * Trigger a social auth connection on the host/native side
+     */
+    connectWithSocialOnHost: (args: ConnectWithSocialOnHostArgs) => Promise<void>;
 };
+export {};

package/src/messageTypes/StorageMessages.d.ts

@@ -0,0 +1,19 @@
+export type StorageMessageSource = 'localStorage' | 'sessionStorage' | 'secureStorage';
+export type GetStorageItemArgs = {
+    source: StorageMessageSource;
+    key: string;
+};
+export type SetStorageItemArgs = {
+    source: StorageMessageSource;
+    key: string;
+    data: string;
+};
+export type DeleteStorageItemArgs = {
+    source: StorageMessageSource;
+    key: string;
+};
+export type StorageMessages = {
+    getItem: (args: GetStorageItemArgs) => Promise<string | null>;
+    setItem: (args: SetStorageItemArgs) => Promise<void>;
+    deleteItem: (args: DeleteStorageItemArgs) => Promise<void>;
+};

package/src/messageTypes/TurnkeyIframeEventProxyMessages.d.ts

@@ -0,0 +1,9 @@
+export type TurnkeyIframeEventProxyMessages = {
+    initializeTurnkeyIframeEventProxy: (args: {
+        origins: string[];
+    }) => Promise<void>;
+    proxyEmitterTurnkeyIframeEvent: (args: {
+        origin: string;
+        data: any;
+    }) => Promise<void>;
+};

package/src/messageTypes/UserInterfaceModuleMessages.cjs

@@ -0,0 +1,12 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const userInterfaceEventNames = [
+    'authFlowCancelled',
+    'authFlowClosed',
+    'authFlowOpened',
+];
+
+exports.userInterfaceEventNames = userInterfaceEventNames;

package/src/messageTypes/UserInterfaceModuleMessages.d.ts

@@ -7,4 +7,8 @@ export type UserInterfaceModuleMessages = {
     revealEmbeddedWalletKey: (params: {
         type: 'recovery-phrase' | 'private-key';
     }) => void;
+    authFlowCancelled: () => void;
+    authFlowClosed: () => void;
+    authFlowOpened: () => void;
 };
+export declare const userInterfaceEventNames: ("authFlowCancelled" | "authFlowClosed" | "authFlowOpened")[];

package/src/messageTypes/UserInterfaceModuleMessages.js

@@ -0,0 +1,8 @@
+'use client'
+const userInterfaceEventNames = [
+    'authFlowCancelled',
+    'authFlowClosed',
+    'authFlowOpened',
+];
+
+export { userInterfaceEventNames };

package/src/messageTypes/WalletsModuleMessages.cjs

@@ -0,0 +1,12 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const userWalletsEventNames = [
+    'messageSigned',
+    'walletAdded',
+    'walletRemoved',
+];
+
+exports.userWalletsEventNames = userWalletsEventNames;

package/src/messageTypes/WalletsModuleMessages.d.ts

@@ -27,4 +27,33 @@ export type WalletsModuleMessages = {
     setPrimary: (params: {
         walletId: string;
     }) => Promise<void>;
+    onWalletEvent: (params: WalletEventArguments & {
+        walletId: string;
+    }) => void;
+    handleConnectedWallet: (wallet: Partial<BaseWallet>) => Promise<boolean>;
+    messageSigned: (params: {
+        messageToSign: string;
+        signedMessage: string;
+    }) => void;
+    walletAdded: (params: {
+        wallet: BaseWallet;
+        userWallets: BaseWallet[];
+    }) => void;
+    walletRemoved: (params: {
+        wallet: BaseWallet;
+        userWallets: BaseWallet[];
+    }) => void;
+};
+export type WalletEvents = {
+    chainChange: (props: {
+        chain: string;
+    }) => void;
 };
+type WalletEventArguments = {
+    [E in keyof WalletEvents]: {
+        event: E;
+        eventParams: Parameters<WalletEvents[E]>;
+    };
+}[keyof WalletEvents];
+export declare const userWalletsEventNames: ("messageSigned" | "walletAdded" | "walletRemoved")[];
+export {};

package/src/messageTypes/WalletsModuleMessages.js

@@ -0,0 +1,8 @@
+'use client'
+const userWalletsEventNames = [
+    'messageSigned',
+    'walletAdded',
+    'walletRemoved',
+];
+
+export { userWalletsEventNames };

package/src/messageTypes/ZeroDevExtensionMessages.d.ts

@@ -0,0 +1,10 @@
+export type KernelAccountSettings = {
+    entryPointAddress: string;
+    chainId: number;
+    ecdsaProviderType: string | null;
+    kernelVersion: string;
+    projectId: string;
+};
+export type ZeroDevExtensionMessages = {
+    getKernelAccountSettings: () => Promise<KernelAccountSettings>;
+};

package/src/messageTypes/index.d.ts

@@ -1,3 +1,4 @@
+export * from './AccountAbstractionMessages';
 export * from './AuthModuleMessages';
 export * from './ConsoleMessages';
 export * from './EmbeddedWalletsModuleMessages';
@@ -8,10 +9,13 @@ export * from './NetworksModuleMessages';
 export * from './OtpMessages';
 export * from './PasskeyMessages';
 export * from './PlatformServiceMessages';
+export * from './ProjectSettingsMessages';
 export * from './SdkModuleMessages';
-export * from './SecureStorageMessages';
 export * from './SocialAuthModuleMessages';
 export * from './SolanaMessages';
+export * from './StorageMessages';
+export * from './TurnkeyIframeEventProxyMessages';
 export * from './UserInterfaceModuleMessages';
 export * from './WalletsModuleMessages';
 export * from './WebViewVisibilityMessages';
+export * from './ZeroDevExtensionMessages';

package/src/requestChannel/createRequestChannelMessageSender/createRequestChannelMessageSender.cjs

@@ -0,0 +1,45 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils = require('../utils/utils.cjs');
+
+const createRequestChannelMessageSender = ({ requestType, messageSessionId, timeoutMap, onReceiveAck, messageTransport, onTimeout, params, }) => {
+    const ackMessageType = utils.getAckMessageType(requestType);
+    const message = {
+        args: params,
+        messageSessionId,
+        type: requestType,
+    };
+    // We must listen for acks
+    const handleAckMessage = ({ messageSessionId: incomingSessionId, type: incomingType, }) => {
+        if (incomingSessionId !== messageSessionId ||
+            incomingType !== ackMessageType)
+            return;
+        clearTimeout(timeoutMap[messageSessionId]);
+        delete timeoutMap[messageSessionId];
+        onReceiveAck === null || onReceiveAck === void 0 ? void 0 : onReceiveAck();
+    };
+    const sendMessage = () => {
+        const startTimer = () => {
+            const timeoutTimer = setTimeout(onTimeout, utils.TIMEOUT_DURATION);
+            timeoutMap[messageSessionId] = timeoutTimer;
+        };
+        // If this message transport is currently blocked, we must only start
+        // the timeout once the message is actually emitted
+        // We don't just default to this because the onEmit option is only
+        // present in the message transport if has the block decorator
+        if ('isBlocked' in messageTransport && messageTransport.isBlocked()) {
+            messageTransport.emit(message, { onEmit: startTimer });
+            return;
+        }
+        // Now we emit the event to set off the request
+        messageTransport.emit(message);
+        // We start the timer immediately since the message was not blocked
+        startTimer();
+    };
+    return { handleAckMessage, sendMessage };
+};
+
+exports.createRequestChannelMessageSender = createRequestChannelMessageSender;

package/src/requestChannel/createRequestChannelMessageSender/createRequestChannelMessageSender.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import { MessageTransportData, WithBlock } from '../../messageTransport';
+import { MessageTransportWithDefaultOrigin } from '../../messageTransport/decorators/applyDefaultMessageOrigin/applyDefaultMessageOrigin';
+import { RequestTypes } from '../types';
+type RequestChannelMessageSenderParams<T extends RequestTypes, K extends Extract<keyof T, string>> = {
+    requestType: K;
+    messageSessionId: string;
+    timeoutMap: Record<string, NodeJS.Timer>;
+    onReceiveAck?: VoidFunction;
+    onTimeout: VoidFunction;
+    messageTransport: MessageTransportWithDefaultOrigin | WithBlock<MessageTransportWithDefaultOrigin>;
+    params: Parameters<T[K]>;
+};
+export declare const createRequestChannelMessageSender: <T extends RequestTypes, K extends Extract<keyof T, string>>({ requestType, messageSessionId, timeoutMap, onReceiveAck, messageTransport, onTimeout, params, }: RequestChannelMessageSenderParams<T, K>) => {
+    handleAckMessage: ({ messageSessionId: incomingSessionId, type: incomingType, }: MessageTransportData) => void;
+    sendMessage: () => void;
+};
+export {};

package/src/requestChannel/createRequestChannelMessageSender/createRequestChannelMessageSender.js

@@ -0,0 +1,41 @@
+'use client'
+import { getAckMessageType, TIMEOUT_DURATION } from '../utils/utils.js';
+
+const createRequestChannelMessageSender = ({ requestType, messageSessionId, timeoutMap, onReceiveAck, messageTransport, onTimeout, params, }) => {
+    const ackMessageType = getAckMessageType(requestType);
+    const message = {
+        args: params,
+        messageSessionId,
+        type: requestType,
+    };
+    // We must listen for acks
+    const handleAckMessage = ({ messageSessionId: incomingSessionId, type: incomingType, }) => {
+        if (incomingSessionId !== messageSessionId ||
+            incomingType !== ackMessageType)
+            return;
+        clearTimeout(timeoutMap[messageSessionId]);
+        delete timeoutMap[messageSessionId];
+        onReceiveAck === null || onReceiveAck === void 0 ? void 0 : onReceiveAck();
+    };
+    const sendMessage = () => {
+        const startTimer = () => {
+            const timeoutTimer = setTimeout(onTimeout, TIMEOUT_DURATION);
+            timeoutMap[messageSessionId] = timeoutTimer;
+        };
+        // If this message transport is currently blocked, we must only start
+        // the timeout once the message is actually emitted
+        // We don't just default to this because the onEmit option is only
+        // present in the message transport if has the block decorator
+        if ('isBlocked' in messageTransport && messageTransport.isBlocked()) {
+            messageTransport.emit(message, { onEmit: startTimer });
+            return;
+        }
+        // Now we emit the event to set off the request
+        messageTransport.emit(message);
+        // We start the timer immediately since the message was not blocked
+        startTimer();
+    };
+    return { handleAckMessage, sendMessage };
+};
+
+export { createRequestChannelMessageSender };

package/src/requestChannel/createRequestChannelMessageSender/index.d.ts

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

package/src/requestChannel/index.d.ts

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

package/src/requestChannel/requestChannel.cjs

@@ -4,32 +4,12 @@
 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 createRequestChannelMessageSender = require('./createRequestChannelMessageSender/createRequestChannelMessageSender.cjs');
+var utils = require('./utils/utils.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.
@@ -63,31 +43,24 @@ const createRequestChannel = (messageTransport) => {
             // 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,
+            const { handleAckMessage, sendMessage } = createRequestChannelMessageSender.createRequestChannelMessageSender({
                 messageSessionId,
-                type: requestType,
+                messageTransport,
+                onReceiveAck: () => {
+                    cleanupMessageHandler();
+                    resolve();
+                },
+                onTimeout: () => {
+                    cleanupMessageHandler();
+                    reject(utils.createNoHandlerError(requestType));
+                },
+                params,
+                requestType,
+                timeoutMap,
             });
-            // And start the time out timer
-            const timeoutTimer = setTimeout(() => {
-                reject(createNoHandlerError(requestType, cleanup));
-            }, TIMEOUT_DURATION);
-            timeoutMap[messageSessionId] = timeoutTimer;
+            const cleanupMessageHandler = () => messageTransport.off(handleAckMessage);
+            messageTransport.on(handleAckMessage);
+            sendMessage();
         }),
         handle: (requestType, handler) => {
             const messageHandler = (_a) => _tslib.__awaiter(void 0, [_a], void 0, function* ({ args, messageSessionId, type: incomingType, }) {
@@ -97,7 +70,7 @@ const createRequestChannel = (messageTransport) => {
                 messageTransport.emit({
                     args: [],
                     messageSessionId,
-                    type: getAckMessageType(requestType),
+                    type: utils.getAckMessageType(requestType),
                 });
                 const result = handler(...args);
                 // If the handler doesn't return a promise,
@@ -109,14 +82,14 @@ const createRequestChannel = (messageTransport) => {
                     messageTransport.emit({
                         args: [response],
                         messageSessionId,
-                        type: getResolveMessageType(requestType),
+                        type: utils.getResolveMessageType(requestType),
                     });
                 }
                 catch (error) {
                     messageTransport.emit({
                         args: [serializeErrorForTransport.serializeErrorForTransport(error)],
                         messageSessionId,
-                        type: getRejectMessageType(requestType),
+                        type: utils.getRejectMessageType(requestType),
                     });
                 }
             });
@@ -127,52 +100,49 @@ const createRequestChannel = (messageTransport) => {
         },
         request: (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 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];
+            const resolveMessageType = utils.getResolveMessageType(requestType);
+            const rejectMessageType = utils.getRejectMessageType(requestType);
+            const { handleAckMessage, sendMessage } = createRequestChannelMessageSender.createRequestChannelMessageSender({
+                messageSessionId,
+                messageTransport,
+                onTimeout: () => {
+                    cleanupMessageHandler();
+                    reject(utils.createNoHandlerError(requestType));
+                },
+                params,
+                requestType,
+                timeoutMap,
+            });
+            // We also need to listen to resolve and reject messages, besides acks
+            const handleMessage = (message) => {
+                if (message.messageSessionId !== messageSessionId)
                     return;
-                }
+                const { args: [result], type: incomingType, } = message;
                 if (incomingType === resolveMessageType) {
+                    cleanupMessageHandler();
                     resolve(result);
-                    cleanup();
                     return;
                 }
                 if (incomingType === rejectMessageType) {
+                    cleanupMessageHandler();
                     if (isSerializedError.isSerializedError(result)) {
                         reject(parseErrorFromTransport.parseErrorFromTransport(result));
                     }
                     else {
                         reject(result);
                     }
-                    cleanup();
+                    return;
                 }
+                handleAckMessage(message);
             };
-            const cleanup = () => messageTransport.off(handleMessage);
+            const cleanupMessageHandler = () => 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,
-                messageSessionId,
-                type: requestType,
-            });
+            sendMessage();
         }),
     };
 };
 
-exports.TIMEOUT_DURATION = TIMEOUT_DURATION;
 exports.createRequestChannel = createRequestChannel;
-exports.getAckMessageType = getAckMessageType;
-exports.getRejectMessageType = getRejectMessageType;
-exports.getResolveMessageType = getResolveMessageType;