@ledgerhq/live-common 26.0.0 → 26.1.0-next.0

package/src/ble/hooks/useBleDevicesScanning.test.ts

@@ -0,0 +1,252 @@
+import { renderHook, act } from "@testing-library/react-hooks";
+import type {
+  Observer as TransportObserver,
+  Subscription as TransportSubscription,
+  DescriptorEvent,
+} from "@ledgerhq/hw-transport";
+import { DeviceModelId, getDeviceModel } from "@ledgerhq/devices";
+import { useBleDevicesScanning } from "./useBleDevicesScanning";
+import type { TransportBleDevice } from "../types";
+
+jest.useFakeTimers();
+
+// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+const nanoXServiceUuid = getDeviceModel(DeviceModelId.nanoX).bluetoothSpec![0]
+  .serviceUuid;
+// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+const nanoFTSServiceUuid = getDeviceModel(DeviceModelId.nanoFTS)
+  .bluetoothSpec![0].serviceUuid;
+
+// Fake devices info we would get from the bluetooth transport listen
+const aTransportBleDevice = (overrideProps?: Partial<TransportBleDevice>) => {
+  return {
+    id: "aBleNanoId",
+    name: "aBleNano",
+    localName: null,
+    rssi: 50,
+    mtu: 50,
+    serviceUUIDs: [nanoXServiceUuid],
+    ...overrideProps,
+  };
+};
+
+type bleTransportListenObserver = TransportObserver<
+  DescriptorEvent<TransportBleDevice | null>
+>;
+
+// HOF creating a mocked Transport listen method to be given to useBleDevicesScanning
+const setupMockBleTransportListen =
+  (mockEmitValuesByObserver: (observer: bleTransportListenObserver) => void) =>
+  (observer: bleTransportListenObserver): TransportSubscription => {
+    mockEmitValuesByObserver(observer);
+
+    const unsubscribe = () => {};
+
+    return {
+      unsubscribe,
+    };
+  };
+
+describe("useBleDevicesScanning", () => {
+  afterEach(() => {
+    jest.clearAllTimers();
+  });
+
+  describe("When several unique devices are found by the scanner", () => {
+    const deviceIdA = "ID_A";
+    const deviceIdB = "ID_B";
+    const deviceIdC = "ID_C";
+
+    const mockEmitValuesByObserver = (observer: bleTransportListenObserver) => {
+      observer.next({
+        type: "add",
+        descriptor: aTransportBleDevice({ id: deviceIdA }),
+      });
+
+      setTimeout(() => {
+        observer.next({
+          type: "add",
+          descriptor: aTransportBleDevice({
+            id: deviceIdB,
+            serviceUUIDs: [nanoFTSServiceUuid],
+          }),
+        });
+      }, 1000);
+
+      setTimeout(() => {
+        observer.next({
+          type: "add",
+          descriptor: aTransportBleDevice({ id: deviceIdC }),
+        });
+      }, 2000);
+    };
+
+    describe("and when no filters are applied to the scanning", () => {
+      it("should update the list of scanned devices for each new scanned device", async () => {
+        const { result } = renderHook(() =>
+          useBleDevicesScanning({
+            bleTransportListen: setupMockBleTransportListen(
+              mockEmitValuesByObserver
+            ),
+          })
+        );
+
+        expect(result.current.scannedDevices).toHaveLength(1);
+        expect(result.current.scannedDevices[0].deviceId).toBe(deviceIdA);
+        // The model was correctly deduced from the ble spec
+        expect(result.current.scannedDevices[0].deviceModel.id).toBe(
+          DeviceModelId.nanoX
+        );
+
+        await act(async () => {
+          jest.advanceTimersByTime(1000);
+        });
+
+        expect(result.current.scannedDevices).toHaveLength(2);
+        expect(result.current.scannedDevices[1].deviceId).toBe(deviceIdB);
+        expect(result.current.scannedDevices[1].deviceModel.id).toBe(
+          DeviceModelId.nanoFTS
+        );
+      });
+    });
+
+    describe("and when filterModelIds is not null", () => {
+      it("should filter the scanning result by the given model ids", async () => {
+        const { result } = renderHook(() =>
+          useBleDevicesScanning({
+            bleTransportListen: setupMockBleTransportListen(
+              mockEmitValuesByObserver
+            ),
+            filterByModelIds: [DeviceModelId.nanoX],
+          })
+        );
+
+        // The first scanned device was a nanoX
+        expect(result.current.scannedDevices).toHaveLength(1);
+        expect(result.current.scannedDevices[0].deviceId).toBe(deviceIdA);
+        // The model was correctly deduced from the ble spec
+        expect(result.current.scannedDevices[0].deviceModel.id).toBe(
+          DeviceModelId.nanoX
+        );
+
+        await act(async () => {
+          jest.advanceTimersByTime(1000);
+        });
+
+        // The second scanned device was a nanoFTS, and was filtered out
+        expect(result.current.scannedDevices).toHaveLength(1);
+
+        await act(async () => {
+          jest.advanceTimersByTime(1000);
+        });
+
+        // The third scanned device was a nanoX
+        expect(result.current.scannedDevices).toHaveLength(2);
+        expect(result.current.scannedDevices[1].deviceId).toBe(deviceIdC);
+        expect(result.current.scannedDevices[1].deviceModel.id).toBe(
+          DeviceModelId.nanoX
+        );
+      });
+    });
+
+    describe("and when the hook consumer stops the scanning", () => {
+      it("should stop the scanning", async () => {
+        let stopBleScanning = false;
+
+        const { result, rerender } = renderHook(() =>
+          useBleDevicesScanning({
+            bleTransportListen: setupMockBleTransportListen(
+              mockEmitValuesByObserver
+            ),
+            stopBleScanning,
+          })
+        );
+
+        // At first the scanning finds device(s)
+        expect(result.current.scannedDevices).toHaveLength(1);
+        expect(result.current.scannedDevices[0].deviceId).toBe(deviceIdA);
+        expect(result.current.scannedDevices[0].deviceModel.id).toBe(
+          DeviceModelId.nanoX
+        );
+
+        // Then the consumer stops the scanning
+        stopBleScanning = true;
+        rerender({
+          bleTransportListen: setupMockBleTransportListen(
+            mockEmitValuesByObserver
+          ),
+          stopBleScanning,
+        });
+
+        await act(async () => {
+          jest.advanceTimersByTime(2000);
+        });
+
+        // It should not find any new devices
+        expect(result.current.scannedDevices).toHaveLength(1);
+      });
+    });
+  });
+
+  describe("When the same device is being scanned several times", () => {
+    const deviceIdA = "ID_A";
+    const deviceIdB = "ID_B";
+
+    const mockEmitValuesByObserver = (observer: bleTransportListenObserver) => {
+      observer.next({
+        type: "add",
+        descriptor: aTransportBleDevice({ id: deviceIdA }),
+      });
+
+      setTimeout(() => {
+        observer.next({
+          type: "add",
+          descriptor: aTransportBleDevice({ id: deviceIdA }),
+        });
+      }, 1000);
+
+      setTimeout(() => {
+        observer.next({
+          type: "add",
+          descriptor: aTransportBleDevice({ id: deviceIdB }),
+        });
+      }, 2000);
+    };
+
+    it("should update the list of scanned devices without any duplicate", async () => {
+      const { result } = renderHook(() =>
+        useBleDevicesScanning({
+          bleTransportListen: setupMockBleTransportListen(
+            mockEmitValuesByObserver
+          ),
+        })
+      );
+
+      // The first time it gets the device from the scanning
+      expect(result.current.scannedDevices).toHaveLength(1);
+      expect(result.current.scannedDevices[0].deviceId).toBe(deviceIdA);
+      expect(result.current.scannedDevices[0].deviceModel.id).toBe(
+        DeviceModelId.nanoX
+      );
+
+      await act(async () => {
+        jest.advanceTimersByTime(1000);
+      });
+
+      // The second time it gets the same device from the scanning
+      // It should not have been added to the list
+      expect(result.current.scannedDevices).toHaveLength(1);
+
+      await act(async () => {
+        jest.advanceTimersByTime(1000);
+      });
+
+      // The third time it gets a new device
+      expect(result.current.scannedDevices).toHaveLength(2);
+      expect(result.current.scannedDevices[1].deviceId).toBe(deviceIdB);
+      expect(result.current.scannedDevices[1].deviceModel.id).toBe(
+        DeviceModelId.nanoX
+      );
+    });
+  });
+});

