@dynamic-labs/message-transport 4.0.0-alpha.5 → 4.0.0-alpha.51

package/src/messageTransport/decorators/makeWaitForInitEvent/makeWaitForInitEvent.d.ts

@@ -1,8 +1,8 @@
-import { MessageTransport, MessageTransportData } from '../../messageTransport';
+import { MessageTransport } from '../../messageTransport';
 import { BypassBlockCallback } from '../makeWaitForUnblock';
-type MakeWaitForInitEventProps = {
+type MakeWaitForInitEventProps<M extends MessageTransport> = {
     /** MessageTransport to add this decorator to */
-    messageTransport: MessageTransport;
+    messageTransport: M;
     /** Which message type should trigger the initialization */
     initializeMessageType: string;
     /** If true is returned, the message will not be blocked */
@@ -16,10 +16,5 @@ type MakeWaitForInitEventProps = {
  *    2. Any future emit calls will no longer store the message, and instead
  *      will emit them right away, as normal.
  */
-export declare const makeWaitForInitEvent: ({ bypassBlockIf, initializeMessageType, messageTransport, }: MakeWaitForInitEventProps) => {
-    unblock: () => void;
-    emit: (message: MessageTransportData) => void;
-    off: (callback: import("../../messageTransport").MessageTransportCallback) => void;
-    on: (callback: import("../../messageTransport").MessageTransportCallback) => void;
-};
+export declare const makeWaitForInitEvent: <M extends MessageTransport>({ bypassBlockIf, initializeMessageType, messageTransport, }: MakeWaitForInitEventProps<M>) => import("../makeWaitForUnblock").WithBlock<M>;
 export {};

package/src/messageTransport/decorators/makeWaitForUnblock/makeWaitForUnblock.cjs

@@ -14,40 +14,46 @@ Object.defineProperty(exports, '__esModule', { value: true });
 const makeWaitForUnblock = ({ messageTransport, bypassBlockIf = () => false, }) => {
     /** Whether to block any new messages */
     let blocked = true;
-    /** Messages pending to be sent once unblocked */
+    /**
+     * Messages pending to be sent once unblocked, along with their onEmit callbacks
+     */
     let pendingMessages = [];
     /**
      * Ids of incoming message sessions.
      * We don't want to block responses to these messages.
      */
     const bypassedMessageSessionIds = new Set();
-    const extendedTransport = {
-        emit: (message) => {
+    return {
+        emit: (message, options) => {
+            const { onEmit } = options !== null && options !== void 0 ? options : {};
             if (bypassBlockIf(message) && blocked) {
                 bypassedMessageSessionIds.add(message.messageSessionId);
             }
             // Even if blocking, we still want to let through ids of messages that
             // can bypass the block (this includes any responses, since they share the same id)
             if (blocked && !bypassedMessageSessionIds.has(message.messageSessionId)) {
-                pendingMessages.push(message);
+                pendingMessages.push({ message, onEmit });
                 return;
             }
             messageTransport.emit(message);
+            onEmit === null || onEmit === void 0 ? void 0 : onEmit();
         },
+        isBlocked: () => blocked,
         off: (callback) => messageTransport.off(callback),
         on: (callback) => messageTransport.on(callback),
+        unblock: () => {
+            if (!blocked)
+                return;
+            blocked = false;
+            // Emit all stored messages
+            for (const { message, onEmit } of pendingMessages) {
+                messageTransport.emit(message);
+                onEmit === null || onEmit === void 0 ? void 0 : onEmit();
+            }
+            pendingMessages = [];
+            bypassedMessageSessionIds.clear();
+        },
     };
-    const unblock = () => {
-        if (!blocked)
-            return;
-        blocked = false;
-        // Emit all stored messages
-        for (const message of pendingMessages)
-            messageTransport.emit(message);
-        pendingMessages = [];
-        bypassedMessageSessionIds.clear();
-    };
-    return Object.assign(Object.assign({}, extendedTransport), { unblock });
 };
 
 exports.makeWaitForUnblock = makeWaitForUnblock;

package/src/messageTransport/decorators/makeWaitForUnblock/makeWaitForUnblock.d.ts

@@ -1,11 +1,24 @@
 import { MessageTransport, MessageTransportData } from '../../messageTransport';
 export type BypassBlockCallback = (message: MessageTransportData) => boolean;
-type MakeWaitForUnblockProps = {
+type MakeWaitForUnblockProps<M extends MessageTransport> = {
     /** MessageTransport to add this decorator to */
-    messageTransport: MessageTransport;
+    messageTransport: M;
     /** If true is return the message will not be blocked */
     bypassBlockIf?: BypassBlockCallback;
 };
+/**
+ * A message transport that may have its messages blocked until unblock is called.
+ *
+ * This adds a second param to the emit method that allows triggering a callback when
+ * the message is actually emitted.
+ */
+export type WithBlock<M extends MessageTransport> = M & {
+    emit: (message: Parameters<M['emit']>[0], options?: {
+        onEmit?: VoidFunction;
+    }) => void;
+    unblock: () => void;
+    isBlocked: () => boolean;
+};
 /**
  * Decorator that adds the following features to a MessageTransport:
  * 1. Any emit calls will not emit the message yet. These messages will be stored.
@@ -14,10 +27,5 @@ type MakeWaitForUnblockProps = {
  *    2. Any future emit calls will no longer store the message, and instead
  *      will emit them right away, as normal.
  */
-export declare const makeWaitForUnblock: ({ messageTransport, bypassBlockIf, }: MakeWaitForUnblockProps) => {
-    unblock: () => void;
-    emit: (message: MessageTransportData) => void;
-    off: (callback: import("../../messageTransport").MessageTransportCallback) => void;
-    on: (callback: import("../../messageTransport").MessageTransportCallback) => void;
-};
+export declare const makeWaitForUnblock: <M extends MessageTransport>({ messageTransport, bypassBlockIf, }: MakeWaitForUnblockProps<M>) => WithBlock<M>;
 export {};

package/src/messageTransport/decorators/makeWaitForUnblock/makeWaitForUnblock.js

@@ -10,40 +10,46 @@
 const makeWaitForUnblock = ({ messageTransport, bypassBlockIf = () => false, }) => {
     /** Whether to block any new messages */
     let blocked = true;
-    /** Messages pending to be sent once unblocked */
+    /**
+     * Messages pending to be sent once unblocked, along with their onEmit callbacks
+     */
     let pendingMessages = [];
     /**
      * Ids of incoming message sessions.
      * We don't want to block responses to these messages.
      */
     const bypassedMessageSessionIds = new Set();
-    const extendedTransport = {
-        emit: (message) => {
+    return {
+        emit: (message, options) => {
+            const { onEmit } = options !== null && options !== void 0 ? options : {};
             if (bypassBlockIf(message) && blocked) {
                 bypassedMessageSessionIds.add(message.messageSessionId);
             }
             // Even if blocking, we still want to let through ids of messages that
             // can bypass the block (this includes any responses, since they share the same id)
             if (blocked && !bypassedMessageSessionIds.has(message.messageSessionId)) {
-                pendingMessages.push(message);
+                pendingMessages.push({ message, onEmit });
                 return;
             }
             messageTransport.emit(message);
+            onEmit === null || onEmit === void 0 ? void 0 : onEmit();
         },
+        isBlocked: () => blocked,
         off: (callback) => messageTransport.off(callback),
         on: (callback) => messageTransport.on(callback),
+        unblock: () => {
+            if (!blocked)
+                return;
+            blocked = false;
+            // Emit all stored messages
+            for (const { message, onEmit } of pendingMessages) {
+                messageTransport.emit(message);
+                onEmit === null || onEmit === void 0 ? void 0 : onEmit();
+            }
+            pendingMessages = [];
+            bypassedMessageSessionIds.clear();
+        },
     };
-    const unblock = () => {
-        if (!blocked)
-            return;
-        blocked = false;
-        // Emit all stored messages
-        for (const message of pendingMessages)
-            messageTransport.emit(message);
-        pendingMessages = [];
-        bypassedMessageSessionIds.clear();
-    };
-    return Object.assign(Object.assign({}, extendedTransport), { unblock });
 };
 
 export { makeWaitForUnblock };

package/src/messageTypes/AccountAbstractionMessages.d.ts

@@ -0,0 +1,15 @@
+import { BaseWallet } from '@dynamic-labs/types';
+export type AccountAbstractionIsSmartWalletArgs = {
+    wallet: BaseWallet;
+};
+export type AccountAbstractionGetEOAWalletArgs = {
+    wallet: BaseWallet;
+};
+export type AccountAbstractionGetSmartWalletArgs = {
+    wallet: BaseWallet;
+};
+export type AccountAbstractionMessages = {
+    isSmartWallet: (args: AccountAbstractionIsSmartWalletArgs) => Promise<boolean>;
+    getEOAWallet: (args: AccountAbstractionGetEOAWalletArgs) => Promise<BaseWallet | null>;
+    getSmartWallet: (args: AccountAbstractionGetSmartWalletArgs) => Promise<BaseWallet | null>;
+};

package/src/messageTypes/AuthModuleMessages.cjs

@@ -0,0 +1,14 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const authEventNames = [
+    'authSuccess',
+    'authFailed',
+    'authInit',
+    'loggedOut',
+    'userProfileUpdated',
+];
+
+exports.authEventNames = authEventNames;

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/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' | 'tiktok' | 'twitch' | 'twitter' | 'shopify' | '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';