@ledgerhq/react-native-hw-transport-ble 6.34.0 → 6.34.1-next.0

package/lib-es/BleTransport.js

@@ -1,13 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var _a;
 import { v4 as uuid } from "uuid";
 import Transport from "@ledgerhq/hw-transport";
 // ---------------------------------------------------------------------------------------------
@@ -88,246 +78,264 @@ const clearDisconnectTimeout = (deviceId, context) => {
  *  - rxjsScheduler: dependency injected RxJS scheduler to control time. Default AsyncScheduler.
  * @returns A BleTransport instance
  */
-function open(deviceOrId_1, needsReconnect_1, timeoutMs_1, context_1) {
-    return __awaiter(this, arguments, void 0, function* (deviceOrId, needsReconnect, timeoutMs, context, { rxjsScheduler } = {}) {
-        const tracer = new LocalTracer(LOG_TYPE, context);
-        let device;
-        tracer.trace(`Opening ${deviceOrId}`, { needsReconnect });
-        if (typeof deviceOrId === "string") {
-            if (transportsCache[deviceOrId]) {
-                tracer.trace(`Transport in cache, using it`);
-                clearDisconnectTimeout(deviceOrId);
-                // The cached transport probably has an older trace/log context
-                transportsCache[deviceOrId].setTraceContext(context);
-                return transportsCache[deviceOrId];
-            }
-            tracer.trace(`Trying to open device: ${deviceOrId}`);
-            yield BlePlxManager.waitOn();
-            // Returns a list of known devices by their identifiers
-            device = yield BlePlxManager.getKnownDevice(deviceOrId);
-            if (!device) {
-                tracer.trace(`Found already known device with given id`, { deviceOrId });
-                // Returns a list of the peripherals currently connected to the system
-                // which have discovered services, connected to system doesn't mean
-                // connected to our app, we check that below.
-                const connectedDevices = yield BlePlxManager.getConnectedDevices();
-                const connectedDevicesFiltered = connectedDevices.filter(d => d.id === deviceOrId);
-                tracer.trace(`No known device with given id. Found ${connectedDevicesFiltered.length} devices from already connected devices`, { deviceOrId });
-                [device] = connectedDevicesFiltered;
-            }
-            if (!device) {
-                // We still don't have a device, so we attempt to connect to it.
-                tracer.trace(`No known nor connected devices with given id. Trying to connect to device`, {
-                    deviceOrId,
-                    timeoutMs,
-                });
-                // Nb ConnectionOptions dropped since it's not used internally by ble-plx.
-                try {
-                    device = yield BlePlxManager.connect(deviceOrId, Object.assign(Object.assign({}, connectOptions), { timeout: timeoutMs }));
-                }
-                catch (e) {
-                    tracer.trace(`Error code: ${e.errorCode}`);
-                    if (e.errorCode === BleErrorCode.DeviceMTUChangeFailed) {
-                        // If the MTU update did not work, we try to connect without requesting for a specific MTU
-                        connectOptions = {};
-                        device = yield BlePlxManager.connect(deviceOrId, { timeout: timeoutMs });
-                    }
-                    else {
-                        throw e;
-                    }
-                }
-            }
-            if (!device) {
-                throw new CantOpenDevice();
-            }
+async function open(deviceOrId, needsReconnect, timeoutMs, context, { rxjsScheduler } = {}) {
+    const tracer = new LocalTracer(LOG_TYPE, context);
+    let device;
+    tracer.trace(`Opening ${deviceOrId}`, { needsReconnect });
+    if (typeof deviceOrId === "string") {
+        if (transportsCache[deviceOrId]) {
+            tracer.trace(`Transport in cache, using it`);
+            clearDisconnectTimeout(deviceOrId);
+            // The cached transport probably has an older trace/log context
+            transportsCache[deviceOrId].setTraceContext(context);
+            return transportsCache[deviceOrId];
         }
-        else {
-            // It was already a Device
-            device = deviceOrId;
+        tracer.trace(`Trying to open device: ${deviceOrId}`);
+        await BlePlxManager.waitOn();
+        // Returns a list of known devices by their identifiers
+        device = await BlePlxManager.getKnownDevice(deviceOrId);
+        if (!device) {
+            tracer.trace(`Found already known device with given id`, { deviceOrId });
+            // Returns a list of the peripherals currently connected to the system
+            // which have discovered services, connected to system doesn't mean
+            // connected to our app, we check that below.
+            const connectedDevices = await BlePlxManager.getConnectedDevices();
+            const connectedDevicesFiltered = connectedDevices.filter(d => d.id === deviceOrId);
+            tracer.trace(`No known device with given id. Found ${connectedDevicesFiltered.length} devices from already connected devices`, { deviceOrId });
+            [device] = connectedDevicesFiltered;
         }
-        if (!(yield device.isConnected())) {
-            tracer.trace(`Device found but not connected. connecting...`, { timeoutMs, connectOptions });
+        if (!device) {
+            // We still don't have a device, so we attempt to connect to it.
+            tracer.trace(`No known nor connected devices with given id. Trying to connect to device`, {
+                deviceOrId,
+                timeoutMs,
+            });
+            // Nb ConnectionOptions dropped since it's not used internally by ble-plx.
             try {
-                yield device.connect(Object.assign(Object.assign({}, connectOptions), { timeout: timeoutMs }));
+                device = await BlePlxManager.connect(deviceOrId, {
+                    ...connectOptions,
+                    timeout: timeoutMs,
+                });
             }
-            catch (error) {
-                tracer.trace(`Connect error`, { error });
-                if (error.errorCode === BleErrorCode.DeviceMTUChangeFailed) {
-                    tracer.trace(`Device mtu=${device.mtu}, reconnecting`);
+            catch (e) {
+                tracer.trace(`Error code: ${e.errorCode}`);
+                if (e.errorCode === BleErrorCode.DeviceMTUChangeFailed) {
+                    // If the MTU update did not work, we try to connect without requesting for a specific MTU
                     connectOptions = {};
-                    yield device.connect();
-                }
-                else if (error.iosErrorCode === 14 || error.reason === "Peer removed pairing information") {
-                    tracer.trace(`iOS broken pairing`, {
-                        device,
-                        bluetoothInfoCache: bluetoothInfoCache[device.id],
-                    });
-                    const { deviceModel } = bluetoothInfoCache[device.id] || {};
-                    const { productName } = deviceModel || {};
-                    throw new PeerRemovedPairing(undefined, {
-                        deviceName: device.name,
-                        productName,
-                    });
-                }
-                // This case should not happen, but recording logs to be warned if we see it in production
-                else if (error.errorCode === BleErrorCode.DeviceAlreadyConnected) {
-                    tracer.trace(`Device already connected, while it was not supposed to`, {
-                        error,
-                    });
-                    throw remapError(error);
+                    device = await BlePlxManager.connect(deviceOrId, { timeout: timeoutMs });
                 }
                 else {
-                    throw remapError(error);
+                    throw e;
                 }
             }
         }
-        tracer.trace(`Device is connected now, getting services and characteristics`);
-        yield device.discoverAllServicesAndCharacteristics();
-        let res = retrieveInfos(device);
-        let characteristics;
-        if (!res) {
-            for (const uuid of getBluetoothServiceUuids()) {
-                try {
-                    characteristics = yield device.characteristicsForService(uuid);
-                    res = getInfosForServiceUuid(uuid);
-                    break;
-                }
-                catch (e) {
-                    // we attempt to connect to service
-                }
-            }
+        if (!device) {
+            throw new CantOpenDevice();
         }
-        if (!res) {
-            tracer.trace(`Service not found`);
-            throw new TransportError("service not found", "BLEServiceNotFound");
-        }
-        const { deviceModel, serviceUuid, writeUuid, writeCmdUuid, notifyUuid } = res;
-        if (!characteristics) {
-            characteristics = yield device.characteristicsForService(serviceUuid);
-        }
-        if (!characteristics) {
-            tracer.trace(`Characteristics not found`);
-            throw new TransportError("service not found", "BLEServiceNotFound");
+    }
+    else {
+        // It was already a Device
+        device = deviceOrId;
+    }
+    if (!(await device.isConnected())) {
+        tracer.trace(`Device found but not connected. connecting...`, { timeoutMs, connectOptions });
+        try {
+            await device.connect({ ...connectOptions, timeout: timeoutMs });
         }
-        let writableWithResponseCharacteristic;
-        let writableWithoutResponseCharacteristic;
-        // A characteristic that can monitor value changes
-        let notifiableCharacteristic;
-        for (const c of characteristics) {
-            if (c.uuid === writeUuid) {
-                writableWithResponseCharacteristic = c;
+        catch (error) {
+            tracer.trace(`Connect error`, { error });
+            if (error.errorCode === BleErrorCode.DeviceMTUChangeFailed) {
+                tracer.trace(`Device mtu=${device.mtu}, reconnecting`);
+                connectOptions = {};
+                await device.connect();
+            }
+            else if (error.iosErrorCode === 14 || error.reason === "Peer removed pairing information") {
+                tracer.trace(`iOS broken pairing`, {
+                    device,
+                    bluetoothInfoCache: bluetoothInfoCache[device.id],
+                });
+                const { deviceModel } = bluetoothInfoCache[device.id] || {};
+                const { productName } = deviceModel || {};
+                throw new PeerRemovedPairing(undefined, {
+                    deviceName: device.name,
+                    productName,
+                });
             }
-            else if (c.uuid === writeCmdUuid) {
-                writableWithoutResponseCharacteristic = c;
+            // This case should not happen, but recording logs to be warned if we see it in production
+            else if (error.errorCode === BleErrorCode.DeviceAlreadyConnected) {
+                tracer.trace(`Device already connected, while it was not supposed to`, {
+                    error,
+                });
+                throw remapError(error);
             }
-            else if (c.uuid === notifyUuid) {
-                notifiableCharacteristic = c;
+            else {
+                throw remapError(error);
             }
         }
-        if (!writableWithResponseCharacteristic) {
-            throw new TransportError("write characteristic not found", "BLECharacteristicNotFound");
-        }
-        if (!notifiableCharacteristic) {
-            throw new TransportError("notify characteristic not found", "BLECharacteristicNotFound");
+    }
+    tracer.trace(`Device is connected now, getting services and characteristics`);
+    await device.discoverAllServicesAndCharacteristics();
+    let res = retrieveInfos(device);
+    let characteristics;
+    if (!res) {
+        for (const uuid of getBluetoothServiceUuids()) {
+            try {
+                characteristics = await device.characteristicsForService(uuid);
+                res = getInfosForServiceUuid(uuid);
+                break;
+            }
+            catch (e) {
+                // we attempt to connect to service
+            }
         }
-        if (!writableWithResponseCharacteristic.isWritableWithResponse) {
-            throw new TransportError("The writable-with-response characteristic is not writable with response", "BLECharacteristicInvalid");
+    }
+    if (!res) {
+        tracer.trace(`Service not found`);
+        throw new TransportError("service not found", "BLEServiceNotFound");
+    }
+    const { deviceModel, serviceUuid, writeUuid, writeCmdUuid, notifyUuid } = res;
+    if (!characteristics) {
+        characteristics = await device.characteristicsForService(serviceUuid);
+    }
+    if (!characteristics) {
+        tracer.trace(`Characteristics not found`);
+        throw new TransportError("service not found", "BLEServiceNotFound");
+    }
+    let writableWithResponseCharacteristic;
+    let writableWithoutResponseCharacteristic;
+    // A characteristic that can monitor value changes
+    let notifiableCharacteristic;
+    for (const c of characteristics) {
+        if (c.uuid === writeUuid) {
+            writableWithResponseCharacteristic = c;
         }
-        if (!notifiableCharacteristic.isNotifiable) {
-            throw new TransportError("notify characteristic not notifiable", "BLECharacteristicInvalid");
+        else if (c.uuid === writeCmdUuid) {
+            writableWithoutResponseCharacteristic = c;
         }
-        if (writableWithoutResponseCharacteristic) {
-            if (!writableWithoutResponseCharacteristic.isWritableWithoutResponse) {
-                throw new TransportError("The writable-without-response characteristic is not writable without response", "BLECharacteristicInvalid");
-            }
+        else if (c.uuid === notifyUuid) {
+            notifiableCharacteristic = c;
         }
-        tracer.trace(`device.mtu=${device.mtu}`);
-        // Inits the observable that will emit received data from the device via BLE
-        const notifyObservable = monitorCharacteristic(notifiableCharacteristic, context).pipe(catchError(e => {
-            // LL-9033 fw 2.0.2 introduced this case, we silence the inner unhandled error.
-            // It will be handled when negotiating the MTU in `inferMTU` but will be ignored in other cases.
-            const msg = String(e);
-            return msg.includes("notify change failed")
-                ? of(new PairingFailed(msg))
-                : throwError(() => e);
-        }), tap(value => {
-            if (value instanceof PairingFailed)
-                return;
-            trace({ type: "ble-frame", message: `<= ${value.toString("hex")}`, context });
-        }), 
-        // Returns a new Observable that multicasts (shares) the original Observable.
-        // As long as there is at least one Subscriber this Observable will be subscribed and emitting data.
-        share());
-        // Keeps the input from the device observable alive (multicast observable)
-        const notif = notifyObservable.subscribe();
-        const transport = new BleTransport(device, writableWithResponseCharacteristic, writableWithoutResponseCharacteristic, notifyObservable, deviceModel, {
-            context,
-            rxjsScheduler,
-        });
-        tracer.trace(`New BleTransport created`);
-        // Keeping it as a comment for now but if no new bluetooth issues occur, we will be able to remove it
-        // await transport.requestConnectionPriority("High");
-        // eslint-disable-next-line prefer-const
-        let disconnectedSub;
-        // Callbacks on `react-native-ble-plx` notifying the device has been disconnected
-        const onDisconnect = (error) => {
-            transport.isConnected = false;
-            transport.notYetDisconnected = false;
-            notif.unsubscribe();
-            disconnectedSub === null || disconnectedSub === void 0 ? void 0 : disconnectedSub.remove();
-            clearDisconnectTimeout(transport.id);
-            delete transportsCache[transport.id];
-            tracer.trace(`On device disconnected callback: cleared cached transport for ${transport.id}, emitting Transport event "disconnect. Error: ${error}"`, { reason: error });
-            transport.emit("disconnect", error);
-        };
-        // eslint-disable-next-line require-atomic-updates
-        transportsCache[transport.id] = transport;
-        const beforeMTUTime = Date.now();
-        disconnectedSub = device.onDisconnected(e => {
-            if (!transport.notYetDisconnected)
-                return;
-            onDisconnect(e);
-        });
-        try {
-            yield transport.inferMTU();
+    }
+    if (!writableWithResponseCharacteristic) {
+        throw new TransportError("write characteristic not found", "BLECharacteristicNotFound");
+    }
+    if (!notifiableCharacteristic) {
+        throw new TransportError("notify characteristic not found", "BLECharacteristicNotFound");
+    }
+    if (!writableWithResponseCharacteristic.isWritableWithResponse) {
+        throw new TransportError("The writable-with-response characteristic is not writable with response", "BLECharacteristicInvalid");
+    }
+    if (!notifiableCharacteristic.isNotifiable) {
+        throw new TransportError("notify characteristic not notifiable", "BLECharacteristicInvalid");
+    }
+    if (writableWithoutResponseCharacteristic) {
+        if (!writableWithoutResponseCharacteristic.isWritableWithoutResponse) {
+            throw new TransportError("The writable-without-response characteristic is not writable without response", "BLECharacteristicInvalid");
         }
-        finally {
-            const afterMTUTime = Date.now();
-            if (reconnectionConfig) {
-                // Refer to ledgerjs archived repo issue #279
-                // All HW .v1 LNX have a bug that prevents us from communicating with the device right after pairing.
-                // When we connect for the first time we issue a disconnect and reconnect, this guarantees that we are
-                // in a good state. This is avoidable in some key scenarios ↓
-                if (afterMTUTime - beforeMTUTime < reconnectionConfig.pairingThreshold) {
-                    needsReconnect = false;
-                }
-                else if (deviceModel.id === DeviceModelId.stax) {
-                    tracer.trace(`Skipping "needsReconnect" strategy for Stax`);
-                    needsReconnect = false;
-                }
-                if (needsReconnect) {
-                    tracer.trace(`Device needs reconnection. Triggering a disconnect`);
-                    yield BleTransport.disconnectDevice(transport.id);
-                    yield delay(reconnectionConfig.delayAfterFirstPairing);
-                }
+    }
+    tracer.trace(`device.mtu=${device.mtu}`);
+    // Inits the observable that will emit received data from the device via BLE
+    const notifyObservable = monitorCharacteristic(notifiableCharacteristic, context).pipe(catchError(e => {
+        // LL-9033 fw 2.0.2 introduced this case, we silence the inner unhandled error.
+        // It will be handled when negotiating the MTU in `inferMTU` but will be ignored in other cases.
+        const msg = String(e);
+        return msg.includes("notify change failed")
+            ? of(new PairingFailed(msg))
+            : throwError(() => e);
+    }), tap(value => {
+        if (value instanceof PairingFailed)
+            return;
+        trace({ type: "ble-frame", message: `<= ${value.toString("hex")}`, context });
+    }), 
+    // Returns a new Observable that multicasts (shares) the original Observable.
+    // As long as there is at least one Subscriber this Observable will be subscribed and emitting data.
+    share());
+    // Keeps the input from the device observable alive (multicast observable)
+    const notif = notifyObservable.subscribe();
+    const transport = new BleTransport(device, writableWithResponseCharacteristic, writableWithoutResponseCharacteristic, notifyObservable, deviceModel, {
+        context,
+        rxjsScheduler,
+    });
+    tracer.trace(`New BleTransport created`);
+    // Keeping it as a comment for now but if no new bluetooth issues occur, we will be able to remove it
+    // await transport.requestConnectionPriority("High");
+    // eslint-disable-next-line prefer-const
+    let disconnectedSub;
+    // Callbacks on `react-native-ble-plx` notifying the device has been disconnected
+    const onDisconnect = (error) => {
+        transport.isConnected = false;
+        transport.notYetDisconnected = false;
+        notif.unsubscribe();
+        disconnectedSub?.remove();
+        clearDisconnectTimeout(transport.id);
+        delete transportsCache[transport.id];
+        tracer.trace(`On device disconnected callback: cleared cached transport for ${transport.id}, emitting Transport event "disconnect. Error: ${error}"`, { reason: error });
+        transport.emit("disconnect", error);
+    };
+    // eslint-disable-next-line require-atomic-updates
+    transportsCache[transport.id] = transport;
+    const beforeMTUTime = Date.now();
+    disconnectedSub = device.onDisconnected(e => {
+        if (!transport.notYetDisconnected)
+            return;
+        onDisconnect(e);
+    });
+    try {
+        await transport.inferMTU();
+    }
+    finally {
+        const afterMTUTime = Date.now();
+        if (reconnectionConfig) {
+            // Refer to ledgerjs archived repo issue #279
+            // All HW .v1 LNX have a bug that prevents us from communicating with the device right after pairing.
+            // When we connect for the first time we issue a disconnect and reconnect, this guarantees that we are
+            // in a good state. This is avoidable in some key scenarios ↓
+            if (afterMTUTime - beforeMTUTime < reconnectionConfig.pairingThreshold) {
+                needsReconnect = false;
             }
-            else {
+            else if (deviceModel.id === DeviceModelId.stax) {
+                tracer.trace(`Skipping "needsReconnect" strategy for Stax`);
                 needsReconnect = false;
             }
+            if (needsReconnect) {
+                tracer.trace(`Device needs reconnection. Triggering a disconnect`);
+                await BleTransport.disconnectDevice(transport.id);
+                await delay(reconnectionConfig.delayAfterFirstPairing);
+            }
         }
-        if (needsReconnect) {
-            tracer.trace(`Reconnecting`);
-            return open(device, false, timeoutMs, context);
+        else {
+            needsReconnect = false;
         }
-        return transport;
-    });
+    }
+    if (needsReconnect) {
+        tracer.trace(`Reconnecting`);
+        return open(device, false, timeoutMs, context);
+    }
+    return transport;
 }
 /**
  * react-native bluetooth BLE implementation
  * @example
  * import BleTransport from "@ledgerhq/react-native-hw-transport-ble";
  */
-class BleTransport extends Transport {
+export default class BleTransport extends Transport {
+    static disconnectTimeoutMs = 5000;
+    /**
+     *
+     */
+    static isSupported = () => Promise.resolve(typeof BlePlxManager === "function");
+    /**
+     *
+     */
+    static list = () => {
+        throw new Error("not implemented");
+    };
+    // /**
+    //  * Exposed method from the ble-plx library
+    //  * Sets new log level for native module's logging mechanism.
+    //  * @param string logLevel New log level to be set.
+    //  */
+    static setLogLevel = BlePlxManager.setLogLevel;
     /**
      * Listen to state changes on the BlePlxManagerInstance and notify the
      * specified observer.
@@ -346,6 +354,14 @@ class BleTransport extends Transport {
             unsubscribe: () => { },
         };
     }
+    static safeRemove = (sub, tracer) => {
+        try {
+            sub.remove();
+        }
+        catch (error) {
+            tracer.trace("Error removing state subscription", { error });
+        }
+    };
     /**
      * Scan for bluetooth Ledger devices
      * @param observer Device is partial in order to avoid the live-common/this dep
@@ -356,10 +372,10 @@ class BleTransport extends Transport {
         const tracer = new LocalTracer(LOG_TYPE, context);
         tracer.trace("Listening for devices ...");
         let unsubscribed;
-        const stateSub = BlePlxManager.onStateChange((state) => __awaiter(this, void 0, void 0, function* () {
+        const stateSub = BlePlxManager.onStateChange(async (state) => {
             if (state === "PoweredOn") {
-                _a.safeRemove(stateSub, tracer);
-                const devices = yield BlePlxManager.getConnectedDevices().catch(err => {
+                BleTransport.safeRemove(stateSub, tracer);
+                const devices = await BlePlxManager.getConnectedDevices().catch(err => {
                     // Handle possible connection errors
                     tracer.trace("Error while fetching connected devices", { err });
                     return [];
@@ -369,7 +385,7 @@ class BleTransport extends Transport {
                 if (devices.length) {
                     tracer.trace("Disconnecting from all devices", { deviceCount: devices.length });
                     try {
-                        yield Promise.all(devices.map(d => _a.disconnectDevice(d.id)));
+                        await Promise.all(devices.map(d => BleTransport.disconnectDevice(d.id)));
                     }
                     catch (error) {
                         tracer.trace("Error disconnecting some devices", { error });
@@ -377,7 +393,7 @@ class BleTransport extends Transport {
                 }
                 if (unsubscribed)
                     return;
-                yield BlePlxManager.startScan((bleError, scannedDevice) => {
+                await BlePlxManager.startScan((bleError, scannedDevice) => {
                     if (bleError) {
                         tracer.trace("Listening startDeviceScan error", { scannedDevice, bleError });
                         observer.error(mapBleErrorToHwTransportError(bleError));
@@ -395,13 +411,13 @@ class BleTransport extends Transport {
                     }
                 });
             }
-        }), true);
+        }, true);
         const unsubscribe = () => {
             if (unsubscribed)
                 return;
             unsubscribed = true;
             BlePlxManager.stopScan().then(() => {
-                _a.safeRemove(stateSub, tracer);
+                BleTransport.safeRemove(stateSub, tracer);
                 tracer.trace("Done listening");
             });
         };
@@ -418,11 +434,41 @@ class BleTransport extends Transport {
      * @param injectedDependencies Contains optional injected dependencies used by the transport implementation
      *  - rxjsScheduler: dependency injected RxJS scheduler to control time. Default AsyncScheduler.
      */
-    static open(deviceOrId_1, timeoutMs_1, context_1) {
-        return __awaiter(this, arguments, void 0, function* (deviceOrId, timeoutMs, context, { rxjsScheduler } = {}) {
-            return open(deviceOrId, true, timeoutMs, context, { rxjsScheduler });
-        });
+    static async open(deviceOrId, timeoutMs, context, { rxjsScheduler } = {}) {
+        return open(deviceOrId, true, timeoutMs, context, { rxjsScheduler });
     }
+    /**
+     * Exposes method from the ble-plx library to disconnect a device
+     *
+     * Disconnects from {@link Device} if it's connected or cancels pending connection.
+     * A "disconnect" event will normally be emitted by the ble-plx lib once the device is disconnected.
+     * Errors are logged but silenced.
+     */
+    static disconnectDevice = async (id, context) => {
+        const tracer = new LocalTracer(LOG_TYPE, context);
+        tracer.trace(`Trying to disconnect device ${id}`);
+        await BlePlxManager.disconnectDevice(id).catch(error => {
+            // Only log, ignore if disconnect did not work
+            tracer
+                .withType("ble-error")
+                .trace(`Error while trying to cancel device connection`, { error });
+        });
+        tracer.trace(`Device ${id} disconnected`);
+    };
+    device;
+    deviceModel;
+    disconnectTimeout = null;
+    id;
+    isConnected = true;
+    mtuSize = 20;
+    // Observable emitting data received from the device via BLE
+    notifyObservable;
+    notYetDisconnected = true;
+    writableWithResponseCharacteristic;
+    writableWithoutResponseCharacteristic;
+    rxjsScheduler;
+    // Transaction ids of communication operations that are currently pending
+    currentTransactionIds;
     /**
      * The static `open` function is used to handle BleTransport instantiation
      *
@@ -440,102 +486,6 @@ class BleTransport extends Transport {
      */
     constructor(device, writableWithResponseCharacteristic, writableWithoutResponseCharacteristic, notifyObservable, deviceModel, { context, rxjsScheduler } = {}) {
         super({ context, logType: LOG_TYPE });
-        this.disconnectTimeout = null;
-        this.isConnected = true;
-        this.mtuSize = 20;
-        this.notYetDisconnected = true;
-        /**
-         * A message exchange (APDU request <-> response) with the device that can be aborted
-         *
-         * The message will be BLE-encoded/framed before being sent, and the response will be BLE-decoded.
-         *
-         * @param message A buffer (u8 array) of a none BLE-encoded message (an APDU for ex) to be sent to the device
-         *   as a request
-         * @param options Contains optional options for the exchange function
-         *  - abortTimeoutMs: stop the exchange after a given timeout. Another timeout exists
-         *    to detect unresponsive device (see `unresponsiveTimeout`). This timeout aborts the exchange.
-         * @returns A promise that resolves with the response data from the device.
-         */
-        this.exchange = (message, { abortTimeoutMs } = {}) => {
-            const tracer = this.tracer.withUpdatedContext({
-                function: "exchange",
-            });
-            tracer.trace("Exchanging APDU ...", { abortTimeoutMs });
-            tracer.withType("apdu").trace(`=> ${message.toString("hex")}`);
-            return this.exchangeAtomicImpl(() => {
-                return firstValueFrom(
-                // `sendApdu` will only emit if an error occurred, otherwise it will complete,
-                // while `receiveAPDU` will emit the full response.
-                // Consequently it monitors the response while being able to reject on an error from the send.
-                merge(this.notifyObservable.pipe(data => receiveAPDU(data, { context: tracer.getContext() })), sendAPDU(this.write, message, this.mtuSize, {
-                    context: tracer.getContext(),
-                })).pipe(abortTimeoutMs ? timeout(abortTimeoutMs, this.rxjsScheduler) : tap(), tap(data => {
-                    tracer.withType("apdu").trace(`<= ${data.toString("hex")}`);
-                }), catchError((error) => __awaiter(this, void 0, void 0, function* () {
-                    // Currently only 1 reason the exchange has been explicitly aborted (other than job and transport errors): a timeout
-                    if (error instanceof TimeoutError) {
-                        tracer.trace("Aborting due to timeout and trying to cancel all communication write of the current exchange", {
-                            abortTimeoutMs,
-                            transactionIds: this.currentTransactionIds,
-                        });
-                        // No concurrent exchange should happen at the same time, so all pending operations are part of the same exchange
-                        yield this.cancelPendingOperations();
-                        throw new TransportExchangeTimeoutError("Exchange aborted due to timeout");
-                    }
-                    tracer.withType("ble-error").trace(`Error while exchanging APDU`, { error });
-                    if (this.notYetDisconnected) {
-                        // In such case we will always disconnect because something is bad.
-                        // This sends a "disconnect" event
-                        yield _a.disconnectDevice(this.id);
-                    }
-                    const mappedError = remapError(error);
-                    tracer.trace("Error while exchanging APDU, mapped and throws following error", {
-                        mappedError,
-                    });
-                    throw mappedError;
-                })), finalize(() => {
-                    tracer.trace("Clearing current transaction ids", {
-                        currentTransactionIds: this.currentTransactionIds,
-                    });
-                    this.clearCurrentTransactionIds();
-                })));
-            });
-        };
-        /**
-         * Do not call this directly unless you know what you're doing. Communication
-         * with a Ledger device should be through the {@link exchange} method.
-         *
-         * For each call a transaction id is added to the current stack of transaction ids.
-         * With this transaction id, a pending BLE communication operations can be cancelled.
-         * Note: each frame/packet of a longer BLE-encoded message to be sent should have their unique transaction id.
-         *
-         * @param buffer BLE-encoded packet to send to the device
-         * @param frameId Frame id to make `write` aware of a bigger message that this frame/packet is part of.
-         *  Helps creating related a collection of transaction ids
-         */
-        this.write = (buffer) => __awaiter(this, void 0, void 0, function* () {
-            const transactionId = uuid();
-            this.currentTransactionIds.push(transactionId);
-            const tracer = this.tracer.withUpdatedContext({ transactionId });
-            tracer.trace("Writing to device", {
-                willMessageBeAcked: !this.writableWithoutResponseCharacteristic,
-            });
-            try {
-                if (!this.writableWithoutResponseCharacteristic) {
-                    // The message will be acked in response by the device
-                    yield this.writableWithResponseCharacteristic.writeWithResponse(buffer.toString("base64"), transactionId);
-                }
-                else {
-                    // The message won't be acked in response by the device
-                    yield this.writableWithoutResponseCharacteristic.writeWithoutResponse(buffer.toString("base64"), transactionId);
-                }
-                tracer.withType("ble-frame").trace("=> " + buffer.toString("hex"));
-            }
-            catch (error) {
-                tracer.trace("Error while writing APDU", { error });
-                throw new DisconnectedDeviceDuringOperation(error instanceof Error ? error.message : `${error}`);
-            }
-        });
         this.id = device.id;
         this.device = device;
         this.writableWithResponseCharacteristic = writableWithResponseCharacteristic;
@@ -547,6 +497,63 @@ class BleTransport extends Transport {
         clearDisconnectTimeout(this.id);
         this.tracer.trace(`New instance of BleTransport for device ${this.id}`);
     }
+    /**
+     * A message exchange (APDU request <-> response) with the device that can be aborted
+     *
+     * The message will be BLE-encoded/framed before being sent, and the response will be BLE-decoded.
+     *
+     * @param message A buffer (u8 array) of a none BLE-encoded message (an APDU for ex) to be sent to the device
+     *   as a request
+     * @param options Contains optional options for the exchange function
+     *  - abortTimeoutMs: stop the exchange after a given timeout. Another timeout exists
+     *    to detect unresponsive device (see `unresponsiveTimeout`). This timeout aborts the exchange.
+     * @returns A promise that resolves with the response data from the device.
+     */
+    exchange = (message, { abortTimeoutMs } = {}) => {
+        const tracer = this.tracer.withUpdatedContext({
+            function: "exchange",
+        });
+        tracer.trace("Exchanging APDU ...", { abortTimeoutMs });
+        tracer.withType("apdu").trace(`=> ${message.toString("hex")}`);
+        return this.exchangeAtomicImpl(() => {
+            return firstValueFrom(
+            // `sendApdu` will only emit if an error occurred, otherwise it will complete,
+            // while `receiveAPDU` will emit the full response.
+            // Consequently it monitors the response while being able to reject on an error from the send.
+            merge(this.notifyObservable.pipe(data => receiveAPDU(data, { context: tracer.getContext() })), sendAPDU(this.write, message, this.mtuSize, {
+                context: tracer.getContext(),
+            })).pipe(abortTimeoutMs ? timeout(abortTimeoutMs, this.rxjsScheduler) : tap(), tap(data => {
+                tracer.withType("apdu").trace(`<= ${data.toString("hex")}`);
+            }), catchError(async (error) => {
+                // Currently only 1 reason the exchange has been explicitly aborted (other than job and transport errors): a timeout
+                if (error instanceof TimeoutError) {
+                    tracer.trace("Aborting due to timeout and trying to cancel all communication write of the current exchange", {
+                        abortTimeoutMs,
+                        transactionIds: this.currentTransactionIds,
+                    });
+                    // No concurrent exchange should happen at the same time, so all pending operations are part of the same exchange
+                    await this.cancelPendingOperations();
+                    throw new TransportExchangeTimeoutError("Exchange aborted due to timeout");
+                }
+                tracer.withType("ble-error").trace(`Error while exchanging APDU`, { error });
+                if (this.notYetDisconnected) {
+                    // In such case we will always disconnect because something is bad.
+                    // This sends a "disconnect" event
+                    await BleTransport.disconnectDevice(this.id);
+                }
+                const mappedError = remapError(error);
+                tracer.trace("Error while exchanging APDU, mapped and throws following error", {
+                    mappedError,
+                });
+                throw mappedError;
+            }), finalize(() => {
+                tracer.trace("Clearing current transaction ids", {
+                    currentTransactionIds: this.currentTransactionIds,
+                });
+                this.clearCurrentTransactionIds();
+            })));
+        });
+    };
     /**
      * Tries to cancel all operations that have a recorded transaction and are pending
      *
@@ -556,18 +563,16 @@ class BleTransport extends Transport {
      * but this error should be ignored. (In `exchange` our observable is unsubscribed before `cancelPendingOperations`
      * is called so the error is ignored)
      */
-    cancelPendingOperations() {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const transactionId of this.currentTransactionIds) {
-                try {
-                    this.tracer.trace("Cancelling operation", { transactionId });
-                    yield BlePlxManager.cancelTransaction(transactionId);
-                }
-                catch (error) {
-                    this.tracer.trace("Error while cancelling operation", { transactionId, error });
-                }
+    async cancelPendingOperations() {
+        for (const transactionId of this.currentTransactionIds) {
+            try {
+                this.tracer.trace("Cancelling operation", { transactionId });
+                await BlePlxManager.cancelTransaction(transactionId);
             }
-        });
+            catch (error) {
+                this.tracer.trace("Error while cancelling operation", { transactionId, error });
+            }
+        }
     }
     /**
      * Sets the collection of current transaction ids to an empty array
@@ -579,43 +584,41 @@ class BleTransport extends Transport {
      * Negotiate with the device the maximum transfer unit for the ble frames
      * @returns Promise<number>
      */
-    inferMTU() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let { mtu } = this.device;
-            this.tracer.trace(`Inferring MTU ...`, { currentDeviceMtu: mtu });
-            yield this.exchangeAtomicImpl(() => __awaiter(this, void 0, void 0, function* () {
-                try {
-                    mtu = yield firstValueFrom(merge(this.notifyObservable.pipe(map(maybeError => {
-                        // Catches the PairingFailed Error that has only been emitted
-                        if (maybeError instanceof Error) {
-                            throw maybeError;
-                        }
-                        return maybeError;
-                    }), first(buffer => buffer.readUInt8(0) === 0x08), map(buffer => buffer.readUInt8(5))), defer(() => from(this.write(Buffer.from([0x08, 0, 0, 0, 0])))).pipe(ignoreElements())));
-                }
-                catch (error) {
-                    this.tracer.withType("ble-error").trace("Error while inferring MTU", { mtu });
-                    yield _a.disconnectDevice(this.id);
-                    const mappedError = remapError(error);
-                    this.tracer.trace("Error while inferring APDU, mapped and throws following error", {
-                        mappedError,
-                    });
-                    throw mappedError;
-                }
-                finally {
-                    // When negotiating the MTU, a message is sent/written to the device, and a transaction id was associated to this write
-                    this.clearCurrentTransactionIds();
-                }
-            }));
-            this.tracer.trace(`Successfully negotiated MTU with device`, {
-                mtu,
-                mtuSize: this.mtuSize,
-            });
-            if (mtu > 20) {
-                this.mtuSize = mtu;
+    async inferMTU() {
+        let { mtu } = this.device;
+        this.tracer.trace(`Inferring MTU ...`, { currentDeviceMtu: mtu });
+        await this.exchangeAtomicImpl(async () => {
+            try {
+                mtu = await firstValueFrom(merge(this.notifyObservable.pipe(map(maybeError => {
+                    // Catches the PairingFailed Error that has only been emitted
+                    if (maybeError instanceof Error) {
+                        throw maybeError;
+                    }
+                    return maybeError;
+                }), first(buffer => buffer.readUInt8(0) === 0x08), map(buffer => buffer.readUInt8(5))), defer(() => from(this.write(Buffer.from([0x08, 0, 0, 0, 0])))).pipe(ignoreElements())));
             }
-            return this.mtuSize;
+            catch (error) {
+                this.tracer.withType("ble-error").trace("Error while inferring MTU", { mtu });
+                await BleTransport.disconnectDevice(this.id);
+                const mappedError = remapError(error);
+                this.tracer.trace("Error while inferring APDU, mapped and throws following error", {
+                    mappedError,
+                });
+                throw mappedError;
+            }
+            finally {
+                // When negotiating the MTU, a message is sent/written to the device, and a transaction id was associated to this write
+                this.clearCurrentTransactionIds();
+            }
+        });
+        this.tracer.trace(`Successfully negotiated MTU with device`, {
+            mtu,
+            mtuSize: this.mtuSize,
         });
+        if (mtu > 20) {
+            this.mtuSize = mtu;
+        }
+        return this.mtuSize;
     }
     /**
      * Exposed method from the ble-plx library
@@ -623,11 +626,44 @@ class BleTransport extends Transport {
      * @param {"Balanced" | "High" | "LowPower"} connectionPriority: Connection priority.
      * @returns {Promise<Device>} Connected device.
      */
-    requestConnectionPriority(connectionPriority) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield decoratePromiseErrors(this.device.requestConnectionPriority(ConnectionPriority[connectionPriority]));
-        });
+    async requestConnectionPriority(connectionPriority) {
+        return await decoratePromiseErrors(this.device.requestConnectionPriority(ConnectionPriority[connectionPriority]));
     }
+    /**
+     * Do not call this directly unless you know what you're doing. Communication
+     * with a Ledger device should be through the {@link exchange} method.
+     *
+     * For each call a transaction id is added to the current stack of transaction ids.
+     * With this transaction id, a pending BLE communication operations can be cancelled.
+     * Note: each frame/packet of a longer BLE-encoded message to be sent should have their unique transaction id.
+     *
+     * @param buffer BLE-encoded packet to send to the device
+     * @param frameId Frame id to make `write` aware of a bigger message that this frame/packet is part of.
+     *  Helps creating related a collection of transaction ids
+     */
+    write = async (buffer) => {
+        const transactionId = uuid();
+        this.currentTransactionIds.push(transactionId);
+        const tracer = this.tracer.withUpdatedContext({ transactionId });
+        tracer.trace("Writing to device", {
+            willMessageBeAcked: !this.writableWithoutResponseCharacteristic,
+        });
+        try {
+            if (!this.writableWithoutResponseCharacteristic) {
+                // The message will be acked in response by the device
+                await this.writableWithResponseCharacteristic.writeWithResponse(buffer.toString("base64"), transactionId);
+            }
+            else {
+                // The message won't be acked in response by the device
+                await this.writableWithoutResponseCharacteristic.writeWithoutResponse(buffer.toString("base64"), transactionId);
+            }
+            tracer.withType("ble-frame").trace("=> " + buffer.toString("hex"));
+        }
+        catch (error) {
+            tracer.trace("Error while writing APDU", { error });
+            throw new DisconnectedDeviceDuringOperation(error instanceof Error ? error.message : `${error}`);
+        }
+    };
     /**
      * We intentionally do not immediately close a transport connection.
      * Instead, we queue the disconnect and wait for a future connection to dismiss the event.
@@ -636,76 +672,29 @@ class BleTransport extends Transport {
      * already been disconnected.
      * @returns {Promise<void>}
      */
-    close() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const tracer = this.tracer.withUpdatedContext({ function: "close" });
-            tracer.trace("Closing, queuing a disconnect with a timeout ...");
-            let resolve;
-            const disconnectPromise = new Promise(innerResolve => {
-                resolve = innerResolve;
-            });
-            clearDisconnectTimeout(this.id);
-            this.disconnectTimeout = setTimeout(() => {
-                tracer.trace("Disconnect timeout has been reached ...");
-                if (this.isConnected) {
-                    _a.disconnectDevice(this.id, tracer.getContext())
-                        .catch(() => { })
-                        .finally(resolve);
-                }
-                else {
-                    resolve();
-                }
-            }, _a.disconnectTimeoutMs);
-            // The closure will occur no later than 5s, triggered either by disconnection
-            // or the actual response of the apdu.
-            yield Promise.race([this.exchangeBusyPromise || Promise.resolve(), disconnectPromise]);
-            return;
+    async close() {
+        const tracer = this.tracer.withUpdatedContext({ function: "close" });
+        tracer.trace("Closing, queuing a disconnect with a timeout ...");
+        let resolve;
+        const disconnectPromise = new Promise(innerResolve => {
+            resolve = innerResolve;
         });
+        clearDisconnectTimeout(this.id);
+        this.disconnectTimeout = setTimeout(() => {
+            tracer.trace("Disconnect timeout has been reached ...");
+            if (this.isConnected) {
+                BleTransport.disconnectDevice(this.id, tracer.getContext())
+                    .catch(() => { })
+                    .finally(resolve);
+            }
+            else {
+                resolve();
+            }
+        }, BleTransport.disconnectTimeoutMs);
+        // The closure will occur no later than 5s, triggered either by disconnection
+        // or the actual response of the apdu.
+        await Promise.race([this.exchangeBusyPromise || Promise.resolve(), disconnectPromise]);
+        return;
     }
 }
-_a = BleTransport;
-BleTransport.disconnectTimeoutMs = 5000;
-/**
- *
- */
-BleTransport.isSupported = () => Promise.resolve(typeof BlePlxManager === "function");
-/**
- *
- */
-BleTransport.list = () => {
-    throw new Error("not implemented");
-};
-// /**
-//  * Exposed method from the ble-plx library
-//  * Sets new log level for native module's logging mechanism.
-//  * @param string logLevel New log level to be set.
-//  */
-BleTransport.setLogLevel = BlePlxManager.setLogLevel;
-BleTransport.safeRemove = (sub, tracer) => {
-    try {
-        sub.remove();
-    }
-    catch (error) {
-        tracer.trace("Error removing state subscription", { error });
-    }
-};
-/**
- * Exposes method from the ble-plx library to disconnect a device
- *
- * Disconnects from {@link Device} if it's connected or cancels pending connection.
- * A "disconnect" event will normally be emitted by the ble-plx lib once the device is disconnected.
- * Errors are logged but silenced.
- */
-BleTransport.disconnectDevice = (id, context) => __awaiter(void 0, void 0, void 0, function* () {
-    const tracer = new LocalTracer(LOG_TYPE, context);
-    tracer.trace(`Trying to disconnect device ${id}`);
-    yield BlePlxManager.disconnectDevice(id).catch(error => {
-        // Only log, ignore if disconnect did not work
-        tracer
-            .withType("ble-error")
-            .trace(`Error while trying to cancel device connection`, { error });
-    });
-    tracer.trace(`Device ${id} disconnected`);
-});
-export default BleTransport;
 //# sourceMappingURL=BleTransport.js.map