@ledgerhq/react-native-hw-transport-ble 6.31.0 → 6.32.0-next.0

package/src/BleTransport.ts

@@ -1,3 +1,4 @@
+import { v4 as uuid } from "uuid";
 import Transport from "@ledgerhq/hw-transport";
 import type {
   Subscription as TransportSubscription,
@@ -13,7 +14,6 @@ import type {
 // See: https://github.com/LedgerHQ/ledger-live/pull/879
 import { sendAPDU } from "@ledgerhq/devices/lib/ble/sendAPDU";
 import { receiveAPDU } from "@ledgerhq/devices/lib/ble/receiveAPDU";
-
 import {
   BleManager,
   ConnectionPriority,
@@ -33,8 +33,28 @@ import {
 } from "@ledgerhq/devices";
 import type { DeviceModel } from "@ledgerhq/devices";
 import { trace, LocalTracer, TraceContext } from "@ledgerhq/logs";
-import { Observable, defer, merge, from, of, throwError, Observer, firstValueFrom } from "rxjs";
-import { share, ignoreElements, first, map, tap, catchError } from "rxjs/operators";
+import {
+  Observable,
+  defer,
+  merge,
+  from,
+  of,
+  throwError,
+  Observer,
+  firstValueFrom,
+  TimeoutError,
+  SchedulerLike,
+} from "rxjs";
+import {
+  share,
+  ignoreElements,
+  first,
+  map,
+  tap,
+  catchError,
+  timeout,
+  finalize,
+} from "rxjs/operators";
 import {
   CantOpenDevice,
   TransportError,
@@ -42,10 +62,16 @@ import {
   PairingFailed,
   PeerRemovedPairing,
   HwTransportError,
+  TransportExchangeTimeoutError,
 } from "@ledgerhq/errors";
 import { monitorCharacteristic } from "./monitorCharacteristic";
 import { awaitsBleOn } from "./awaitsBleOn";
-import { decoratePromiseErrors, remapError, mapBleErrorToHwTransportError } from "./remapErrors";
+import {
+  decoratePromiseErrors,
+  remapError,
+  mapBleErrorToHwTransportError,
+  IOBleErrorRemap,
+} from "./remapErrors";
 import { ReconnectionConfig } from "./types";
 
 const LOG_TYPE = "ble-verbose";
@@ -123,8 +149,10 @@ const clearDisconnectTimeout = (deviceId: string, context?: TraceContext): void
  *
  * @param deviceOrId
  * @param needsReconnect
- * @param timeoutMs TODO: to keep, used in a separate PR
+ * @param timeoutMs Optional Timeout (in ms) applied during the connection with the device
  * @param context Optional tracing/log context
+ * @param injectedDependencies Contains optional injected dependencies used by the transport implementation
+ *  - rxjsScheduler: dependency injected RxJS scheduler to control time. Default AsyncScheduler.
  * @returns A BleTransport instance
  */
 async function open(
@@ -132,6 +160,7 @@ async function open(
   needsReconnect: boolean,
   timeoutMs?: number,
   context?: TraceContext,
+  { rxjsScheduler }: { rxjsScheduler?: SchedulerLike } = {},
 ) {
   const tracer = new LocalTracer(LOG_TYPE, context);
   let device: Device;
@@ -179,13 +208,16 @@ async function open(
 
       // Nb ConnectionOptions dropped since it's not used internally by ble-plx.
       try {
-        device = await bleManagerInstance().connectToDevice(deviceOrId, connectOptions);
+        device = await bleManagerInstance().connectToDevice(deviceOrId, {
+          ...connectOptions,
+          timeout: timeoutMs,
+        });
       } catch (e: any) {
         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 = await bleManagerInstance().connectToDevice(deviceOrId);
+          device = await bleManagerInstance().connectToDevice(deviceOrId, { timeout: timeoutMs });
         } else {
           throw e;
         }
@@ -203,7 +235,7 @@ async function open(
   if (!(await device.isConnected())) {
     tracer.trace(`Device found but not connected. connecting...`, { timeoutMs, connectOptions });
     try {
-      await device.connect({ ...connectOptions });
+      await device.connect({ ...connectOptions, timeout: timeoutMs });
     } catch (error: any) {
       tracer.trace(`Connect error`, { error });
       if (error.errorCode === BleErrorCode.DeviceMTUChangeFailed) {
@@ -221,6 +253,14 @@ async function open(
           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);
       } else {
         throw remapError(error);
       }
@@ -261,52 +301,56 @@ async function open(
     throw new TransportError("service not found", "BLEServiceNotFound");
   }
 
-  let writeC: Characteristic | null | undefined;
-  let writeCmdC: Characteristic | undefined;
-  let notifyC: Characteristic | null | undefined;
+  let writableWithResponseCharacteristic: Characteristic | null | undefined;
+  let writableWithoutResponseCharacteristic: Characteristic | undefined;
+  // A characteristic that can monitor value changes
+  let notifiableCharacteristic: Characteristic | null | undefined;
 
   for (const c of characteristics) {
     if (c.uuid === writeUuid) {
-      writeC = c;
+      writableWithResponseCharacteristic = c;
     } else if (c.uuid === writeCmdUuid) {
-      writeCmdC = c;
+      writableWithoutResponseCharacteristic = c;
     } else if (c.uuid === notifyUuid) {
-      notifyC = c;
+      notifiableCharacteristic = c;
     }
   }
 
-  if (!writeC) {
+  if (!writableWithResponseCharacteristic) {
     throw new TransportError("write characteristic not found", "BLECharacteristicNotFound");
   }
 
-  if (!notifyC) {
+  if (!notifiableCharacteristic) {
     throw new TransportError("notify characteristic not found", "BLECharacteristicNotFound");
   }
 
-  if (!writeC.isWritableWithResponse) {
+  if (!writableWithResponseCharacteristic.isWritableWithResponse) {
     throw new TransportError(
-      "write characteristic not writableWithResponse",
+      "The writable-with-response characteristic is not writable with response",
       "BLECharacteristicInvalid",
     );
   }
 
-  if (!notifyC.isNotifiable) {
+  if (!notifiableCharacteristic.isNotifiable) {
     throw new TransportError("notify characteristic not notifiable", "BLECharacteristicInvalid");
   }
 
-  if (writeCmdC) {
-    if (!writeCmdC.isWritableWithoutResponse) {
+  if (writableWithoutResponseCharacteristic) {
+    if (!writableWithoutResponseCharacteristic.isWritableWithoutResponse) {
       throw new TransportError(
-        "write cmd characteristic not writableWithoutResponse",
+        "The writable-without-response characteristic is not writable without response",
         "BLECharacteristicInvalid",
       );
     }
   }
 
   tracer.trace(`device.mtu=${device.mtu}`);
-  const notifyObservable = monitorCharacteristic(notifyC, context).pipe(
+
+  // 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))
@@ -316,19 +360,34 @@ async function open(
       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, writeC, writeCmdC, notifyObservable, deviceModel, {
-    context,
-  });
+  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: Subscription;
+
+  // Callbacks on `react-native-ble-plx` notifying the device has been disconnected
   const onDisconnect = (error: BleError | null) => {
     transport.isConnected = false;
     transport.notYetDisconnected = false;
@@ -338,7 +397,7 @@ async function open(
     clearDisconnectTimeout(transport.id);
     delete transportsCache[transport.id];
     tracer.trace(
-      `On device disconnected callback: cleared cached transport for ${transport.id}, emitting Transport event "disconnect"`,
+      `On device disconnected callback: cleared cached transport for ${transport.id}, emitting Transport event "disconnect. Error: ${error}"`,
       { reason: error },
     );
     transport.emit("disconnect", error);
@@ -371,7 +430,8 @@ async function open(
       }
 
       if (needsReconnect) {
-        await BleTransport.disconnect(transport.id).catch(() => {});
+        tracer.trace(`Device needs reconnection. Triggering a disconnect`);
+        await BleTransport.disconnectDevice(transport.id);
         await delay(reconnectionConfig.delayAfterFirstPairing);
       }
     } else {
@@ -467,7 +527,7 @@ export default class BleTransport extends Transport {
         if (devices.length) {
           tracer.trace("Disconnecting from all devices", { deviceCount: devices.length });
 
-          await Promise.all(devices.map(d => BleTransport.disconnect(d.id).catch(() => {})));
+          await Promise.all(devices.map(d => BleTransport.disconnectDevice(d.id)));
         }
 
         if (unsubscribed) return;
@@ -513,34 +573,40 @@ export default class BleTransport extends Transport {
    * Opens a BLE transport
    *
    * @param {Device | string} deviceOrId
-   * @param timeoutMs TODO: to keep, used in a separate PR
+   * @param timeoutMs Applied when trying to connect to a device
    * @param context An optional context object for log/tracing strategy
+   * @param injectedDependencies Contains optional injected dependencies used by the transport implementation
+   *  - rxjsScheduler: dependency injected RxJS scheduler to control time. Default AsyncScheduler.
    */
   static async open(
     deviceOrId: Device | string,
     timeoutMs?: number,
     context?: TraceContext,
+    { rxjsScheduler }: { rxjsScheduler?: SchedulerLike } = {},
   ): Promise<BleTransport> {
-    return open(deviceOrId, true, timeoutMs, context);
+    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 disconnect = async (id: DeviceId, context?: TraceContext): Promise<void> => {
-    trace({
-      type: LOG_TYPE,
-      message: `Trying to disconnect device ${id})`,
-      context,
-    });
-    await bleManagerInstance().cancelDeviceConnection(id);
-    trace({
-      type: LOG_TYPE,
-      message: `Device ${id} disconnected`,
-      context,
-    });
+  static disconnectDevice = async (id: DeviceId, context?: TraceContext): Promise<void> => {
+    const tracer = new LocalTracer(LOG_TYPE, context);
+    tracer.trace(`Trying to disconnect device ${id}`);
+
+    await bleManagerInstance()
+      .cancelDeviceConnection(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: Device;
@@ -549,26 +615,47 @@ export default class BleTransport extends Transport {
   id: string;
   isConnected = true;
   mtuSize = 20;
-  notifyObservable: Observable<any>;
+  // Observable emitting data received from the device via BLE
+  notifyObservable: Observable<Buffer | Error>;
   notYetDisconnected = true;
-  writeCharacteristic: Characteristic;
-  writeCmdCharacteristic: Characteristic | undefined;
+  writableWithResponseCharacteristic: Characteristic;
+  writableWithoutResponseCharacteristic: Characteristic | undefined;
+  rxjsScheduler?: SchedulerLike;
+  // Transaction ids of communication operations that are currently pending
+  currentTransactionIds: Array<string>;
 
+  /**
+   * The static `open` function is used to handle BleTransport instantiation
+   *
+   * @param device
+   * @param writableWithResponseCharacteristic A BLE characteristic that we can write on,
+   *   and that will be acknowledged in response from the device when it receives the written value.
+   * @param writableWithoutResponseCharacteristic A BLE characteristic that we can write on,
+   *   and that will not be acknowledged in response from the device
+   * @param notifyObservable A multicast observable that emits messages received from the device
+   * @param deviceModel
+   * @param params Contains optional options and injected dependencies used by the transport implementation
+   *  - abortTimeoutMs: stop the exchange after a given timeout. Another timeout exists
+   *    to detect unresponsive device (see `unresponsiveTimeout`). This timeout aborts the exchange.
+   *  - rxjsScheduler: dependency injected RxJS scheduler to control time. Default: AsyncScheduler.
+   */
   constructor(
     device: Device,
-    writeCharacteristic: Characteristic,
-    writeCmdCharacteristic: Characteristic | undefined,
-    notifyObservable: Observable<any>,
+    writableWithResponseCharacteristic: Characteristic,
+    writableWithoutResponseCharacteristic: Characteristic | undefined,
+    notifyObservable: Observable<Buffer | Error>,
     deviceModel: DeviceModel,
-    { context }: { context?: TraceContext } = {},
+    { context, rxjsScheduler }: { context?: TraceContext; rxjsScheduler?: SchedulerLike } = {},
   ) {
     super({ context, logType: LOG_TYPE });
     this.id = device.id;
     this.device = device;
-    this.writeCharacteristic = writeCharacteristic;
-    this.writeCmdCharacteristic = writeCmdCharacteristic;
+    this.writableWithResponseCharacteristic = writableWithResponseCharacteristic;
+    this.writableWithoutResponseCharacteristic = writableWithoutResponseCharacteristic;
     this.notifyObservable = notifyObservable;
     this.deviceModel = deviceModel;
+    this.rxjsScheduler = rxjsScheduler;
+    this.currentTransactionIds = [];
 
     clearDisconnectTimeout(this.id);
 
@@ -576,50 +663,111 @@ export default class BleTransport extends Transport {
   }
 
   /**
-   * Send data to the device using a low level API.
-   * It's recommended to use the "send" method for a higher level API.
+   * 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 {Buffer} apdu - The data to send.
-   * @returns {Promise<Buffer>} A promise that resolves with the response data from the device.
+   * @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 = (apdu: Buffer): Promise<any> => {
+  exchange = (
+    message: Buffer,
+    { abortTimeoutMs }: { abortTimeoutMs?: number } = {},
+  ): Promise<Buffer> => {
     const tracer = this.tracer.withUpdatedContext({
       function: "exchange",
     });
-    tracer.trace("Exchanging APDU ...");
-
-    return this.exchangeAtomicImpl(async () => {
-      try {
-        const msgIn = apdu.toString("hex");
-        tracer.withType("apdu").trace(`=> ${msgIn}`);
-
-        const data = await firstValueFrom(
-          merge(this.notifyObservable.pipe(receiveAPDU), sendAPDU(this.write, apdu, this.mtuSize)),
-        );
-
-        const msgOut = data.toString("hex");
-        tracer.withType("apdu").trace(`<= ${msgOut}`);
+    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
+              this.cancelPendingOperations();
+
+              throw new TransportExchangeTimeoutError("Exchange aborted due to timeout");
+            }
 
-        return data;
-      } catch (error: any) {
-        tracer.withType("ble-error").trace(`Error while exchanging APDU`, { error });
+            tracer.withType("ble-error").trace(`Error while exchanging APDU`, { error });
 
-        if (this.notYetDisconnected) {
-          // in such case we will always disconnect because something is bad.
-          await bleManagerInstance()
-            .cancelDeviceConnection(this.id)
-            .catch(() => {}); // but we ignore if disconnect worked.
-        }
+            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;
-      }
+            const mappedError = remapError(error as IOBleErrorRemap);
+            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
+   *
+   * Cancelling transaction which doesn't exist is ignored.
+   *
+   * Note: cancelling `writableWithoutResponseCharacteristic.write...` will throw a `BleError` with code `OperationCancelled`
+   * but this error should be ignored. (In `exchange` our observable is unsubscribed before `cancelPendingOperations`
+   * is called so the error is ignored)
+   */
+  private cancelPendingOperations() {
+    for (const transactionId of this.currentTransactionIds) {
+      try {
+        this.tracer.trace("Cancelling operation", { transactionId });
+        bleManagerInstance().cancelTransaction(transactionId);
+      } catch (error) {
+        this.tracer.trace("Error while cancelling operation", { transactionId, error });
+      }
+    }
+  }
+
+  /**
+   * Sets the collection of current transaction ids to an empty array
+   */
+  private clearCurrentTransactionIds() {
+    this.currentTransactionIds = [];
+  }
+
   /**
    * Negotiate with the device the maximum transfer unit for the ble frames
    * @returns Promise<number>
@@ -633,8 +781,13 @@ export default class BleTransport extends Transport {
         mtu = await firstValueFrom(
           merge(
             this.notifyObservable.pipe(
-              tap(maybeError => {
-                if (maybeError instanceof Error) throw maybeError;
+              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)),
@@ -645,15 +798,16 @@ export default class BleTransport extends Transport {
       } catch (error: any) {
         this.tracer.withType("ble-error").trace("Error while inferring MTU", { mtu });
 
-        await bleManagerInstance()
-          .cancelDeviceConnection(this.id)
-          .catch(() => {}); // but we ignore if disconnect worked.
+        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();
       }
     });
 
@@ -685,19 +839,41 @@ export default class BleTransport extends Transport {
   /**
    * 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
+   *
+   * 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: Buffer, txid?: string | undefined): Promise<void> => {
+  write = async (buffer: Buffer): Promise<void> => {
+    const transactionId = uuid();
+    this.currentTransactionIds.push(transactionId);
+
+    const tracer = this.tracer.withUpdatedContext({ transactionId });
+    tracer.trace("Writing to device", {
+      willMessageBeAcked: !this.writableWithoutResponseCharacteristic,
+    });
+
     try {
-      if (!this.writeCmdCharacteristic) {
-        await this.writeCharacteristic.writeWithResponse(buffer.toString("base64"), txid);
+      if (!this.writableWithoutResponseCharacteristic) {
+        // The message will be acked in response by the device
+        await this.writableWithResponseCharacteristic.writeWithResponse(
+          buffer.toString("base64"),
+          transactionId,
+        );
       } else {
-        await this.writeCmdCharacteristic.writeWithoutResponse(buffer.toString("base64"), txid);
+        // The message won't be acked in response by the device
+        await this.writableWithoutResponseCharacteristic.writeWithoutResponse(
+          buffer.toString("base64"),
+          transactionId,
+        );
       }
-      this.tracer.withType("ble-frame").trace("=> " + buffer.toString("hex"));
+      tracer.withType("ble-frame").trace("=> " + buffer.toString("hex"));
     } catch (error: unknown) {
-      this.tracer.trace("Error while writing APDU", { error });
+      tracer.trace("Error while writing APDU", { error });
       throw new DisconnectedDeviceDuringOperation(
         error instanceof Error ? error.message : `${error}`,
       );
@@ -713,7 +889,8 @@ export default class BleTransport extends Transport {
    * @returns {Promise<void>}
    */
   async close(): Promise<void> {
-    this.tracer.trace("Closing, queuing a disconnect ...");
+    const tracer = this.tracer.withUpdatedContext({ function: "close" });
+    tracer.trace("Closing, queuing a disconnect with a timeout ...");
 
     let resolve: (value: void | PromiseLike<void>) => void;
     const disconnectPromise = new Promise<void>(innerResolve => {
@@ -723,8 +900,9 @@ export default class BleTransport extends Transport {
     clearDisconnectTimeout(this.id);
 
     this.disconnectTimeout = setTimeout(() => {
+      tracer.trace("Disconnect timeout has been reached ...");
       if (this.isConnected) {
-        BleTransport.disconnect(this.id, this.tracer.getContext())
+        BleTransport.disconnectDevice(this.id, tracer.getContext())
           .catch(() => {})
           .finally(resolve);
       } else {

package/src/remapErrors.ts

@@ -7,7 +7,8 @@ import {
 } from "@ledgerhq/errors";
 import { BleATTErrorCode, BleError, BleErrorCode } from "react-native-ble-plx";
 
-type IOBleErrorRemap = Error | BleError | null | undefined;
+export type IOBleErrorRemap = Error | BleError | null | undefined;
+
 export const remapError = (error: IOBleErrorRemap): IOBleErrorRemap => {
   if (!error || !error.message) return error;