fixes: connectWith sdk

app/components/Views/AccountConnect/AccountConnect.tsx

@@ -229,12 +229,17 @@ const AccountConnect = (props: AccountConnectProps) => {
   );
 
   const actualIcon = useMemo(() => {
+    // Priority to dappIconUrl
+    if (dappIconUrl) {
+      return { uri: dappIconUrl };
+    }
+
     const favicon = faviconSource as ImageURISource;
     if ('uri' in favicon) {
       return faviconSource;
     }
 
-    return { uri: dappIconUrl ?? '' };
+    return { uri: '' };
   }, [dappIconUrl, faviconSource]);
 
   const secureIcon = useMemo(

app/core/SDKConnect/handlers/handleDeeplink.test.ts

@@ -3,19 +3,23 @@ import AppConstants from '../../AppConstants';
 import SDKConnect from '../SDKConnect';
 import { waitForCondition } from '../utils/wait.util';
 import handleDeeplink from './handleDeeplink';
+import handleConnectionMessage from './handleConnectionMessage';
 
 jest.mock('../SDKConnect');
 jest.mock('../../AppConstants');
 jest.mock('../utils/DevLogger');
 jest.mock('../utils/wait.util');
 jest.mock('../../../util/Logger');
+jest.mock('./handleConnectionMessage');
 
 describe('handleDeeplink', () => {
   let sdkConnect = {} as unknown as SDKConnect;
   // TODO: Replace "any" with type
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   let fakeConnections = {} as any;
-
+  const rpc = Buffer.from('{"jsonrpc":"2.0","method":"eth_accounts"}').toString(
+    'base64',
+  );
   const mockWaitForCondition = waitForCondition as jest.MockedFunction<
     typeof waitForCondition
   >;
@@ -33,6 +37,11 @@ describe('handleDeeplink', () => {
   const mockRevalidateChannel = jest.fn();
   const mockReconnect = jest.fn();
   const mockConnectToChannel = jest.fn();
+  const mockHandleConnectionMessage =
+    handleConnectionMessage as jest.MockedFunction<
+      typeof handleConnectionMessage
+    >;
+
   const mockDecrypt = jest
     .fn()
     .mockReturnValue('{"jsonrpc":"2.0","method":"eth_accounts"}');
@@ -46,6 +55,8 @@ describe('handleDeeplink', () => {
 
   beforeEach(() => {
     jest.clearAllMocks();
+    jest.resetModules();
+
     mockUpdateSDKLoadingState.mockResolvedValue(undefined);
     fakeConnections = [
       {
@@ -70,6 +81,11 @@ describe('handleDeeplink', () => {
     mockGetConnections.mockReturnValue(fakeConnections);
   });
 
+  afterEach(() => {
+    jest.clearAllMocks();
+    jest.restoreAllMocks();
+  });
+
   it('should waits for SDKConnect to initialize if not already initialized', async () => {
     mockHasInitialized.mockReturnValueOnce(false).mockReturnValueOnce(true);
     mockWaitForCondition.mockResolvedValue();
@@ -83,7 +99,6 @@ describe('handleDeeplink', () => {
       protocolVersion,
       context,
     });
-
     expect(waitForCondition).toHaveBeenCalledWith(expect.any(Object));
     expect(sdkConnect.hasInitialized).toHaveBeenCalledTimes(1);
   });
@@ -184,18 +199,50 @@ describe('handleDeeplink', () => {
     );
   });
 
-  it('should handle rpc calls when rpc has values and connection is valid', async () => {
-    const rpc = Buffer.from(
+  it('should handle rpc calls for existing connections', async () => {
+    mockHasInitialized.mockReturnValue(true);
+    mockGetConnections.mockReturnValue({ [channelId]: {} });
+
+    await handleDeeplink({
+      sdkConnect,
+      channelId,
+      origin,
+      url,
+      otherPublicKey,
+      protocolVersion,
+      context,
+      rpc,
+    });
+
+    expect(mockDecrypt).toHaveBeenCalledWith(
       '{"jsonrpc":"2.0","method":"eth_accounts"}',
-    ).toString('base64');
-    const decodedRPC = '{"jsonrpc":"2.0","method":"eth_accounts"}';
+    );
+    expect(handleConnectionMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: expect.any(Object),
+        connection: expect.any(Object),
+        engine: expect.any(Object),
+      }),
+    );
+  });
 
-    (sdkConnect.getConnections as jest.Mock).mockReturnValue({
-      [channelId]: {},
+  it('should handle rpc calls for new connections', async () => {
+    mockHasInitialized.mockReturnValue(true);
+    mockGetConnections.mockReturnValue({});
+    mockConnectToChannel.mockReturnValue({});
+    mockGetConnected.mockReturnValue({
+      [channelId]: {
+        remote: {
+          decrypt: mockDecrypt,
+        },
+      },
     });
 
+    // Spy on JSON.parse
+    const jsonParseSpy = jest.spyOn(JSON, 'parse');
+
     await handleDeeplink({
-      sdkConnect: sdkConnect as SDKConnect,
+      sdkConnect,
       channelId,
       origin,
       url,
@@ -205,21 +252,21 @@ describe('handleDeeplink', () => {
       rpc,
     });
 
-    expect(mockGetConnected()[channelId].remote.decrypt).toHaveBeenCalledWith(
-      decodedRPC,
-    );
+    expect(mockConnectToChannel).toHaveBeenCalled();
+
+    // Verify that JSON.parse was called with the correct string
+    expect(jsonParseSpy).toHaveBeenCalled();
+
+    expect(mockHandleConnectionMessage).toHaveBeenCalled();
   });
 
-  it('should not handle rpc calls when rpc has values and connection is not found', async () => {
-    const rpc = Buffer.from(
-      '{"jsonrpc":"2.0","method":"eth_accounts"}',
-    ).toString('base64');
-    (sdkConnect.getConnections as jest.Mock).mockReturnValue({
-      [channelId]: undefined,
-    });
+  it('should not handle rpc calls when connection is not found', async () => {
+    mockHasInitialized.mockReturnValue(true);
+    mockGetConnections.mockReturnValue({});
+    mockGetConnected.mockReturnValue({});
 
     await handleDeeplink({
-      sdkConnect: sdkConnect as SDKConnect,
+      sdkConnect,
       channelId,
       origin,
       url,
@@ -229,6 +276,8 @@ describe('handleDeeplink', () => {
       rpc,
     });
 
-    expect(mockGetConnected()[channelId].remote.decrypt).not.toHaveBeenCalled();
+    expect(mockConnectToChannel).toHaveBeenCalled();
+    expect(mockDecrypt).not.toHaveBeenCalled();
+    expect(handleConnectionMessage).not.toHaveBeenCalled();
   });
 });

app/core/SDKConnect/handlers/handleDeeplink.ts

@@ -9,6 +9,7 @@ import SDKConnect from '../SDKConnect';
 import DevLogger from '../utils/DevLogger';
 import { waitForCondition } from '../utils/wait.util';
 import handleConnectionMessage from './handleConnectionMessage';
+import { Platform } from 'react-native';
 
 const QRCODE_PARAM_PATTERN = '&t=q';
 
@@ -119,15 +120,51 @@ const handleDeeplink = async ({
         sdkConnect.updateSDKLoadingState({ channelId, loading: true });
       }
     } else {
+      const trigger =
+        rpc !== undefined && origin === AppConstants.DEEPLINKS.ORIGIN_DEEPLINK
+          ? undefined // temporarily unset trigger on android to prevent goBack after connection approval
+          : 'deeplink';
+
+      DevLogger.log(
+        `handleDeeplink:: connectToChannel - trigger=${trigger} origin=${origin} platform=${Platform.OS} rpc=${rpc}`,
+      );
       await sdkConnect.connectToChannel({
         id: channelId,
         origin,
         originatorInfo,
         initialConnection: true,
         protocolVersion,
-        trigger: 'deeplink',
+        trigger,
         otherPublicKey,
       });
+
+      // When RPC is provided on new connection, it means connectWith.
+      if (rpc) {
+        const connection = sdkConnect.getConnected()[channelId];
+        if (!connection) {
+          DevLogger.log(`handleDeeplink:: connection not found`);
+          return;
+        }
+
+        if (!trigger) {
+          // set trigger back to deeplink on android
+          connection.trigger = 'deeplink';
+        }
+
+        // Decode rpc and directly process it - simulate network reception
+        const decodedRPC = Buffer.from(rpc, 'base64').toString('utf-8');
+
+        DevLogger.log(`decoded rpc`, decodedRPC);
+
+        const message = JSON.parse(decodedRPC) as CommunicationLayerMessage;
+        DevLogger.log(`handleDeeplink:: message`, message);
+
+        await handleConnectionMessage({
+          message,
+          connection,
+          engine: Engine,
+        });
+      }
     }
   } catch (error) {
     Logger.error(error as Error, 'Failed to connect to channel');