package/src/ble/hooks/useBleDevicesScanning.ts

@@ -0,0 +1,147 @@
+import { useState, useEffect, useRef } from "react";
+import { Observable, of } from "rxjs";
+import { concatAll } from "rxjs/operators";
+import { getInfosForServiceUuid } from "@ledgerhq/devices";
+import type { DeviceModelId } from "@ledgerhq/types-devices";
+import type {
+  Observer as TransportObserver,
+  Subscription as TransportSubscription,
+  DescriptorEvent,
+  DescriptorEventType,
+} from "@ledgerhq/hw-transport";
+import { TransportBleDevice, ScannedDevice, BleError } from "../types";
+
+export type ScanningBleError = BleError | null;
+
+export type UseBleDevicesScanningResult = {
+  scannedDevices: ScannedDevice[];
+  scanningBleError: ScanningBleError;
+};
+
+export type UseBleDevicesScanningDependencies = {
+  bleTransportListen: (
+    observer: TransportObserver<DescriptorEvent<TransportBleDevice | null>>
+  ) => TransportSubscription;
+};
+
+export type UseBleDevicesScanningOptions = {
+  stopBleScanning?: boolean;
+  filterByModelIds?: DeviceModelId[];
+};
+
+const DEFAULT_DEVICE_NAME = "Device";
+
+/**
+ * Scans the BLE devices around the user
+ * @param filterByModelIds An array of model ids to filter on
+ * @param stopBleScanning Flag to stop or continue the scanning
+ * @returns An object containing:
+ * - scannedDevices: list of ScannedDevice found by the scanning
+ * - scanningBleError: if an error occurred, a BleError, otherwise null
+ */
+export const useBleDevicesScanning = ({
+  bleTransportListen,
+  stopBleScanning,
+  filterByModelIds,
+}: UseBleDevicesScanningDependencies &
+  UseBleDevicesScanningOptions): UseBleDevicesScanningResult => {
+  const [scanningBleError, setScanningBleError] =
+    useState<ScanningBleError>(null);
+  const [scannedDevices, setScannedDevices] = useState<ScannedDevice[]>([]);
+  // To check for duplicates. The ref will persist for the full lifetime of the component
+  // in which the hook is called.
+  // We could use the current value of scannedDevices inside setScannedDevices
+  // but the check would only be done at the end of the process when calling setScannedDevices.
+  const scannedDevicesRef = useRef<ScannedDevice[]>([]);
+
+  useEffect(() => {
+    if (stopBleScanning) {
+      return;
+    }
+
+    const bleScanningSource = new Observable(bleTransportListen);
+
+    // Concat to flatten the events emitted by the scanning, that could arrive too fast
+    const sub = of(bleScanningSource)
+      .pipe(concatAll())
+      .subscribe({
+        next: (event: {
+          type: DescriptorEventType;
+          descriptor: TransportBleDevice | null;
+        }) => {
+          setScanningBleError(null);
+          const { type, descriptor } = event;
+
+          if (type === "add" && descriptor) {
+            const transportDevice = descriptor;
+
+            const isScannedDeviceDuplicate = scannedDevicesRef.current.some(
+              (d) => d.deviceId === transportDevice.id
+            );
+
+            // Avoiding duplicates
+            if (isScannedDeviceDuplicate) {
+              return;
+            }
+
+            if (
+              transportDevice.serviceUUIDs &&
+              transportDevice.serviceUUIDs.length > 0
+            ) {
+              const bleInfo = getInfosForServiceUuid(
+                transportDevice.serviceUUIDs[0]
+              );
+
+              if (!bleInfo) {
+                return;
+              }
+
+              // Filters on the model ids, if asked
+              if (
+                filterByModelIds &&
+                !filterByModelIds.includes(bleInfo.deviceModel.id)
+              ) {
+                return;
+              }
+
+              const newScannedDevice = {
+                deviceModel: bleInfo.deviceModel,
+                deviceName:
+                  transportDevice.localName ??
+                  transportDevice.name ??
+                  DEFAULT_DEVICE_NAME,
+                deviceId: transportDevice.id,
+                bleRssi: transportDevice.rssi,
+              };
+
+              setScannedDevices((scannedDevices) => [
+                ...scannedDevices,
+                newScannedDevice,
+              ]);
+              scannedDevicesRef.current.push(newScannedDevice);
+            }
+          }
+        },
+        error: (error: BleError) => {
+          // TODO: we should be sure to have a BleError
+          if (error.errorCode) {
+            setScanningBleError(error);
+          }
+        },
+      });
+
+    return () => {
+      sub.unsubscribe();
+    };
+  }, [
+    bleTransportListen,
+    stopBleScanning,
+    filterByModelIds,
+    setScannedDevices,
+  ]);
+
+  return {
+    scannedDevices,
+    scanningBleError,
+  };
+};

