Merge pull request #3 from MobileWalletProtocol/felix/polish

Singleton Communicator

Author: fan-zhang-sv

packages/client/.prettierignore

@@ -5,6 +5,5 @@ coverage/**
 **/build
 **/dist
 **/node_modules
-**/src/vendor-js
 **/*-css.ts
 **/*-svg.ts

packages/client/jest.config.ts

@@ -16,7 +16,7 @@ export default {
   coverageDirectory: 'coverage',
 
   // An array of regexp pattern strings used to skip coverage collection
-  coveragePathIgnorePatterns: ['/node_modules/', 'vendor-js/', 'assets/', 'walletlink/relay/'],
+  coveragePathIgnorePatterns: ['/node_modules/'],
 
   // A list of reporter names that Jest uses when writing coverage reports
   coverageReporters: ['json', 'text', 'text-summary', 'lcov'],

packages/client/package.json

@@ -22,7 +22,7 @@
     "test": "jest",
     "test:coverage": "yarn test:unit && open coverage/lcov-report/index.html",
     "prebuild": "rm -rf ./build && node -p \"'export const LIB_VERSION = \\'' + require('./package.json').version + '\\';'\" > src/version.ts",
-    "build": "tsc -p ./tsconfig.build.json && tsc-alias && cp -a src/vendor-js dist",
+    "build": "tsc -p ./tsconfig.build.json && tsc-alias",
     "dev": "tsc --watch & nodemon --watch dist --delay 1 --exec tsc-alias",
     "typecheck": "tsc --noEmit",
     "lint": "eslint . --ext .ts,.tsx --fix"

packages/client/src/MWPClient.test.ts

@@ -1,6 +1,5 @@
 import { WebBasedWalletCommunicator } from 'src/components/communicator/webBased/Communicator';
 
-import { CommunicatorInterface, getCommunicator } from './components/communicator';
 import { KeyManager } from './components/key/KeyManager';
 import { MWPClient } from './MWPClient';
 import {
@@ -57,7 +56,6 @@ const mockWallet = Wallets.CoinbaseSmartWallet;
 describe('MWPClient', () => {
   let signer: MWPClient;
   let mockMetadata: AppMetadata;
-  let mockCommunicator: CommunicatorInterface;
   let mockKeyManager: jest.Mocked<KeyManager>;
 
   beforeEach(async () => {
@@ -67,10 +65,8 @@ describe('MWPClient', () => {
       appDeeplinkUrl: 'https://example.com',
     };
 
-    WebBasedWalletCommunicator.communicators.clear();
-    mockCommunicator = getCommunicator(mockWallet);
     jest
-      .spyOn(mockCommunicator, 'postRequestAndWaitForResponse')
+      .spyOn(WebBasedWalletCommunicator, 'postRequestAndWaitForResponse')
       .mockResolvedValue(mockSuccessResponse);
 
     mockKeyManager = new KeyManager({
@@ -126,7 +122,9 @@ describe('MWPClient', () => {
         content: { failure: mockError },
         timestamp: new Date(),
       };
-      (mockCommunicator.postRequestAndWaitForResponse as jest.Mock).mockResolvedValue(mockResponse);
+      (WebBasedWalletCommunicator.postRequestAndWaitForResponse as jest.Mock).mockResolvedValue(
+        mockResponse
+      );
 
       await expect(signer.handshake()).rejects.toThrowError(mockError);
     });
@@ -165,11 +163,12 @@ describe('MWPClient', () => {
       const result = await signer.request(mockRequest);
 
       expect(encryptContent).toHaveBeenCalled();
-      expect(mockCommunicator.postRequestAndWaitForResponse).toHaveBeenCalledWith(
+      expect(WebBasedWalletCommunicator.postRequestAndWaitForResponse).toHaveBeenCalledWith(
         expect.objectContaining({
           sender: '0xPublicKey',
           content: { encrypted: encryptedData },
-        })
+        }),
+        mockWallet.scheme
       );
       expect(result).toEqual('0xSignature');
     });

packages/client/src/MWPClient.ts

@@ -16,7 +16,7 @@ const ACCOUNTS_KEY = 'accounts';
 const ACTIVE_CHAIN_STORAGE_KEY = 'activeChain';
 const AVAILABLE_CHAINS_STORAGE_KEY = 'availableChains';
 const WALLET_CAPABILITIES_STORAGE_KEY = 'walletCapabilities';
-import { CommunicatorInterface, getCommunicator } from './components/communicator';
+import * as Communicator from './components/communicator';
 import { LIB_VERSION } from './version';
 import {
   appendMWPResponsePath,
@@ -41,8 +41,6 @@ export class MWPClient {
   private readonly keyManager: KeyManager;
   private readonly storage: ScopedAsyncStorage;
 
-  private readonly communicator: CommunicatorInterface;
-
   private accounts: AddressString[];
   private chain: Chain;
 
@@ -57,8 +55,6 @@ export class MWPClient {
     this.keyManager = new KeyManager({ wallet: this.wallet });
     this.storage = new ScopedAsyncStorage(this.wallet.name, 'MWPClient');
 
-    this.communicator = getCommunicator(this.wallet);
-
     // default values
     this.accounts = [];
     this.chain = {
@@ -67,8 +63,7 @@ export class MWPClient {
 
     this.handshake = this.handshake.bind(this);
     this.request = this.request.bind(this);
-    this.createRequestMessage = this.createRequestMessage.bind(this);
-    this.decryptResponseMessage = this.decryptResponseMessage.bind(this);
+    this.reset = this.reset.bind(this);
   }
 
   private async initialize() {
@@ -96,8 +91,10 @@ export class MWPClient {
         params: this.metadata,
       },
     });
-    const response: RPCResponseMessage =
-      await this.communicator.postRequestAndWaitForResponse(handshakeMessage);
+    const response: RPCResponseMessage = await Communicator.postRequestToWallet(
+      handshakeMessage,
+      this.wallet
+    );
 
     // store peer's public key
     if ('failure' in response.content) throw response.content.failure;
@@ -219,7 +216,7 @@ export class MWPClient {
     );
     const message = await this.createRequestMessage({ encrypted });
 
-    return this.communicator.postRequestAndWaitForResponse(message);
+    return Communicator.postRequestToWallet(message, this.wallet);
   }
 
   private async createRequestMessage(
@@ -232,7 +229,7 @@ export class MWPClient {
       content,
       sdkVersion: LIB_VERSION,
       timestamp: new Date(),
-      ...(this.metadata.appDeeplinkUrl && { callbackUrl: this.metadata.appDeeplinkUrl }),
+      callbackUrl: this.metadata.appDeeplinkUrl,
     };
   }
 

packages/client/src/components/communicator/getCommunicator.test.ts

@@ -1,65 +1,62 @@
 import { handleResponse } from './handleResponse';
 import { WebBasedWalletCommunicator } from './webBased/Communicator';
 import { MWP_RESPONSE_PATH } from ':core/constants';
-import { Wallet } from ':core/wallet';
 
-jest.mock('./webBased/Communicator');
-jest.mock('expo-web-browser', () => ({
-  openBrowserAsync: jest.fn(),
-  WebBrowserPresentationStyle: {
-    FORM_SHEET: 'FORM_SHEET',
+jest.mock('./webBased/Communicator', () => ({
+  WebBasedWalletCommunicator: {
+    handleResponse: jest.fn(),
   },
-  dismissBrowser: jest.fn(),
 }));
 
 describe('handleResponse', () => {
-  const mockWebBasedWallet = { type: 'webBased', scheme: 'https://example.com' } as Wallet;
-  const mockNativeWallet = { type: 'native' } as Wallet;
-  const mockOtherWallet = { type: 'other' as any } as Wallet;
-
   beforeEach(() => {
     jest.clearAllMocks();
   });
 
-  test('returns false for non-MWP response URLs', () => {
-    const url = 'https://example.com/some-path';
-    expect(handleResponse(url, mockWebBasedWallet)).toBe(false);
+  it('should return false if the pathname does not include MWP_RESPONSE_PATH', () => {
+    const responseUrl = 'https://example.com/some-other-path';
+    const result = handleResponse(responseUrl);
+    expect(result).toBe(false);
+    expect(WebBasedWalletCommunicator.handleResponse).not.toHaveBeenCalled();
   });
 
-  test('handles web-based wallet response correctly', () => {
-    const url = `https://example.com/${MWP_RESPONSE_PATH}/some-params`;
-    const mockHandleResponse = jest.fn().mockReturnValue(true);
-    (WebBasedWalletCommunicator.getInstance as jest.Mock).mockReturnValue({
-      handleResponse: mockHandleResponse,
-    });
+  it('should return true if WebBasedWalletCommunicator handles the response successfully', () => {
+    const responseUrl = `https://example.com/${MWP_RESPONSE_PATH}/some-params`;
+    (WebBasedWalletCommunicator.handleResponse as jest.Mock).mockReturnValue(true);
 
-    const result = handleResponse(url, mockWebBasedWallet);
+    const result = handleResponse(responseUrl);
 
-    expect(WebBasedWalletCommunicator.getInstance).toHaveBeenCalledWith(mockWebBasedWallet.scheme);
-    expect(mockHandleResponse).toHaveBeenCalledWith(url);
     expect(result).toBe(true);
+    expect(WebBasedWalletCommunicator.handleResponse).toHaveBeenCalledWith(responseUrl);
   });
 
-  test('throws error for native wallet', () => {
-    const url = `https://example.com/${MWP_RESPONSE_PATH}/some-params`;
-    expect(() => handleResponse(url, mockNativeWallet)).toThrow('Native wallet not supported yet');
-  });
+  it('should return false if WebBasedWalletCommunicator does not handle the response', () => {
+    const responseUrl = `https://example.com/${MWP_RESPONSE_PATH}/some-params`;
+    (WebBasedWalletCommunicator.handleResponse as jest.Mock).mockReturnValue(false);
+
+    const result = handleResponse(responseUrl);
 
-  test('returns false for unsupported wallet types', () => {
-    const url = `https://example.com/${MWP_RESPONSE_PATH}/some-params`;
-    expect(handleResponse(url, mockOtherWallet)).toBe(false);
+    expect(result).toBe(false);
+    expect(WebBasedWalletCommunicator.handleResponse).toHaveBeenCalledWith(responseUrl);
   });
 
-  test('WebBasedWalletCommunicator.handleResponse returns false', () => {
-    const url = `https://example.com/${MWP_RESPONSE_PATH}/some-params`;
-    const mockHandleResponse = jest.fn().mockReturnValue(false);
-    (WebBasedWalletCommunicator.getInstance as jest.Mock).mockReturnValue({
-      handleResponse: mockHandleResponse,
+  it('should handle different URL formats correctly', () => {
+    const responseUrls = [
+      `https://example.com/${MWP_RESPONSE_PATH}`,
+      `https://example.com/${MWP_RESPONSE_PATH}/`,
+      `https://example.com/${MWP_RESPONSE_PATH}?param=value`,
+      `https://example.com/${MWP_RESPONSE_PATH}/?param=value`,
+    ];
+
+    responseUrls.forEach((url) => {
+      (WebBasedWalletCommunicator.handleResponse as jest.Mock).mockReturnValue(true);
+      expect(handleResponse(url)).toBe(true);
+      expect(WebBasedWalletCommunicator.handleResponse).toHaveBeenCalledWith(url);
     });
+  });
 
-    const result = handleResponse(url, mockWebBasedWallet);
-
-    expect(mockHandleResponse).toHaveBeenCalledWith(url);
-    expect(result).toBe(false);
+  it('should throw an error for invalid URLs', () => {
+    const invalidUrl = 'not-a-valid-url';
+    expect(() => handleResponse(invalidUrl)).toThrow('Invalid URL');
   });
 });

packages/client/src/components/communicator/getCommunicator.ts

@@ -1,29 +1,24 @@
 import { WebBasedWalletCommunicator } from './webBased/Communicator';
 import { MWP_RESPONSE_PATH } from ':core/constants';
-import { Wallet } from ':core/wallet';
 
 /**
  * Handles the response from a deeplink.
  *
  * @param responseUrl - The URL of the response.
- * @param wallet - The wallet object.
  * @returns A boolean indicating whether the response was handled successfully.
  */
-export function handleResponse(responseUrl: string, wallet: Wallet): boolean {
+export function handleResponse(responseUrl: string): boolean {
   const pathname = new URL(responseUrl).pathname;
 
   if (!pathname.includes(MWP_RESPONSE_PATH)) {
     return false;
   }
 
-  if (wallet.type === 'webBased') {
-    const communicator = WebBasedWalletCommunicator.getInstance(wallet.scheme);
-    return communicator.handleResponse(responseUrl);
+  if (WebBasedWalletCommunicator.handleResponse(responseUrl)) {
+    return true;
   }
 
-  if (wallet.type === 'native') {
-    throw new Error('Native wallet not supported yet');
-  }
+  // NativeWalletCommunicator.handleResponse
 
   return false;
 }

packages/client/src/components/communicator/handleResponse.test.ts

@@ -1,2 +1,2 @@
-export * from './getCommunicator';
 export * from './handleResponse';
+export * from './postRequestToWallet';