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

package/CHANGELOG.md

@@ -1,4 +1,43 @@
 
+## [4.0.0-alpha.7](https://github.com/dynamic-labs/dynamic-auth/compare/v4.0.0-alpha.6...v4.0.0-alpha.7) (2024-10-03)
+
+
+### Features
+
+* add account abstraction module to client ([#7002](https://github.com/dynamic-labs/dynamic-auth/issues/7002)) ([2f06975](https://github.com/dynamic-labs/dynamic-auth/commit/2f06975083dfa9d40537ef4a99b414eda1a68e01))
+* add support for wallet events in rn ([#7061](https://github.com/dynamic-labs/dynamic-auth/issues/7061)) ([c7c4ce5](https://github.com/dynamic-labs/dynamic-auth/commit/c7c4ce51f27a2b84a1710c120d7006a00920c1e7))
+* add zerodev extension for react native ([#7028](https://github.com/dynamic-labs/dynamic-auth/issues/7028)) ([858b8a8](https://github.com/dynamic-labs/dynamic-auth/commit/858b8a851cfa0cddc8e4559541b03992cf5ccdfc))
+
+
+### Bug Fixes
+
+* do not modify sol tx blockhash as tx could have been signed already ([#7050](https://github.com/dynamic-labs/dynamic-auth/issues/7050)) ([770edb4](https://github.com/dynamic-labs/dynamic-auth/commit/770edb49ddc231b75fb45a9f6d563f22e5185df2))
+* ensure the correct auth mode is used on social redirect ([#7047](https://github.com/dynamic-labs/dynamic-auth/issues/7047)) ([7c27172](https://github.com/dynamic-labs/dynamic-auth/commit/7c271721d5ddf19e3fd1bf56ddb1d49e0e2bca07))
+* prevent react native message timeout before sdk is ready ([#7051](https://github.com/dynamic-labs/dynamic-auth/issues/7051)) ([6421237](https://github.com/dynamic-labs/dynamic-auth/commit/6421237d677d788b824d53432c1a75b9d571aa78))
+* update version error text ([#7054](https://github.com/dynamic-labs/dynamic-auth/issues/7054)) ([713dacb](https://github.com/dynamic-labs/dynamic-auth/commit/713dacb79c2513323c2e6840d7418716011c2dcd))
+* use project settings sdk network for send flow ([#7011](https://github.com/dynamic-labs/dynamic-auth/issues/7011)) ([983e796](https://github.com/dynamic-labs/dynamic-auth/commit/983e79632762f71ee0502c92057a32ea985ae19c))
+
+## [4.0.0-alpha.6](https://github.com/dynamic-labs/dynamic-auth/compare/v4.0.0-alpha.5...v4.0.0-alpha.6) (2024-10-01)
+
+
+### ⚠ BREAKING CHANGES
+
+* remove support to magic ([#7033](https://github.com/dynamic-labs/dynamic-auth/issues/7033)) ([0fdc41f](https://github.com/dynamic-labs/dynamic-auth/commit/0fdc41f05f87b32f56b73db068f984f18bdf69a0))
+
+### Features
+
+* global connectivity disconnect ([#7008](https://github.com/dynamic-labs/dynamic-auth/issues/7008)) ([80d705b](https://github.com/dynamic-labs/dynamic-auth/commit/80d705ba252aa3b01cbf4861507fed00e460215f))
+
+
+### Bug Fixes
+
+* add popper context to send balance ([#7016](https://github.com/dynamic-labs/dynamic-auth/issues/7016)) ([73aa6f1](https://github.com/dynamic-labs/dynamic-auth/commit/73aa6f122afe0db660ebb654f3e018ae7bf445c5))
+* add retry to useConnectWithOtp ([#7012](https://github.com/dynamic-labs/dynamic-auth/issues/7012)) ([d551d72](https://github.com/dynamic-labs/dynamic-auth/commit/d551d72a463f8a03964858b30ec174d41985a7b1))
+* don't re-fetch wallet address on network change ([#7019](https://github.com/dynamic-labs/dynamic-auth/issues/7019)) ([4e7900c](https://github.com/dynamic-labs/dynamic-auth/commit/4e7900cc24b3abda736bc81466eda7512cf7fc61))
+* fix sign message with solana wallet standard provider ([#7014](https://github.com/dynamic-labs/dynamic-auth/issues/7014)) ([ffaf972](https://github.com/dynamic-labs/dynamic-auth/commit/ffaf972e8b190b0b8cd0103e0ef67bfdee6c8f7c))
+* update wallet reference when user switches wallet in connect-only ([#7030](https://github.com/dynamic-labs/dynamic-auth/issues/7030)) ([75d9aa6](https://github.com/dynamic-labs/dynamic-auth/commit/75d9aa66f63fc5536caeff12d8b860c0ba86106f))
+
+
 ## [4.0.0-alpha.5](https://github.com/dynamic-labs/DynamicAuth/compare/v4.0.0-alpha.4...v4.0.0-alpha.5) (2024-09-25)
 
 

package/package.cjs

@@ -0,0 +1,8 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var version = "4.0.0-alpha.7";
+
+exports.version = version;

package/package.js

@@ -0,0 +1,4 @@
+'use client'
+var version = "4.0.0-alpha.7";
+
+export { version };

package/package.json

@@ -1,16 +1,7 @@
 {
   "name": "@dynamic-labs/message-transport",
-  "version": "4.0.0-alpha.5",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/dynamic-labs/dynamic-auth.git",
-    "directory": "packages/message-transport"
-  },
+  "version": "4.0.0-alpha.7",
   "description": "Defines the interface to communicate with dynamic's webview",
-  "bugs": {
-    "url": "https://github.com/dynamic-labs/DynamicAuth/issues"
-  },
-  "homepage": "https://github.com/dynamic-labs/DynamicAuth/main/packages/message-transport#readme",
   "author": "Dynamic Labs, Inc.",
   "license": "MIT",
   "main": "./src/index.cjs",
@@ -25,14 +16,16 @@
     },
     "./package.json": "./package.json"
   },
+  "homepage": "https://www.dynamic.xyz/",
   "dependencies": {
     "@dynamic-labs/sdk-api-core": "0.0.535",
     "@vue/reactivity": "3.4.21",
-    "@dynamic-labs/types": "4.0.0-alpha.5",
+    "@dynamic-labs/types": "4.0.0-alpha.7",
     "eventemitter3": "5.0.1"
   },
   "peerDependencies": {
-    "@dynamic-labs/logger": "4.0.0-alpha.5",
-    "@dynamic-labs/utils": "4.0.0-alpha.5"
+    "@dynamic-labs/assert-package-version": "4.0.0-alpha.7",
+    "@dynamic-labs/logger": "4.0.0-alpha.7",
+    "@dynamic-labs/utils": "4.0.0-alpha.7"
   }
 }

package/src/index.cjs

@@ -3,6 +3,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var assertPackageVersion = require('@dynamic-labs/assert-package-version');
+var _package = require('../package.cjs');
 var messageTransport = require('./messageTransport/messageTransport.cjs');
 var applyDefaultMessageOrigin = require('./messageTransport/decorators/applyDefaultMessageOrigin/applyDefaultMessageOrigin.cjs');
 var makeWaitForInitEvent = require('./messageTransport/decorators/makeWaitForInitEvent/makeWaitForInitEvent.cjs');
@@ -16,7 +18,7 @@ var store = require('./store/store.cjs');
 var storeSetter = require('./store/storeSetter/storeSetter.cjs');
 var SdkModuleMessages = require('./messageTypes/SdkModuleMessages.cjs');
 
-
+assertPackageVersion.assertPackageVersion('@dynamic-labs/message-transport', _package.version);
 
 exports.createMessageTransport = messageTransport.createMessageTransport;
 exports.applyDefaultMessageOrigin = applyDefaultMessageOrigin.applyDefaultMessageOrigin;

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 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';
+export { sdkHasLoadedEventName, type AccountAbstractionGetEOAWalletArgs, type AccountAbstractionGetSmartWalletArgs, type AccountAbstractionIsSmartWalletArgs, type AccountAbstractionMessages, type AuthModuleMessages, type AuthModuleState, type ClientManifest, type ConsoleMessages, type CreateEmbeddedWalletArgs, type EmailOtpParams, type EmbeddedWalletsModuleMessages, type EmbeddedWalletsModuleState, type EthMessages, type EthRequestParams, type EthRequestWithAddressParams, type EthRequestWithChainIdParams, type ExternalAuthMessages, type FetchMessages, type KernelAccountSettings, type NetworksModuleState, type OtpData, type OtpMessages, type PasskeyMessages, type PlatformServiceMessages, type ProjectSettingsMessages, type SdkModuleMessages, type SdkModuleState, type SecureStorageMessages, type SignInWithExternalJwtParams, type SmsOtpParams, type SocialAuthModuleMessages, type SocialProvider, type SolanaMessages, type UserInterfaceModuleMessages, type VerifyWithExternalJwtParams, type WalletEvents, type WalletsModuleMessages, type WalletsModuleState, type WebViewVisibilityMessages, type ZeroDevExtensionMessages, } from './messageTypes';

package/src/index.js

@@ -1,4 +1,6 @@
 'use client'
+import { assertPackageVersion } from '@dynamic-labs/assert-package-version';
+import { version } from '../package.js';
 export { createMessageTransport } from './messageTransport/messageTransport.js';
 export { applyDefaultMessageOrigin } from './messageTransport/decorators/applyDefaultMessageOrigin/applyDefaultMessageOrigin.js';
 export { makeWaitForInitEvent } from './messageTransport/decorators/makeWaitForInitEvent/makeWaitForInitEvent.js';
@@ -11,3 +13,5 @@ export { createEventEmitterForMessages } from './store/createEventEmitterForMess
 export { createStore } from './store/store.js';
 export { createStoreSetter } from './store/storeSetter/storeSetter.js';
 export { sdkHasLoadedEventName } from './messageTypes/SdkModuleMessages.js';
+
+assertPackageVersion('@dynamic-labs/message-transport', version);

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,48 @@ 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();
+        },
+        get isBlocked() {
+            return 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,48 @@
 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();
+        },
+        get isBlocked() {
+            return 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/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/WalletsModuleMessages.d.ts

@@ -27,4 +27,19 @@ export type WalletsModuleMessages = {
     setPrimary: (params: {
         walletId: string;
     }) => Promise<void>;
+    onWalletEvent: (params: WalletEventArguments & {
+        walletId: string;
+    }) => void;
+};
+export type WalletEvents = {
+    chainChange: (props: {
+        chain: string;
+    }) => void;
 };
+type WalletEventArguments = {
+    [E in keyof WalletEvents]: {
+        event: E;
+        eventParams: Parameters<WalletEvents[E]>;
+    };
+}[keyof WalletEvents];
+export {};

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,6 +9,7 @@ export * from './NetworksModuleMessages';
 export * from './OtpMessages';
 export * from './PasskeyMessages';
 export * from './PlatformServiceMessages';
+export * from './ProjectSettingsMessages';
 export * from './SdkModuleMessages';
 export * from './SecureStorageMessages';
 export * from './SocialAuthModuleMessages';
@@ -15,3 +17,4 @@ export * from './SolanaMessages';
 export * from './UserInterfaceModuleMessages';
 export * from './WalletsModuleMessages';
 export * from './WebViewVisibilityMessages';
+export * from './ZeroDevExtensionMessages';

package/src/requestChannel/createRequestChannelMessageSender/createRequestChannelMessageSender.cjs

@@ -0,0 +1,43 @@
+'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
+        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,39 @@
+'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
+        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;

package/src/requestChannel/requestChannel.d.ts

@@ -1,71 +1,6 @@
+import { WithBlock } from '../messageTransport';
 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> = Extract<{
-    [K in keyof T]: ReturnType<T[K]> extends Promise<any> ? K : never;
-}[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 Extract<keyof T, string>>(requestType: K, handler: T[K]) => VoidFunction;
-    /**
-     * Triggers handlers for this request type, with the given params.
-     * 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 Extract<keyof T, string>>(requestName: K, ...params: Parameters<T[K]>) => Promise<void>;
-    /**
-     * Triggers handlers for this request type, with the given params.
-     * 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]>;
-};
-/** 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;
-/** 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;
+import { RequestChannel, RequestTypes } from './types';
 /**
  * Allows handling and submitting requests to and from a webview.
  * Requests are messages that (can) expect some response.
@@ -84,5 +19,4 @@ export declare const TIMEOUT_DURATION = 3000;
  *
  * This is an abstraction built on top of the MessageTransport interface.
  */
-export declare const createRequestChannel: <T extends RequestTypes = never>(messageTransport: MessageTransportWithDefaultOrigin) => RequestChannel<T>;
-export {};
+export declare const createRequestChannel: <T extends RequestTypes = never>(messageTransport: MessageTransportWithDefaultOrigin | WithBlock<MessageTransportWithDefaultOrigin>) => RequestChannel<T>;

package/src/requestChannel/requestChannel.js

@@ -1,31 +1,11 @@
 '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 { createRequestChannelMessageSender } from './createRequestChannelMessageSender/createRequestChannelMessageSender.js';
+import { createNoHandlerError, getAckMessageType, getResolveMessageType, getRejectMessageType } from './utils/utils.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.
@@ -59,31 +39,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({
                 messageSessionId,
-                type: requestType,
+                messageTransport,
+                onReceiveAck: () => {
+                    cleanupMessageHandler();
+                    resolve();
+                },
+                onTimeout: () => {
+                    cleanupMessageHandler();
+                    reject(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) => __awaiter(void 0, [_a], void 0, function* ({ args, messageSessionId, type: incomingType, }) {
@@ -123,48 +96,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 { handleAckMessage, sendMessage } = createRequestChannelMessageSender({
+                messageSessionId,
+                messageTransport,
+                onTimeout: () => {
+                    cleanupMessageHandler();
+                    reject(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(result)) {
                         reject(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();
         }),
     };
 };
 
-export { TIMEOUT_DURATION, createRequestChannel, getAckMessageType, getRejectMessageType, getResolveMessageType };
+export { createRequestChannel };

package/src/requestChannel/types.d.ts

@@ -0,0 +1,55 @@
+/**
+ * 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> = Extract<{
+    [K in keyof T]: ReturnType<T[K]> extends Promise<any> ? K : never;
+}[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 Extract<keyof T, string>>(requestType: K, handler: T[K]) => VoidFunction;
+    /**
+     * Triggers handlers for this request type, with the given params.
+     * 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 Extract<keyof T, string>>(requestName: K, ...params: Parameters<T[K]>) => Promise<void>;
+    /**
+     * Triggers handlers for this request type, with the given params.
+     * 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]>;
+};
+export {};

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

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

package/src/requestChannel/utils/utils.cjs

@@ -0,0 +1,33 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils = require('@dynamic-labs/utils');
+var logger = require('../../utils/logger.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) => {
+    const message = `No handlers were registered for message of type ${type}`;
+    logger.logger.error(message);
+    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;
+
+exports.TIMEOUT_DURATION = TIMEOUT_DURATION;
+exports.createNoHandlerError = createNoHandlerError;
+exports.getAckMessageType = getAckMessageType;
+exports.getRejectMessageType = getRejectMessageType;
+exports.getResolveMessageType = getResolveMessageType;

package/src/requestChannel/utils/utils.d.ts

@@ -0,0 +1,16 @@
+import { RequestChannelNotHandledError } from '@dynamic-labs/utils';
+/** 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;
+/** Given a request event name, returns the event name for its acknowledgement */
+export declare const getAckMessageType: (type: string) => string;
+/** Returns a "no handlers registered" error for a message type */
+export declare const createNoHandlerError: (type: string) => RequestChannelNotHandledError;
+/**
+ * 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;

package/src/requestChannel/utils/utils.js

@@ -0,0 +1,25 @@
+'use client'
+import { RequestChannelNotHandledError } from '@dynamic-labs/utils';
+import { logger } from '../../utils/logger.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) => {
+    const message = `No handlers were registered for message of type ${type}`;
+    logger.error(message);
+    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;
+
+export { TIMEOUT_DURATION, createNoHandlerError, getAckMessageType, getRejectMessageType, getResolveMessageType };