package/src/ble/types.ts

@@ -0,0 +1,42 @@
+import type { DeviceModel } from "@ledgerhq/types-devices";
+
+// Inspired by Device class from react-native-ble-plx
+// Should be exported from somewhere else
+// TODO: Update after BIM transport is finished
+export type TransportBleDevice = {
+  // Device identifier: MAC address on Android and UUID on iOS.
+  id: string;
+  // Device name
+  name: string | null;
+  // User friendly name of device.
+  localName: string | null;
+  // Current Received Signal Strength Indication of device
+  rssi: number | null;
+  // Current Maximum Transmission Unit for this device.
+  // When device is not connected default value of 23 is used.
+  mtu: number;
+  // List of available services visible during scanning.
+  serviceUUIDs: string[] | null;
+  // Allows any other properties
+  [otherOptions: string]: unknown;
+};
+
+// Inspired by BleError class from react-native-ble-plx
+// BleError should be an error class which is guaranteed to be thrown by all functions
+// by our different implementations of Transport or at least of ble implementation of Transport
+// TODO: BleError should probably be a class and update after BIM transport is finished
+export type BleError = Error & {
+  // Platform independent error code.
+  // It is defined as an enum named BleErrorCode in react-native-ble-plx
+  // We should have our own mapping
+  errorCode: number;
+  // Allows any other properties
+  [otherOptions: string]: unknown;
+};
+
+export type ScannedDevice = {
+  deviceId: string;
+  deviceName: string;
+  bleRssi: number | null;
+  deviceModel: DeviceModel;
+};

