feat: Bluetooth components for onboarding

packages/blockchain-link-types/src/constants/errors.ts

@@ -1,6 +1,7 @@
 const PREFIX = 'blockchain_link/';
 
 const ERROR: { [key: string]: string | undefined } = {
+    connect: undefined,
     worker_not_found: 'Worker not found',
     worker_invalid: 'Invalid worker object',
     worker_timeout: 'Worker timeout',
@@ -19,23 +20,28 @@ export class CustomError extends Error {
 
     message = '';
 
-    constructor(code: string, message = '') {
+    constructor(codeOrMessage: string, message = '') {
         // test reports that super is not covered, TODO: investigate more
         super(message);
 
         this.message = message;
 
-        if (typeof code === 'string') {
-            const c =
-                code.indexOf(PREFIX) === 0 ? code.substring(PREFIX.length, code.length) : code;
-            this.code = `${PREFIX}${c}`;
-            const msg = ERROR[c];
-            if (typeof msg === 'string') {
-                if (this.message === '') {
-                    this.message = msg;
-                } else if (message.indexOf('+') === 0) {
-                    this.message = `${msg} ${message.substring(1)}`;
+        if (typeof codeOrMessage === 'string') {
+            const isPrefixed = codeOrMessage.indexOf(PREFIX) === 0;
+            const code = isPrefixed ? codeOrMessage.substring(PREFIX.length) : codeOrMessage;
+            const knownCode = Object.keys(ERROR).includes(code);
+            if (isPrefixed || knownCode) {
+                this.code = `${PREFIX}${code}`;
+                const codeMessage = ERROR[code];
+                if (codeMessage) {
+                    if (this.message === '') {
+                        this.message = codeMessage;
+                    } else if (message.indexOf('+') === 0) {
+                        this.message = `${codeMessage} ${message.substring(1)}`;
+                    }
                 }
+            } else if (this.message === '') {
+                this.message = code;
             }
         }
 

packages/blockchain-link/jest.config.unit.js

@@ -13,7 +13,6 @@ module.exports = {
         ...testPathIgnorePatterns,
         'src/types',
         'src/ui',
-        'src/utils/ws.ts',
         'fixtures',
         'unit/worker/index.ts',
     ],

packages/blockchain-link/package.json

@@ -26,25 +26,21 @@
     ],
     "main": "src/index.ts",
     "browser": {
-        "socks-proxy-agent": "./src/utils/socks-proxy-agent.ts",
-        "ws": "./src/utils/ws.ts"
+        "socks-proxy-agent": "./src/utils/socks-proxy-agent.ts"
     },
     "react-native": {
         "__comment__": "Hotfix for issue where RN metro bundler resolve relatives paths wrong",
-        "ws": "@trezor/blockchain-link/src/utils/ws-native.ts",
         "socks-proxy-agent": "@trezor/blockchain-link/src/utils/socks-proxy-agent.ts"
     },
     "publishConfig": {
         "main": "./lib/index.js",
         "types": "lib/index.d.ts",
         "typings": "lib/index.d.ts",
         "browser": {
-            "socks-proxy-agent": "./lib/utils/socks-proxy-agent.js",
-            "ws": "./lib/utils/ws.js"
+            "socks-proxy-agent": "./lib/utils/socks-proxy-agent.js"
         },
         "react-native": {
             "__comment__": "Hotfix for issue where RN metro bundler resolve relatives paths wrong",
-            "ws": "@trezor/blockchain-link/lib/utils/ws-native.js",
             "socks-proxy-agent": "@trezor/blockchain-link/lib/utils/socks-proxy-agent.js"
         }
     },
@@ -83,11 +79,11 @@
         "@trezor/env-utils": "workspace:*",
         "@trezor/utils": "workspace:*",
         "@trezor/utxo-lib": "workspace:*",
+        "@trezor/websocket-client": "workspace:*",
         "@types/web": "^0.0.174",
         "events": "^3.3.0",
         "ripple-lib": "^1.10.1",
-        "socks-proxy-agent": "8.0.4",
-        "ws": "^8.18.0"
+        "socks-proxy-agent": "8.0.4"
     },
     "peerDependencies": {
         "tslib": "^2.6.2"

packages/blockchain-link/src/workers/baseWebsocket.ts

@@ -1,115 +1,27 @@
-import WebSocket from 'ws';
-
-import { createDeferred, createDeferredManager, TypedEmitter } from '@trezor/utils';
 import { CustomError } from '@trezor/blockchain-link-types/src/constants/errors';
-import { TimerId } from '@trezor/type-utils';
+import { WebsocketClient, WebsocketRequest, WebsocketResponse } from '@trezor/websocket-client';
 
 interface Subscription<T> {
     id: string;
     type: T;
     callback: (result: any) => void;
 }
 
-interface Options {
-    url: string;
-    timeout?: number;
-    pingTimeout?: number;
-    connectionTimeout?: number;
-    keepAlive?: boolean;
-    agent?: WebSocket.ClientOptions['agent'];
-    headers?: WebSocket.ClientOptions['headers'];
-    onSending?: (message: Record<string, any>) => void;
-}
-
-const DEFAULT_TIMEOUT = 20 * 1000;
-const DEFAULT_PING_TIMEOUT = 50 * 1000;
-
-type EventMap = { [event: string]: any };
-
-type WsEvents = {
-    error: string;
-    disconnected: undefined;
-};
-
-export abstract class BaseWebsocket<T extends EventMap> extends TypedEmitter<T & WsEvents> {
-    readonly options: Options;
-
-    private readonly messages;
+export abstract class BaseWebsocket<T extends Record<string, any>> extends WebsocketClient<T> {
     private readonly subscriptions: Subscription<keyof T>[] = [];
-    private readonly emitter: TypedEmitter<WsEvents> = this;
-
-    private ws?: WebSocket;
-    private pingTimeout?: TimerId;
-    private connectPromise?: Promise<void>;
-
-    protected abstract ping(): Promise<unknown>;
-
-    protected abstract createWebsocket(): WebSocket;
-
-    constructor(options: Options) {
-        super();
-        this.options = options;
-        this.messages = createDeferredManager({
-            timeout: this.options.timeout || DEFAULT_TIMEOUT,
-            onTimeout: this.onTimeout.bind(this),
-        });
-    }
-
-    private setPingTimeout() {
-        if (this.pingTimeout) {
-            clearTimeout(this.pingTimeout);
-        }
-        this.pingTimeout = setTimeout(
-            this.onPing.bind(this),
-            this.options.pingTimeout || DEFAULT_PING_TIMEOUT,
-        );
-    }
 
-    private onTimeout() {
-        const { ws } = this;
-        if (!ws) return;
-        this.messages.rejectAll(new CustomError('websocket_timeout'));
-        ws.close();
-    }
-
-    private async onPing() {
+    async onPing() {
         // make sure that connection is alive if there are subscriptions
-        if (this.ws && this.isConnected()) {
-            try {
-                if (this.subscriptions.length > 0 || this.options.keepAlive) {
-                    await this.ping();
-                } else {
-                    this.ws.close();
-                }
-            } catch {
-                // empty
-            }
+        if (this.subscriptions.length > 0 || this.options.keepAlive) {
+            await this.ping();
+        } else {
+            this.disconnect();
         }
     }
 
-    private onError() {
-        this.onClose();
-    }
-
-    protected sendMessage(message: Record<string, any>) {
-        const { ws } = this;
-        if (!ws) throw new CustomError('websocket_not_initialized');
-        const { promiseId, promise } = this.messages.create();
-
-        const req = { id: promiseId.toString(), ...message };
-
-        this.setPingTimeout();
-
-        this.options.onSending?.(message);
-
-        ws.send(JSON.stringify(req));
-
-        return promise;
-    }
-
-    protected onMessage(message: string) {
+    protected onMessage(message: WebsocketResponse) {
         try {
-            const resp = JSON.parse(message);
+            const resp = JSON.parse(message.toString());
             const { id, data } = resp;
 
             const messageSettled = data.error
@@ -128,8 +40,12 @@ export abstract class BaseWebsocket<T extends EventMap> extends TypedEmitter<T &
         } catch {
             // empty
         }
+    }
 
-        this.setPingTimeout();
+    protected sendMessage(message: WebsocketRequest) {
+        return super.sendMessage(message).catch(error => {
+            throw new CustomError(error.message);
+        });
     }
 
     protected addSubscription<E extends keyof T>(type: E, callback: (result: T[E]) => void) {
@@ -146,95 +62,4 @@ export abstract class BaseWebsocket<T extends EventMap> extends TypedEmitter<T &
 
         return index;
     }
-
-    async connect() {
-        // if connecting already, just return the promise
-        if (this.connectPromise) {
-            return this.connectPromise;
-        }
-
-        if (this.ws?.readyState === WebSocket.CLOSING) {
-            await new Promise<void>(resolve => this.emitter.once('disconnected', resolve));
-        }
-
-        // create deferred promise
-        const dfd = createDeferred(-1);
-        this.connectPromise = dfd.promise;
-
-        const ws = this.createWebsocket();
-
-        // set connection timeout before WebSocket initialization
-        const connectionTimeout = setTimeout(
-            () => {
-                ws.emit('error', new CustomError('websocket_timeout'));
-                try {
-                    ws.once('error', () => {}); // hack; ws throws uncaughtably when there's no error listener
-                    ws.close();
-                } catch {
-                    // empty
-                }
-            },
-            this.options.connectionTimeout || this.options.timeout || DEFAULT_TIMEOUT,
-        );
-
-        ws.once('error', error => {
-            clearTimeout(connectionTimeout);
-            this.onClose();
-            dfd.reject(new CustomError('websocket_runtime_error', error.message));
-        });
-        ws.on('open', () => {
-            clearTimeout(connectionTimeout);
-            this.init();
-            dfd.resolve();
-        });
-
-        this.ws = ws;
-
-        // wait for onopen event
-        return dfd.promise.finally(() => {
-            this.connectPromise = undefined;
-        });
-    }
-
-    private init() {
-        const { ws } = this;
-        if (!ws || !this.isConnected()) {
-            throw Error('Websocket init cannot be called');
-        }
-
-        // remove previous listeners and add new listeners
-        ws.removeAllListeners();
-        ws.on('error', this.onError.bind(this));
-        ws.on('message', this.onMessage.bind(this));
-        ws.on('close', () => {
-            this.onClose();
-        });
-    }
-
-    disconnect() {
-        this.emitter.emit('disconnected');
-        this.ws?.close();
-    }
-
-    isConnected() {
-        return this.ws?.readyState === WebSocket.OPEN;
-    }
-
-    private onClose() {
-        if (this.pingTimeout) {
-            clearTimeout(this.pingTimeout);
-        }
-
-        this.disconnect();
-
-        this.ws?.removeAllListeners();
-        this.messages.rejectAll(
-            new CustomError('websocket_runtime_error', 'Websocket closed unexpectedly'),
-        );
-    }
-
-    dispose() {
-        this.removeAllListeners();
-        this.onClose();
-    }
 }

packages/blockchain-link/src/workers/blockbook/websocket.ts

@@ -1,5 +1,3 @@
-import WebSocket from 'ws';
-
 import { CustomError } from '@trezor/blockchain-link-types/src/constants/errors';
 import type {
     BlockNotification,
@@ -48,9 +46,8 @@ export class BlockbookAPI extends BaseWebsocket<BlockbookEvents> {
             url += suffix;
         }
 
-        // initialize connection,
-        // options are not used in web builds (see ./src/utils/ws)
-        return new WebSocket(url, {
+        return this.initWebsocket({
+            url,
             agent: this.options.agent,
             headers: {
                 Origin: 'https://node.trezor.io',

packages/blockchain-link/src/workers/blockfrost/websocket.ts

@@ -1,5 +1,3 @@
-import WebSocket from 'ws';
-
 import type {
     Send,
     BlockContent,
@@ -23,8 +21,8 @@ export class BlockfrostAPI extends BaseWebsocket<BlockfrostEvents> {
     protected createWebsocket() {
         const { url } = this.options;
 
-        // options are not used in web builds (see ./src/utils/ws)
-        return new WebSocket(url, {
+        return this.initWebsocket({
+            url,
             agent: this.options.agent,
             headers: {
                 Origin: 'https://node.trezor.io',

packages/blockchain-link/tests/unit/errors.test.ts

@@ -19,16 +19,16 @@ describe('Custom errors', () => {
         expect(error.message).toBe('Worker not found');
     });
 
-    it('Error with custom code and custom message', () => {
+    it('Error with custom prefixed code and custom message', () => {
         const error = new CustomError('blockchain_link/custom', 'Custom message');
         expect(error.code).toBe('blockchain_link/custom');
         expect(error.message).toBe('Custom message');
     });
 
-    it('Error with custom code and without message', () => {
+    it('Error with custom code as message', () => {
         const error = new CustomError('custom');
-        expect(error.code).toBe('blockchain_link/custom');
-        expect(error.message).toBe('Message not set');
+        expect(error.code).toBe(undefined);
+        expect(error.message).toBe('custom');
     });
 
     it('Error without code and with custom message', () => {

packages/blockchain-link/tsconfig.json

@@ -12,6 +12,7 @@
         { "path": "../env-utils" },
         { "path": "../utils" },
         { "path": "../utxo-lib" },
+        { "path": "../websocket-client" },
         { "path": "../e2e-utils" },
         { "path": "../eslint" },
         { "path": "../type-utils" }