feat: full deeplink protocol

packages/sdk-communication-layer/src/services/RemoteCommunication/MessageHandlers/handleWalletInitMessage.ts

@@ -3,7 +3,7 @@ import { CommunicationLayerMessage } from '../../../types/CommunicationLayerMess
 import { EventType } from '../../../types/EventType';
 import { logger } from '../../../utils/logger';
 
-export function handleWalletInitMessage(
+export async function handleWalletInitMessage(
   instance: RemoteCommunication,
   message: CommunicationLayerMessage,
 ) {
@@ -19,32 +19,36 @@ export function handleWalletInitMessage(
       'chainId' in data &&
       'walletKey' in data
     ) {
-      // Persist channel config
-      const { channelConfig } = instance.state;
-      logger.RemoteCommunication(
-        `WALLET_INIT: channelConfig`,
-        JSON.stringify(channelConfig, null, 2),
-      );
+      try {
+        // Persist channel config
+        const { channelConfig } = instance.state;
+        logger.RemoteCommunication(
+          `WALLET_INIT: channelConfig`,
+          JSON.stringify(channelConfig, null, 2),
+        );
 
-      if (channelConfig) {
-        const accounts = data.accounts as string[];
-        const chainId = data.chainId as string;
-        const walletKey = data.walletKey as string;
+        if (channelConfig) {
+          const accounts = data.accounts as string[];
+          const chainId = data.chainId as string;
+          const walletKey = data.walletKey as string;
 
-        instance.state.storageManager?.persistChannelConfig({
-          ...channelConfig,
-          otherKey: walletKey,
-          relayPersistence: true,
-        });
+          await instance.state.storageManager?.persistChannelConfig({
+            ...channelConfig,
+            otherKey: walletKey,
+            relayPersistence: true,
+          });
 
-        instance.state.storageManager?.persistAccounts(accounts);
-        instance.state.storageManager?.persistChainId(chainId);
-      }
+          await instance.state.storageManager?.persistAccounts(accounts);
+          await instance.state.storageManager?.persistChainId(chainId);
+        }
 
-      instance.emit(EventType.WALLET_INIT, {
-        accounts: data.accounts,
-        chainId: data.chainId,
-      });
+        instance.emit(EventType.WALLET_INIT, {
+          accounts: data.accounts,
+          chainId: data.chainId,
+        });
+      } catch (error) {
+        console.error('RemoteCommunication::on "wallet_init" -- error', error);
+      }
     } else {
       console.error(
         'RemoteCommunication::on "wallet_init" -- invalid data format',

packages/sdk-communication-layer/src/services/SocketService/ConnectionManager/resume.ts

@@ -14,19 +14,24 @@ import { handleJoinChannelResults } from './handleJoinChannelResult';
  *
  * @param instance The current instance of the SocketService.
  */
-export function resume(instance: SocketService) {
+export function resume(instance: SocketService): void {
   const { state, remote } = instance;
   const { socket, channelId, context, keyExchange, isOriginator } = state;
   const { isOriginator: remoteIsOriginator } = remote.state;
 
   logger.SocketService(
-    `[SocketService: resume()] context=${context} connected=${
+    `[SocketService: resume()] channelId=${channelId} context=${context} connected=${
       socket?.connected
     } manualDisconnect=${state.manualDisconnect} resumed=${
       state.resumed
     } keysExchanged=${keyExchange?.areKeysExchanged()}`,
   );
 
+  if (!channelId) {
+    logger.SocketService(`[SocketService: resume()] channelId is not defined`);
+    throw new Error('ChannelId is not defined');
+  }
+
   if (socket?.connected) {
     logger.SocketService(`[SocketService: resume()] already connected.`);
     socket.emit(MessageType.PING, {
@@ -35,6 +40,15 @@ export function resume(instance: SocketService) {
       context: 'on_channel_config',
       message: '',
     });
+
+    if (!remote.hasRelayPersistence() && !keyExchange?.areKeysExchanged()) {
+      // Always try to recover key exchange from both side (wallet / dapp)
+      if (isOriginator) {
+        instance.sendMessage({ type: MessageType.READY });
+      } else {
+        keyExchange?.start({ isOriginator: false });
+      }
+    }
   } else {
     socket?.connect();
 
@@ -51,7 +65,11 @@ export function resume(instance: SocketService) {
       },
       async (
         error: string | null,
-        result?: { ready: boolean; persistence?: boolean; walletKey?: string },
+        result?: {
+          ready: boolean;
+          persistence?: boolean;
+          walletKey?: string;
+        },
       ) => {
         try {
           await handleJoinChannelResults(instance, error, result);
@@ -62,17 +80,6 @@ export function resume(instance: SocketService) {
     );
   }
 
-  // Always try to recover key exchange from both side (wallet / dapp)
-  if (keyExchange?.areKeysExchanged()) {
-    if (!isOriginator) {
-      instance.sendMessage({ type: MessageType.READY });
-    }
-  } else if (!isOriginator) {
-    keyExchange?.start({
-      isOriginator: isOriginator ?? false,
-    });
-  }
-
   state.manualDisconnect = false;
   state.resumed = true;
 }

packages/sdk-communication-layer/src/services/SocketService/MessageHandlers/handleSendMessage.ts

@@ -41,6 +41,9 @@ export function handleSendMessage(
   message: CommunicationLayerMessage,
 ) {
   if (!instance.state.channelId) {
+    logger.SocketService(
+      `handleSendMessage: no channelId - Create a channel first`,
+    );
     throw new Error('Create a channel first');
   }
 

packages/sdk-socket-server-next/src/protocol/handleMessage.ts

@@ -134,11 +134,16 @@ export const handleMessage = async ({
       );
 
       // broadcast that the channel supports relayPersistence
-      socket.broadcast
-        .to(channelId)
-        .emit(`config-${channelId}`, { persistence: true });
+      socket.broadcast.to(channelId).emit(`config-${channelId}`, {
+        persistence: true,
+        walletKey: channelConfig.walletKey,
+      });
+
       // also inform current client
-      socket.emit(`config-${channelId}`, { persistence: true });
+      socket.emit(`config-${channelId}`, {
+        persistence: true,
+        walletKey: channelConfig.walletKey,
+      });
     }
     return;
   } catch (error) {

packages/sdk/src/services/RemoteCommunicationPostMessageStream/onMessage.ts

@@ -29,9 +29,7 @@ export function onMessage(
     }
 
     if (!message?.name) {
-      logger(
-        `[RCPMS: onMessage()] ignore message without name message=${message}`,
-      );
+      logger(`[RCPMS: onMessage()] ignore message without name`, message);
       return;
     }
 

packages/sdk/src/services/RemoteCommunicationPostMessageStream/write.ts

@@ -48,7 +48,7 @@ export async function write(
   const isSecure = instance.state.platformManager?.isSecure();
   const mobileWeb = instance.state.platformManager?.isMobileWeb() ?? false;
 
-  const activeDeeplinkProtocol = deeplinkProtocol && mobileWeb;
+  const activeDeeplinkProtocol = deeplinkProtocol && mobileWeb && authorized;
   console.warn(
     `[RCPMS: write()] activeDeeplinkProtocol=${activeDeeplinkProtocol}`,
   );
@@ -65,22 +65,6 @@ export async function write(
           logger(`[RCPMS: _write()] error sending message`, err);
         });
 
-      // Keep this for now as  reference -- it should become unnecessary if we send via deeplink
-      // if (!socketConnected && !isRemoteReady) {
-      //   // Invalid connection status
-      //   logger(
-      //     `[RCPMS: _write()] invalid connection status targetMethod=${targetMethod} socketConnected=${socketConnected} ready=${isRemoteReady} providerConnected=${provider.isConnected()}`,
-      //   );
-      //   return callback();
-      // }
-      if (!socketConnected && isRemoteReady) {
-        // Shouldn't happen -- needs to refresh
-        console.warn(
-          `[RCPMS: _write()] invalid socket status -- shouldn't happen`,
-        );
-        return callback();
-      }
-
       if (!isSecure) {
         // Redirect early if nodejs or browser...
         logger(
@@ -90,7 +74,6 @@ export async function write(
       }
     }
 
-    // Check if should open app
     const pubKey = instance.state.remote?.getKeyInfo()?.ecies.public ?? '';
     let urlParams = encodeURI(
       `channelId=${channelId}&pubkey=${pubKey}&comm=socket&t=d&v=2`,
@@ -106,18 +89,21 @@ export async function write(
         );
       }
       const encoded = base64Encode(encrypted);
-      console.warn(`[RCPMS: _write()] rpc`, data?.data, jsonrpc);
       urlParams += `&scheme=${deeplinkProtocol}&rpc=${encoded}`;
     }
 
-    console.log(`[RCPMS: _write()] urlParams=${urlParams}`);
+    if (!instance.state.platformManager?.isMetaMaskInstalled()) {
+      logger(
+        `[RCPMS: _write()] prevent deeplink until installation is completed.`,
+      );
+      return callback();
+    }
 
     if (METHODS_TO_REDIRECT[targetMethod]) {
       logger(
         `[RCPMS: _write()] redirect link for '${targetMethod}' socketConnected=${socketConnected} connect?${urlParams}`,
       );
 
-      // Use otp to re-enable host approval
       instance.state.platformManager?.openDeeplink(
         `${METAMASK_CONNECT_BASE_URL}?${urlParams}`,
         `${METAMASK_DEEPLINK_BASE}?${urlParams}`,