package/src/families/cardano/js-estimateMaxSpendable.ts

@@ -1,4 +1,5 @@
 import { BigNumber } from "bignumber.js";
+import { log } from "@ledgerhq/logs";
 import type { AccountLike, Account } from "@ledgerhq/types-live";
 import { getMainAccount } from "../../account";
 import type { CardanoAccount, Transaction } from "./types";
@@ -42,6 +43,7 @@ const estimateMaxSpendable = async ({
   try {
     typhonTransaction = await buildTransaction(a as CardanoAccount, t);
   } catch (error) {
+    log("cardano-error", "Failed to estimate max spendable: " + String(error));
     return new BigNumber(0);
   }
   const transactionAmount = typhonTransaction

package/src/families/cosmos/specs.ts

@@ -154,7 +154,7 @@ const cosmos: AppSpec<Transaction> = {
           count
         )
           .minus(minAmount.times(2))
-          .times(0.5 * Math.random());
+          .times(0.25 * Math.random());
         invariant(remaining.gt(0), "not enough funds in account for delegate");
         const all = data.validators.filter(
           (v) =>
@@ -298,7 +298,7 @@ const cosmos: AppSpec<Transaction> = {
         const amount = (sourceDelegation as CosmosDelegation).amount
           .times(
             // most of the time redelegate all
-            Math.random() > 0.3 ? 1 : Math.random()
+            Math.random() > 0.2 ? 1 : Math.random()
           )
           .integerValue();
         invariant(amount.gt(0), "random amount to be positive");

package/src/families/elrond/specs.ts

@@ -54,7 +54,7 @@ const elrondSpec: AppSpec<Transaction> = {
           transaction: bridge.createTransaction(account),
           updates: [
             {
-              recipient: pickSiblings(siblings, 1).freshAddress,
+              recipient: sibling.freshAddress,
             },
             {
               amount,

package/src/families/polkadot/bridge.integration.test.ts

@@ -715,7 +715,7 @@ describe("canUnbond", () => {
         nominations: [],
         unlockings: [
           ...Array(MAX_UNLOCKINGS - 1).map(() => ({
-            amount: new BigNumber(Math.random()),
+            amount: new BigNumber(100000),
             completionDate: new Date(),
           })),
         ],
@@ -736,7 +736,7 @@ describe("canUnbond", () => {
         nominations: [],
         unlockings: [
           ...Array(MAX_UNLOCKINGS).map(() => ({
-            amount: new BigNumber(Math.random()),
+            amount: new BigNumber(100000),
             completionDate: new Date(),
           })),
         ],
@@ -757,7 +757,7 @@ describe("canUnbond", () => {
         nominations: [],
         unlockings: [
           ...Array(MAX_UNLOCKINGS).map(() => ({
-            amount: new BigNumber(Math.random()),
+            amount: new BigNumber(100000),
             completionDate: new Date(),
           })),
         ],

package/src/families/polkadot/specs.ts

@@ -21,6 +21,7 @@ import {
 } from "../../families/polkadot/logic";
 import { DeviceModelId } from "@ledgerhq/devices";
 
+const maxAccounts = 32;
 const currency = getCryptoCurrencyById("polkadot");
 // FIXME Should be replaced with EXISTENTIAL_DEPOSIT_RECOMMENDED_MARGIN in logic.ts
 const POLKADOT_MIN_SAFE = parseCurrencyUnit(currency.units[0], "0.1");
@@ -52,10 +53,10 @@ const polkadot: AppSpec<Transaction> = {
   mutations: [
     {
       name: "send 50%~",
-      maxRun: 2,
+      maxRun: 4,
       transaction: ({ account, siblings, bridge }) => {
         invariant((account as PolkadotAccount).polkadotResources, "polkadot");
-        const sibling = pickSiblings(siblings, 2);
+        const sibling = pickSiblings(siblings, maxAccounts);
         let amount = account.spendableBalance
           .div(1.9 + 0.2 * Math.random())
           .integerValue();
@@ -74,7 +75,7 @@ const polkadot: AppSpec<Transaction> = {
           transaction: bridge.createTransaction(account),
           updates: [
             {
-              recipient: pickSiblings(siblings, 1).freshAddress,
+              recipient: sibling.freshAddress,
             },
             {
               amount,

package/src/featureFlags/provider.tsx

@@ -10,10 +10,14 @@ import type { FeatureId, Feature } from "@ledgerhq/types-live";
 
 type State = {
   getFeature: (_: FeatureId) => Feature | null;
+  overrideFeature: (_: FeatureId, value: Feature) => void;
+  resetFeature: (_: FeatureId) => void;
 };
 
 const initialState: State = {
   getFeature: (_) => ({ enabled: false }),
+  overrideFeature: (_) => {},
+  resetFeature: (_) => {},
 };
 
 const FeatureFlagsContext = createContext<State>(initialState);
@@ -24,11 +28,15 @@ export function useFeatureFlags(): State {
 
 type Props = {
   getFeature: (_: FeatureId) => Feature | null;
+  overrideFeature: (_: FeatureId, value: Feature) => void;
+  resetFeature: (_: FeatureId) => void;
   children?: ReactNode;
 };
 
 export function FeatureFlagsProvider({
   getFeature,
+  overrideFeature,
+  resetFeature,
   children,
 }: Props): JSX.Element {
   const [state, setState] = useState<State>(initialState);
@@ -37,8 +45,10 @@ export function FeatureFlagsProvider({
     setState((prev) => ({
       ...prev,
       getFeature,
+      overrideFeature,
+      resetFeature,
     }));
-  }, [getFeature]);
+  }, [getFeature, overrideFeature, resetFeature]);
 
   return (
     <FeatureFlagsContext.Provider value={state}>

package/src/featureFlags/useFeature.ts

@@ -1,10 +1,14 @@
+import { useMemo } from "react";
 import { useFeatureFlags } from "./provider";
 import { FeatureId, Feature } from "@ledgerhq/types-live";
 
 const useFeature = (key: FeatureId): Feature | null => {
   const featureFlags = useFeatureFlags();
-
-  return featureFlags.getFeature(key);
+  const value = useMemo(
+    () => featureFlags.getFeature(key),
+    [featureFlags, key]
+  );
+  return value;
 };
 
 export default useFeature;

package/src/generated/account.ts

@@ -1,20 +1,12 @@
 import algorand from "../families/algorand/account";
-
 import bitcoin from "../families/bitcoin/account";
-
 import cosmos from "../families/cosmos/account";
-
 import crypto_org from "../families/crypto_org/account";
-
 import elrond from "../families/elrond/account";
-
 import filecoin from "../families/filecoin/account";
-
 import osmosis from "../families/osmosis/account";
-
 import polkadot from "../families/polkadot/account";
 
-
 export default {
   algorand,
   bitcoin,

package/src/generated/bridge/js.ts

@@ -1,40 +1,22 @@
 import algorand from "../../families/algorand/bridge/js";
-
 import bitcoin from "../../families/bitcoin/bridge/js";
-
 import cardano from "../../families/cardano/bridge/js";
-
 import celo from "../../families/celo/bridge/js";
-
 import cosmos from "../../families/cosmos/bridge/js";
-
 import crypto_org from "../../families/crypto_org/bridge/js";
-
 import elrond from "../../families/elrond/bridge/js";
-
 import ethereum from "../../families/ethereum/bridge/js";
-
 import filecoin from "../../families/filecoin/bridge/js";
-
 import hedera from "../../families/hedera/bridge/js";
-
 import neo from "../../families/neo/bridge/js";
-
 import osmosis from "../../families/osmosis/bridge/js";
-
 import polkadot from "../../families/polkadot/bridge/js";
-
 import ripple from "../../families/ripple/bridge/js";
-
 import solana from "../../families/solana/bridge/js";
-
 import stellar from "../../families/stellar/bridge/js";
-
 import tezos from "../../families/tezos/bridge/js";
-
 import tron from "../../families/tron/bridge/js";
 
-
 export default {
   algorand,
   bitcoin,

package/src/generated/bridge/mock.ts

@@ -1,20 +1,12 @@
 import algorand from "../../families/algorand/bridge/mock";
-
 import bitcoin from "../../families/bitcoin/bridge/mock";
-
 import cosmos from "../../families/cosmos/bridge/mock";
-
 import ethereum from "../../families/ethereum/bridge/mock";
-
 import ripple from "../../families/ripple/bridge/mock";
-
 import solana from "../../families/solana/bridge/mock";
-
 import stellar from "../../families/stellar/bridge/mock";
-
 import tezos from "../../families/tezos/bridge/mock";
 
-
 export default {
   algorand,
   bitcoin,