@ledgerhq/react-native-hw-transport-ble 6.28.5 → 6.28.6-nightly.0

package/lib-es/BleTransport.js

@@ -1,18 +1,3 @@
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 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) {
@@ -22,60 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
+var _a;
 import Transport from "@ledgerhq/hw-transport";
 // ---------------------------------------------------------------------------------------------
 // Since this is a react-native library and metro bundler does not support
@@ -92,48 +24,49 @@ import { getBluetoothServiceUuids, getInfosForServiceUuid, } from "@ledgerhq/dev
 import { log } from "@ledgerhq/logs";
 import { defer, merge, from, of, throwError } from "rxjs";
 import { share, ignoreElements, first, map, tap, catchError, } from "rxjs/operators";
-import { CantOpenDevice, TransportError, DisconnectedDeviceDuringOperation, PairingFailed, } from "@ledgerhq/errors";
+import { CantOpenDevice, TransportError, DisconnectedDeviceDuringOperation, PairingFailed, PeerRemovedPairing, } from "@ledgerhq/errors";
 import { monitorCharacteristic } from "./monitorCharacteristic";
 import { awaitsBleOn } from "./awaitsBleOn";
-import { decoratePromiseErrors, mapBleErrorToHwTransportError, remapError, } from "./remapErrors";
+import { decoratePromiseErrors, remapError, mapBleErrorToHwTransportError, } from "./remapErrors";
 /**
  * This is potentially not needed anymore, to be checked if the bug is still
  * happening.
  */
-var reconnectionConfig = {
+let reconnectionConfig = {
     pairingThreshold: 1000,
-    delayAfterFirstPairing: 4000
+    delayAfterFirstPairing: 4000,
 };
-export var setReconnectionConfig = function (config) {
+export const setReconnectionConfig = (config) => {
     reconnectionConfig = config;
 };
-var retrieveInfos = function (device) {
+const retrieveInfos = (device) => {
     if (!device || !device.serviceUUIDs)
         return;
-    var _a = __read(device.serviceUUIDs, 1), serviceUUID = _a[0];
+    const [serviceUUID] = device.serviceUUIDs;
     if (!serviceUUID)
         return;
-    var infos = getInfosForServiceUuid(serviceUUID);
+    const infos = getInfosForServiceUuid(serviceUUID);
     if (!infos)
         return;
+    // If we retrieved information, update the cache
+    bluetoothInfoCache[device.id] = infos;
     return infos;
 };
-var delay = function (ms) {
-    return new Promise(function (success) { return setTimeout(success, ms); });
-};
+const delay = (ms) => new Promise((success) => setTimeout(success, ms));
 /**
  * A cache of Bluetooth transport instances associated with device IDs.
  * Allows efficient storage and retrieval of previously initialized transports.
  * @type {Object.<string, BluetoothTransport>}
  */
-var transportsCache = {};
+const transportsCache = {};
+const bluetoothInfoCache = {}; // Allows us to give more granulary error messages.
 // connectOptions is actually used by react-native-ble-plx even if comment above ConnectionOptions says it's not used
-var connectOptions = {
+let connectOptions = {
     // 156 bytes to max the iOS < 10 limit (158 bytes)
     // (185 bytes for iOS >= 10)(up to 512 bytes for Android, but could be blocked at 23 bytes)
     requestMTU: 156,
     // Priority 1 = high. TODO: Check firmware update over BLE PR before merging
-    connectionPriority: 1
+    connectionPriority: 1,
 };
 /**
  * Returns the instance of the Bluetooth Low Energy Manager. It initializes it only
@@ -142,265 +75,219 @@ var connectOptions = {
  * Use this function instead.
  * @returns {BleManager} - The instance of the BleManager.
  */
-var _bleManager = null;
-var bleManagerInstance = function () {
+let _bleManager = null;
+const bleManagerInstance = () => {
     if (!_bleManager) {
         _bleManager = new BleManager();
     }
     return _bleManager;
 };
-var clearDisconnectTimeout = function (deviceId) {
-    var cachedTransport = transportsCache[deviceId];
+const clearDisconnectTimeout = (deviceId) => {
+    const cachedTransport = transportsCache[deviceId];
     if (cachedTransport && cachedTransport.disconnectTimeout) {
         log(TAG, "Clearing queued disconnect");
         clearTimeout(cachedTransport.disconnectTimeout);
     }
 };
 function open(deviceOrId, needsReconnect) {
-    return __awaiter(this, void 0, void 0, function () {
-        var device, devices, connectedDevices, connectedDevicesFiltered, e_1, e_2, res, characteristics, _a, _b, uuid, e_3, e_4_1, deviceModel, serviceUuid, writeUuid, writeCmdUuid, notifyUuid, writeC, writeCmdC, notifyC, characteristics_1, characteristics_1_1, c, notifyObservable, notif, transport, disconnectedSub, onDisconnect, beforeMTUTime, afterMTUTime;
-        var _c, _d, e_4, _e, e_5, _f;
-        return __generator(this, function (_g) {
-            switch (_g.label) {
-                case 0:
-                    log(TAG, "open with ".concat(deviceOrId));
-                    if (!(typeof deviceOrId === "string")) return [3 /*break*/, 12];
-                    if (transportsCache[deviceOrId]) {
-                        log(TAG, "Transport in cache, using that.");
-                        clearDisconnectTimeout(deviceOrId);
-                        return [2 /*return*/, transportsCache[deviceOrId]];
+    return __awaiter(this, void 0, void 0, function* () {
+        let device;
+        log(TAG, `open with ${deviceOrId}`);
+        if (typeof deviceOrId === "string") {
+            if (transportsCache[deviceOrId]) {
+                log(TAG, "Transport in cache, using that.");
+                clearDisconnectTimeout(deviceOrId);
+                return transportsCache[deviceOrId];
+            }
+            log(TAG, `Tries to open device: ${deviceOrId}`);
+            yield awaitsBleOn(bleManagerInstance());
+            // Returns a list of known devices by their identifiers
+            const devices = yield bleManagerInstance().devices([deviceOrId]);
+            log(TAG, `found ${devices.length} devices`);
+            [device] = devices;
+            if (!device) {
+                // 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 bleManagerInstance().connectedDevices(getBluetoothServiceUuids());
+                const connectedDevicesFiltered = connectedDevices.filter((d) => d.id === deviceOrId);
+                log(TAG, `found ${connectedDevicesFiltered.length} connected devices`);
+                [device] = connectedDevicesFiltered;
+            }
+            if (!device) {
+                // We still don't have a device, so we attempt to connect to it.
+                log(TAG, `connectToDevice(${deviceOrId})`);
+                // Nb ConnectionOptions dropped since it's not used internally by ble-plx.
+                try {
+                    device = yield bleManagerInstance().connectToDevice(deviceOrId, connectOptions);
+                }
+                catch (e) {
+                    log(TAG, `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 bleManagerInstance().connectToDevice(deviceOrId);
                     }
-                    log(TAG, "Tries to open device: ".concat(deviceOrId));
-                    return [4 /*yield*/, awaitsBleOn(bleManagerInstance())];
-                case 1:
-                    _g.sent();
-                    return [4 /*yield*/, bleManagerInstance().devices([deviceOrId])];
-                case 2:
-                    devices = _g.sent();
-                    log(TAG, "found ".concat(devices.length, " devices"));
-                    _c = __read(devices, 1), device = _c[0];
-                    if (!!device) return [3 /*break*/, 4];
-                    return [4 /*yield*/, bleManagerInstance().connectedDevices(getBluetoothServiceUuids())];
-                case 3:
-                    connectedDevices = _g.sent();
-                    connectedDevicesFiltered = connectedDevices.filter(function (d) { return d.id === deviceOrId; });
-                    log(TAG, "found ".concat(connectedDevicesFiltered.length, " connected devices"));
-                    _d = __read(connectedDevicesFiltered, 1), device = _d[0];
-                    _g.label = 4;
-                case 4:
-                    if (!!device) return [3 /*break*/, 11];
-                    // We still don't have a device, so we attempt to connect to it.
-                    log(TAG, "connectToDevice(".concat(deviceOrId, ")"));
-                    _g.label = 5;
-                case 5:
-                    _g.trys.push([5, 7, , 11]);
-                    return [4 /*yield*/, bleManagerInstance().connectToDevice(deviceOrId, connectOptions)];
-                case 6:
-                    device = _g.sent();
-                    return [3 /*break*/, 11];
-                case 7:
-                    e_1 = _g.sent();
-                    log(TAG, "error code ".concat(e_1.errorCode));
-                    if (!(e_1.errorCode === BleErrorCode.DeviceMTUChangeFailed)) return [3 /*break*/, 9];
-                    // If the MTU update did not work, we try to connect without requesting for a specific MTU
-                    connectOptions = {};
-                    return [4 /*yield*/, bleManagerInstance().connectToDevice(deviceOrId)];
-                case 8:
-                    device = _g.sent();
-                    return [3 /*break*/, 10];
-                case 9: throw e_1;
-                case 10: return [3 /*break*/, 11];
-                case 11:
-                    if (!device) {
-                        throw new CantOpenDevice();
+                    else {
+                        throw e;
                     }
-                    return [3 /*break*/, 13];
-                case 12:
-                    // It was already a Device
-                    device = deviceOrId;
-                    _g.label = 13;
-                case 13: return [4 /*yield*/, device.isConnected()];
-                case 14:
-                    if (!!(_g.sent())) return [3 /*break*/, 21];
-                    log(TAG, "not connected. connecting...");
-                    _g.label = 15;
-                case 15:
-                    _g.trys.push([15, 17, , 21]);
-                    return [4 /*yield*/, device.connect(connectOptions)];
-                case 16:
-                    _g.sent();
-                    return [3 /*break*/, 21];
-                case 17:
-                    e_2 = _g.sent();
-                    if (!(e_2.errorCode === BleErrorCode.DeviceMTUChangeFailed)) return [3 /*break*/, 19];
-                    // If the MTU update did not work, we try to connect without requesting for a specific MTU
+                }
+            }
+            if (!device) {
+                throw new CantOpenDevice();
+            }
+        }
+        else {
+            // It was already a Device
+            device = deviceOrId;
+        }
+        if (!(yield device.isConnected())) {
+            log(TAG, "not connected. connecting...");
+            try {
+                yield device.connect(connectOptions);
+            }
+            catch (e) {
+                log("ble-verbose", `connect error - ${JSON.stringify(e)}`);
+                if (e.errorCode === BleErrorCode.DeviceMTUChangeFailed) {
+                    log("ble-verbose", `device.mtu=${device.mtu}, reconnecting`);
                     connectOptions = {};
-                    return [4 /*yield*/, device.connect()];
-                case 18:
-                    _g.sent();
-                    return [3 /*break*/, 20];
-                case 19: throw e_2;
-                case 20: return [3 /*break*/, 21];
-                case 21: return [4 /*yield*/, device.discoverAllServicesAndCharacteristics()];
-                case 22:
-                    _g.sent();
-                    res = retrieveInfos(device);
-                    if (!!res) return [3 /*break*/, 32];
-                    _g.label = 23;
-                case 23:
-                    _g.trys.push([23, 30, 31, 32]);
-                    _a = __values(getBluetoothServiceUuids()), _b = _a.next();
-                    _g.label = 24;
-                case 24:
-                    if (!!_b.done) return [3 /*break*/, 29];
-                    uuid = _b.value;
-                    _g.label = 25;
-                case 25:
-                    _g.trys.push([25, 27, , 28]);
-                    return [4 /*yield*/, device.characteristicsForService(uuid)];
-                case 26:
-                    characteristics = _g.sent();
-                    res = getInfosForServiceUuid(uuid);
-                    return [3 /*break*/, 29];
-                case 27:
-                    e_3 = _g.sent();
-                    return [3 /*break*/, 28];
-                case 28:
-                    _b = _a.next();
-                    return [3 /*break*/, 24];
-                case 29: return [3 /*break*/, 32];
-                case 30:
-                    e_4_1 = _g.sent();
-                    e_4 = { error: e_4_1 };
-                    return [3 /*break*/, 32];
-                case 31:
-                    try {
-                        if (_b && !_b.done && (_e = _a["return"])) _e.call(_a);
-                    }
-                    finally { if (e_4) throw e_4.error; }
-                    return [7 /*endfinally*/];
-                case 32:
-                    if (!res) {
-                        throw new TransportError("service not found", "BLEServiceNotFound");
-                    }
-                    deviceModel = res.deviceModel, serviceUuid = res.serviceUuid, writeUuid = res.writeUuid, writeCmdUuid = res.writeCmdUuid, notifyUuid = res.notifyUuid;
-                    if (!!characteristics) return [3 /*break*/, 34];
-                    return [4 /*yield*/, device.characteristicsForService(serviceUuid)];
-                case 33:
-                    characteristics = _g.sent();
-                    _g.label = 34;
-                case 34:
-                    if (!characteristics) {
-                        throw new TransportError("service not found", "BLEServiceNotFound");
-                    }
-                    try {
-                        for (characteristics_1 = __values(characteristics), characteristics_1_1 = characteristics_1.next(); !characteristics_1_1.done; characteristics_1_1 = characteristics_1.next()) {
-                            c = characteristics_1_1.value;
-                            if (c.uuid === writeUuid) {
-                                writeC = c;
-                            }
-                            else if (c.uuid === writeCmdUuid) {
-                                writeCmdC = c;
-                            }
-                            else if (c.uuid === notifyUuid) {
-                                notifyC = c;
-                            }
-                        }
-                    }
-                    catch (e_5_1) { e_5 = { error: e_5_1 }; }
-                    finally {
-                        try {
-                            if (characteristics_1_1 && !characteristics_1_1.done && (_f = characteristics_1["return"])) _f.call(characteristics_1);
-                        }
-                        finally { if (e_5) throw e_5.error; }
-                    }
-                    if (!writeC) {
-                        throw new TransportError("write characteristic not found", "BLECharacteristicNotFound");
-                    }
-                    if (!notifyC) {
-                        throw new TransportError("notify characteristic not found", "BLECharacteristicNotFound");
-                    }
-                    if (!writeC.isWritableWithResponse) {
-                        throw new TransportError("write characteristic not writableWithResponse", "BLECharacteristicInvalid");
-                    }
-                    if (!notifyC.isNotifiable) {
-                        throw new TransportError("notify characteristic not notifiable", "BLECharacteristicInvalid");
-                    }
-                    if (writeCmdC) {
-                        if (!writeCmdC.isWritableWithoutResponse) {
-                            throw new TransportError("write cmd characteristic not writableWithoutResponse", "BLECharacteristicInvalid");
-                        }
-                    }
-                    log(TAG, "device.mtu=".concat(device.mtu));
-                    notifyObservable = monitorCharacteristic(notifyC).pipe(catchError(function (e) {
-                        // LL-9033 fw 2.0.2 introduced this case, we silence the inner unhandled error.
-                        var msg = String(e);
-                        return msg.includes("notify change failed")
-                            ? of(new PairingFailed(msg))
-                            : throwError(e);
-                    }), tap(function (value) {
-                        if (value instanceof PairingFailed)
-                            return;
-                        log("ble-frame", "<= " + value.toString("hex"));
-                    }), share());
-                    notif = notifyObservable.subscribe();
-                    transport = new BleTransport(device, writeC, writeCmdC, notifyObservable, deviceModel);
-                    onDisconnect = function (e) {
-                        transport.isConnected = false;
-                        transport.notYetDisconnected = false;
-                        notif.unsubscribe();
-                        disconnectedSub === null || disconnectedSub === void 0 ? void 0 : disconnectedSub.remove();
-                        clearDisconnectTimeout(transport.id);
-                        delete transportsCache[transport.id];
-                        log(TAG, "BleTransport(".concat(transport.id, ") disconnected"));
-                        transport.emit("disconnect", e);
-                    };
-                    // eslint-disable-next-line require-atomic-updates
-                    transportsCache[transport.id] = transport;
-                    beforeMTUTime = Date.now();
-                    disconnectedSub = device.onDisconnected(function (e) {
-                        if (!transport.notYetDisconnected)
-                            return;
-                        onDisconnect(e);
+                    yield device.connect();
+                }
+                else if (e.iosErrorCode === 14 ||
+                    e.reason === "Peer removed pairing information") {
+                    log("ble-verbose", "iOS broken pairing");
+                    log("ble-verbose", JSON.stringify(device));
+                    log("ble-verbose", JSON.stringify(bluetoothInfoCache[device.id]));
+                    const { deviceModel } = bluetoothInfoCache[device.id] || {};
+                    const { productName } = deviceModel || {};
+                    throw new PeerRemovedPairing(undefined, {
+                        deviceName: device.name,
+                        productName,
                     });
-                    _g.label = 35;
-                case 35:
-                    _g.trys.push([35, , 37, 43]);
-                    return [4 /*yield*/, transport.inferMTU()];
-                case 36:
-                    _g.sent();
-                    return [3 /*break*/, 43];
-                case 37:
-                    afterMTUTime = Date.now();
-                    if (!reconnectionConfig) return [3 /*break*/, 41];
-                    // workaround for #279: we need to open() again if we come the first time here,
-                    // to make sure we do a disconnect() after the first pairing time
-                    // because of a firmware bug
-                    if (afterMTUTime - beforeMTUTime < reconnectionConfig.pairingThreshold) {
-                        needsReconnect = false; // (optim) there is likely no new pairing done because mtu answer was fast.
-                    }
-                    if (!needsReconnect) return [3 /*break*/, 40];
-                    // necessary time for the bonding workaround
-                    return [4 /*yield*/, BleTransport.disconnect(transport.id)["catch"](function () { })];
-                case 38:
-                    // necessary time for the bonding workaround
-                    _g.sent();
-                    return [4 /*yield*/, delay(reconnectionConfig.delayAfterFirstPairing)];
-                case 39:
-                    _g.sent();
-                    _g.label = 40;
-                case 40: return [3 /*break*/, 42];
-                case 41:
-                    needsReconnect = false;
-                    _g.label = 42;
-                case 42: return [7 /*endfinally*/];
-                case 43:
-                    if (needsReconnect) {
-                        return [2 /*return*/, open(device, false)];
-                    }
-                    return [2 /*return*/, transport];
+                }
+                else {
+                    throw remapError(e);
+                }
             }
+        }
+        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 (!res) {
+            throw new TransportError("service not found", "BLEServiceNotFound");
+        }
+        const { deviceModel, serviceUuid, writeUuid, writeCmdUuid, notifyUuid } = res;
+        if (!characteristics) {
+            characteristics = yield device.characteristicsForService(serviceUuid);
+        }
+        if (!characteristics) {
+            throw new TransportError("service not found", "BLEServiceNotFound");
+        }
+        let writeC;
+        let writeCmdC;
+        let notifyC;
+        for (const c of characteristics) {
+            if (c.uuid === writeUuid) {
+                writeC = c;
+            }
+            else if (c.uuid === writeCmdUuid) {
+                writeCmdC = c;
+            }
+            else if (c.uuid === notifyUuid) {
+                notifyC = c;
+            }
+        }
+        if (!writeC) {
+            throw new TransportError("write characteristic not found", "BLECharacteristicNotFound");
+        }
+        if (!notifyC) {
+            throw new TransportError("notify characteristic not found", "BLECharacteristicNotFound");
+        }
+        if (!writeC.isWritableWithResponse) {
+            throw new TransportError("write characteristic not writableWithResponse", "BLECharacteristicInvalid");
+        }
+        if (!notifyC.isNotifiable) {
+            throw new TransportError("notify characteristic not notifiable", "BLECharacteristicInvalid");
+        }
+        if (writeCmdC) {
+            if (!writeCmdC.isWritableWithoutResponse) {
+                throw new TransportError("write cmd characteristic not writableWithoutResponse", "BLECharacteristicInvalid");
+            }
+        }
+        log(TAG, `device.mtu=${device.mtu}`);
+        const notifyObservable = monitorCharacteristic(notifyC).pipe(catchError((e) => {
+            // LL-9033 fw 2.0.2 introduced this case, we silence the inner unhandled error.
+            const msg = String(e);
+            return msg.includes("notify change failed")
+                ? of(new PairingFailed(msg))
+                : throwError(e);
+        }), tap((value) => {
+            if (value instanceof PairingFailed)
+                return;
+            log("ble-frame", "<= " + value.toString("hex"));
+        }), share());
+        const notif = notifyObservable.subscribe();
+        const transport = new BleTransport(device, writeC, writeCmdC, notifyObservable, deviceModel);
+        // 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;
+        const onDisconnect = (e) => {
+            transport.isConnected = false;
+            transport.notYetDisconnected = false;
+            notif.unsubscribe();
+            disconnectedSub === null || disconnectedSub === void 0 ? void 0 : disconnectedSub.remove();
+            clearDisconnectTimeout(transport.id);
+            delete transportsCache[transport.id];
+            log(TAG, `BleTransport(${transport.id}) disconnected`);
+            transport.emit("disconnect", e);
+        };
+        // 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();
+        }
+        finally {
+            const afterMTUTime = Date.now();
+            if (reconnectionConfig) {
+                // workaround for #279: we need to open() again if we come the first time here,
+                // to make sure we do a disconnect() after the first pairing time
+                // because of a firmware bug
+                if (afterMTUTime - beforeMTUTime < reconnectionConfig.pairingThreshold) {
+                    needsReconnect = false; // (optim) there is likely no new pairing done because mtu answer was fast.
+                }
+                if (needsReconnect) {
+                    // necessary time for the bonding workaround
+                    yield BleTransport.disconnect(transport.id).catch(() => { });
+                    yield delay(reconnectionConfig.delayAfterFirstPairing);
+                }
+            }
+            else {
+                needsReconnect = false;
+            }
+        }
+        if (needsReconnect) {
+            return open(device, false);
+        }
+        return transport;
     });
 }
 /**
@@ -408,255 +295,189 @@ function open(deviceOrId, needsReconnect) {
  * @example
  * import BleTransport from "@ledgerhq/react-native-hw-transport-ble";
  */
-var TAG = "ble-verbose";
-var BleTransport = /** @class */ (function (_super) {
-    __extends(BleTransport, _super);
-    function BleTransport(device, writeCharacteristic, writeCmdCharacteristic, notifyObservable, deviceModel) {
-        var _this = _super.call(this) || this;
-        _this.disconnectTimeout = null;
-        _this.isConnected = true;
-        _this.mtuSize = 20;
-        _this.notYetDisconnected = true;
-        /**
-         * Send data to the device using a low level API.
-         * It's recommended to use the "send" method for a higher level API.
-         * @param {Buffer} apdu - The data to send.
-         * @returns {Promise<Buffer>} A promise that resolves with the response data from the device.
-         */
-        _this.exchange = function (apdu) {
-            return _this.exchangeAtomicImpl(function () { return __awaiter(_this, void 0, void 0, function () {
-                var msgIn, data, msgOut, e_6;
-                return __generator(this, function (_b) {
-                    switch (_b.label) {
-                        case 0:
-                            _b.trys.push([0, 2, , 5]);
-                            msgIn = apdu.toString("hex");
-                            log("apdu", "=> ".concat(msgIn));
-                            return [4 /*yield*/, merge(this.notifyObservable.pipe(receiveAPDU), sendAPDU(this.write, apdu, this.mtuSize)).toPromise()];
-                        case 1:
-                            data = _b.sent();
-                            msgOut = data.toString("hex");
-                            log("apdu", "<= ".concat(msgOut));
-                            return [2 /*return*/, data];
-                        case 2:
-                            e_6 = _b.sent();
-                            log("ble-error", "exchange got " + String(e_6));
-                            if (!this.notYetDisconnected) return [3 /*break*/, 4];
-                            // in such case we will always disconnect because something is bad.
-                            return [4 /*yield*/, bleManagerInstance()
-                                    .cancelDeviceConnection(this.id)["catch"](function () { })];
-                        case 3:
-                            // in such case we will always disconnect because something is bad.
-                            _b.sent(); // but we ignore if disconnect worked.
-                            _b.label = 4;
-                        case 4: throw remapError(e_6);
-                        case 5: return [2 /*return*/];
-                    }
-                });
-            }); });
-        };
-        /**
-         * Do not call this directly unless you know what you're doing. Communication
-         * with a Ledger device should be through the {@link exchange} method.
-         * @param buffer
-         * @param txid
-         */
-        _this.write = function (buffer, txid) { return __awaiter(_this, void 0, void 0, function () {
-            var e_7, e_8;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        log("ble-frame", "=> " + buffer.toString("hex"));
-                        if (!!this.writeCmdCharacteristic) return [3 /*break*/, 5];
-                        _b.label = 1;
-                    case 1:
-                        _b.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this.writeCharacteristic.writeWithResponse(buffer.toString("base64"), txid)];
-                    case 2:
-                        _b.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
-                        e_7 = _b.sent();
-                        throw new DisconnectedDeviceDuringOperation(e_7.message);
-                    case 4: return [3 /*break*/, 8];
-                    case 5:
-                        _b.trys.push([5, 7, , 8]);
-                        return [4 /*yield*/, this.writeCmdCharacteristic.writeWithoutResponse(buffer.toString("base64"), txid)];
-                    case 6:
-                        _b.sent();
-                        return [3 /*break*/, 8];
-                    case 7:
-                        e_8 = _b.sent();
-                        throw new DisconnectedDeviceDuringOperation(e_8.message);
-                    case 8: return [2 /*return*/];
-                }
-            });
-        }); };
-        _this.id = device.id;
-        _this.device = device;
-        _this.writeCharacteristic = writeCharacteristic;
-        _this.writeCmdCharacteristic = writeCmdCharacteristic;
-        _this.notifyObservable = notifyObservable;
-        _this.deviceModel = deviceModel;
-        log(TAG, "BleTransport(".concat(String(_this.id), ") new instance"));
-        clearDisconnectTimeout(_this.id);
-        return _this;
-    }
+const TAG = "ble-verbose";
+export default class BleTransport extends Transport {
     /**
      * Listen to state changes on the bleManagerInstance and notify the
      * specified observer.
      * @param observer
      * @returns TransportSubscription
      */
-    BleTransport.observeState = function (observer) {
-        var emitFromState = function (type) {
+    static observeState(observer) {
+        const emitFromState = (type) => {
             observer.next({
-                type: type,
-                available: type === "PoweredOn"
+                type,
+                available: type === "PoweredOn",
             });
         };
         bleManagerInstance().onStateChange(emitFromState, true);
         return {
-            unsubscribe: function () { }
+            unsubscribe: () => { },
         };
-    };
+    }
     /**
      * Scan for bluetooth Ledger devices
      * @param observer Device is partial in order to avoid the live-common/this dep
      * @returns TransportSubscription
      */
-    BleTransport.listen = function (observer) {
-        var _this = this;
+    static listen(observer) {
         log(TAG, "listening for devices");
-        var unsubscribed;
-        var stateSub = bleManagerInstance().onStateChange(function (state) { return __awaiter(_this, void 0, void 0, function () {
-            var devices;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!(state === "PoweredOn")) return [3 /*break*/, 4];
-                        stateSub.remove();
-                        return [4 /*yield*/, bleManagerInstance().connectedDevices(getBluetoothServiceUuids())];
-                    case 1:
-                        devices = _b.sent();
-                        if (unsubscribed)
-                            return [2 /*return*/];
-                        if (!devices.length) return [3 /*break*/, 3];
-                        log(TAG, "disconnecting from devices");
-                        return [4 /*yield*/, Promise.all(devices.map(function (d) { return BleTransport.disconnect(d.id)["catch"](function () { }); }))];
-                    case 2:
-                        _b.sent();
-                        _b.label = 3;
-                    case 3:
-                        if (unsubscribed)
-                            return [2 /*return*/];
-                        bleManagerInstance().startDeviceScan(getBluetoothServiceUuids(), null, function (bleError, scannedDevice) {
-                            if (bleError) {
-                                observer.error(mapBleErrorToHwTransportError(bleError));
-                                unsubscribe();
-                                return;
-                            }
-                            var res = retrieveInfos(scannedDevice);
-                            var deviceModel = res && res.deviceModel;
-                            if (scannedDevice) {
-                                observer.next({
-                                    type: "add",
-                                    descriptor: scannedDevice,
-                                    deviceModel: deviceModel
-                                });
-                            }
-                        });
-                        _b.label = 4;
-                    case 4: return [2 /*return*/];
+        let unsubscribed;
+        const stateSub = bleManagerInstance().onStateChange((state) => __awaiter(this, void 0, void 0, function* () {
+            if (state === "PoweredOn") {
+                stateSub.remove();
+                const devices = yield bleManagerInstance().connectedDevices(getBluetoothServiceUuids());
+                if (unsubscribed)
+                    return;
+                if (devices.length) {
+                    log(TAG, "disconnecting from devices");
+                    yield Promise.all(devices.map((d) => BleTransport.disconnect(d.id).catch(() => { })));
                 }
-            });
-        }); }, true);
-        var unsubscribe = function () {
+                if (unsubscribed)
+                    return;
+                bleManagerInstance().startDeviceScan(getBluetoothServiceUuids(), null, (bleError, scannedDevice) => {
+                    if (bleError) {
+                        observer.error(mapBleErrorToHwTransportError(bleError));
+                        unsubscribe();
+                        return;
+                    }
+                    const res = retrieveInfos(scannedDevice);
+                    const deviceModel = res && res.deviceModel;
+                    if (scannedDevice) {
+                        observer.next({
+                            type: "add",
+                            descriptor: scannedDevice,
+                            deviceModel,
+                        });
+                    }
+                });
+            }
+        }), true);
+        const unsubscribe = () => {
             unsubscribed = true;
             bleManagerInstance().stopDeviceScan();
             stateSub.remove();
             log(TAG, "done listening.");
         };
         return {
-            unsubscribe: unsubscribe
+            unsubscribe,
         };
-    };
+    }
     /**
      * Open a BLE transport
      * @param {Device | string} deviceOrId
      */
-    BleTransport.open = function (deviceOrId) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_b) {
-                return [2 /*return*/, open(deviceOrId, true)];
-            });
+    static open(deviceOrId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return open(deviceOrId, true);
+        });
+    }
+    constructor(device, writeCharacteristic, writeCmdCharacteristic, notifyObservable, deviceModel) {
+        super();
+        this.disconnectTimeout = null;
+        this.isConnected = true;
+        this.mtuSize = 20;
+        this.notYetDisconnected = true;
+        /**
+         * Send data to the device using a low level API.
+         * It's recommended to use the "send" method for a higher level API.
+         * @param {Buffer} apdu - The data to send.
+         * @returns {Promise<Buffer>} A promise that resolves with the response data from the device.
+         */
+        this.exchange = (apdu) => this.exchangeAtomicImpl(() => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const msgIn = apdu.toString("hex");
+                log("apdu", `=> ${msgIn}`);
+                const data = yield merge(this.notifyObservable.pipe(receiveAPDU), sendAPDU(this.write, apdu, this.mtuSize)).toPromise();
+                const msgOut = data.toString("hex");
+                log("apdu", `<= ${msgOut}`);
+                return data;
+            }
+            catch (e) {
+                log("ble-error", "exchange got " + String(e));
+                if (this.notYetDisconnected) {
+                    // in such case we will always disconnect because something is bad.
+                    yield bleManagerInstance()
+                        .cancelDeviceConnection(this.id)
+                        .catch(() => { }); // but we ignore if disconnect worked.
+                }
+                throw remapError(e);
+            }
+        }));
+        /**
+         * Do not call this directly unless you know what you're doing. Communication
+         * with a Ledger device should be through the {@link exchange} method.
+         * @param buffer
+         * @param txid
+         */
+        this.write = (buffer, txid) => __awaiter(this, void 0, void 0, function* () {
+            log("ble-frame", "=> " + buffer.toString("hex"));
+            if (!this.writeCmdCharacteristic) {
+                try {
+                    yield this.writeCharacteristic.writeWithResponse(buffer.toString("base64"), txid);
+                }
+                catch (e) {
+                    throw new DisconnectedDeviceDuringOperation(e.message);
+                }
+            }
+            else {
+                try {
+                    yield this.writeCmdCharacteristic.writeWithoutResponse(buffer.toString("base64"), txid);
+                }
+                catch (e) {
+                    throw new DisconnectedDeviceDuringOperation(e.message);
+                }
+            }
         });
-    };
+        this.id = device.id;
+        this.device = device;
+        this.writeCharacteristic = writeCharacteristic;
+        this.writeCmdCharacteristic = writeCmdCharacteristic;
+        this.notifyObservable = notifyObservable;
+        this.deviceModel = deviceModel;
+        log(TAG, `BleTransport(${String(this.id)}) new instance`);
+        clearDisconnectTimeout(this.id);
+    }
     /**
      * Negotiate with the device the maximum transfer unit for the ble frames
      * @returns Promise<number>
      */
-    BleTransport.prototype.inferMTU = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var mtu;
-            var _this = this;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        mtu = this.device.mtu;
-                        return [4 /*yield*/, this.exchangeAtomicImpl(function () { return __awaiter(_this, void 0, void 0, function () {
-                                var e_9;
-                                var _this = this;
-                                return __generator(this, function (_b) {
-                                    switch (_b.label) {
-                                        case 0:
-                                            _b.trys.push([0, 2, , 4]);
-                                            return [4 /*yield*/, merge(this.notifyObservable.pipe(tap(function (maybeError) {
-                                                    if (maybeError instanceof Error)
-                                                        throw maybeError;
-                                                }), first(function (buffer) { return buffer.readUInt8(0) === 0x08; }), map(function (buffer) { return buffer.readUInt8(5); })), defer(function () { return from(_this.write(Buffer.from([0x08, 0, 0, 0, 0]))); }).pipe(ignoreElements())).toPromise()];
-                                        case 1:
-                                            mtu = _b.sent();
-                                            return [3 /*break*/, 4];
-                                        case 2:
-                                            e_9 = _b.sent();
-                                            log("ble-error", "inferMTU got " + JSON.stringify(e_9));
-                                            return [4 /*yield*/, bleManagerInstance()
-                                                    .cancelDeviceConnection(this.id)["catch"](function () { })];
-                                        case 3:
-                                            _b.sent(); // but we ignore if disconnect worked.
-                                            throw remapError(e_9);
-                                        case 4: return [2 /*return*/];
-                                    }
-                                });
-                            }); })];
-                    case 1:
-                        _b.sent();
-                        if (mtu > 20) {
-                            this.mtuSize = mtu;
-                            log(TAG, "BleTransport(".concat(this.id, ") mtu set to ").concat(this.mtuSize));
-                        }
-                        return [2 /*return*/, this.mtuSize];
+    inferMTU() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let { mtu } = this.device;
+            yield this.exchangeAtomicImpl(() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    mtu = yield merge(this.notifyObservable.pipe(tap((maybeError) => {
+                        if (maybeError instanceof Error)
+                            throw 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())).toPromise();
                 }
-            });
+                catch (e) {
+                    log("ble-error", "inferMTU got " + JSON.stringify(e));
+                    yield bleManagerInstance()
+                        .cancelDeviceConnection(this.id)
+                        .catch(() => { }); // but we ignore if disconnect worked.
+                    throw remapError(e);
+                }
+            }));
+            if (mtu > 20) {
+                this.mtuSize = mtu;
+                log(TAG, `BleTransport(${this.id}) mtu set to ${this.mtuSize}`);
+            }
+            return this.mtuSize;
         });
-    };
+    }
     /**
      * Exposed method from the ble-plx library
      * Request the connection priority for the given device.
      * @param {"Balanced" | "High" | "LowPower"} connectionPriority: Connection priority.
      * @returns {Promise<Device>} Connected device.
      */
-    BleTransport.prototype.requestConnectionPriority = function (connectionPriority) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, decoratePromiseErrors(this.device.requestConnectionPriority(ConnectionPriority[connectionPriority]))];
-                    case 1: return [2 /*return*/, _b.sent()];
-                }
-            });
+    requestConnectionPriority(connectionPriority) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield decoratePromiseErrors(this.device.requestConnectionPriority(ConnectionPriority[connectionPriority]));
         });
-    };
+    }
     /**
      * We intentionally do not immediately close a transport connection.
      * Instead, we queue the disconnect and wait for a future connection to dismiss the event.
@@ -665,88 +486,67 @@ var BleTransport = /** @class */ (function (_super) {
      * already been disconnected.
      * @returns {Promise<void>}
      */
-    BleTransport.prototype.close = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var resolve, disconnectPromise;
-            var _this = this;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        disconnectPromise = new Promise(function (innerResolve) {
-                            resolve = innerResolve;
-                        });
-                        clearDisconnectTimeout(this.id);
-                        log(TAG, "Queuing a disconnect");
-                        this.disconnectTimeout = setTimeout(function () {
-                            log(TAG, "Triggering a disconnect from ".concat(_this.id));
-                            if (_this.isConnected) {
-                                BleTransport.disconnect(_this.id)["catch"](function () { })["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.
-                        return [4 /*yield*/, Promise.race([
-                                this.exchangeBusyPromise || Promise.resolve(),
-                                disconnectPromise,
-                            ])];
-                    case 1:
-                        // The closure will occur no later than 5s, triggered either by disconnection
-                        // or the actual response of the apdu.
-                        _b.sent();
-                        return [2 /*return*/];
-                }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let resolve;
+            const disconnectPromise = new Promise((innerResolve) => {
+                resolve = innerResolve;
             });
+            clearDisconnectTimeout(this.id);
+            log(TAG, "Queuing a disconnect");
+            this.disconnectTimeout = setTimeout(() => {
+                log(TAG, `Triggering a disconnect from ${this.id}`);
+                if (this.isConnected) {
+                    BleTransport.disconnect(this.id)
+                        .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.
+            yield Promise.race([
+                this.exchangeBusyPromise || Promise.resolve(),
+                disconnectPromise,
+            ]);
+            return;
         });
-    };
-    var _a;
-    _a = BleTransport;
-    BleTransport.disconnectTimeoutMs = 5000;
-    /**
-     *
-     */
-    BleTransport.isSupported = function () {
-        return Promise.resolve(typeof BleManager === "function");
-    };
-    /**
-     *
-     */
-    BleTransport.list = function () {
-        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 = function (logLevel) {
-        if (Object.values(LogLevel).includes(logLevel)) {
-            bleManagerInstance().setLogLevel(logLevel);
-        }
-        else {
-            throw new Error("".concat(logLevel, " is not a valid LogLevel"));
-        }
-    };
-    /**
-     * Exposed method from the ble-plx library
-     * Disconnects from {@link Device} if it's connected or cancels pending connection.
-     */
-    BleTransport.disconnect = function (id) { return __awaiter(void 0, void 0, void 0, function () {
-        return __generator(_a, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    log(TAG, "user disconnect(".concat(id, ")"));
-                    return [4 /*yield*/, bleManagerInstance().cancelDeviceConnection(id)];
-                case 1:
-                    _b.sent();
-                    log(TAG, "disconnected");
-                    return [2 /*return*/];
-            }
-        });
-    }); };
-    return BleTransport;
-}(Transport));
-export default BleTransport;
+    }
+}
+_a = BleTransport;
+BleTransport.disconnectTimeoutMs = 5000;
+/**
+ *
+ */
+BleTransport.isSupported = () => Promise.resolve(typeof BleManager === "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 = (logLevel) => {
+    if (Object.values(LogLevel).includes(logLevel)) {
+        bleManagerInstance().setLogLevel(logLevel);
+    }
+    else {
+        throw new Error(`${logLevel} is not a valid LogLevel`);
+    }
+};
+/**
+ * Exposed method from the ble-plx library
+ * Disconnects from {@link Device} if it's connected or cancels pending connection.
+ */
+BleTransport.disconnect = (id) => __awaiter(void 0, void 0, void 0, function* () {
+    log(TAG, `user disconnect(${id})`);
+    yield bleManagerInstance().cancelDeviceConnection(id);
+    log(TAG, "disconnected");
+});
 //# sourceMappingURL=BleTransport.js.map