@ledgerhq/live-common 27.0.0 → 27.0.1-next.0

package/src/families/tron/specs.ts

@@ -7,11 +7,12 @@ import sampleSize from "lodash/sampleSize";
 import get from "lodash/get";
 import type { Transaction, TronAccount } from "./types";
 import { getCryptoCurrencyById, parseCurrencyUnit } from "../../currencies";
-import { pickSiblings } from "../../bot/specs";
+import { botTest, pickSiblings } from "../../bot/specs";
 import type { AppSpec } from "../../bot/types";
 import { getUnfreezeData, getNextRewardDate } from "./react";
 import { DeviceModelId } from "@ledgerhq/devices";
 import { SubAccount } from "@ledgerhq/types-live";
+import { acceptTransaction } from "./speculos-deviceActions";
 const currency = getCryptoCurrencyById("tron");
 const minimalAmount = parseCurrencyUnit(currency.units[0], "1");
 const maxAccount = 10;
@@ -19,6 +20,16 @@ const maxAccount = 10;
 const getDecimalPart = (value: BigNumber, magnitude: number) =>
   value.minus(value.modulo(10 ** magnitude));
 
+const expectedApproximate = (
+  value: BigNumber,
+  expected: BigNumber,
+  delta = 50
+) => {
+  if (value.minus(expected).abs().gt(delta)) {
+    expect(value.toString()).toEqual(value.toString());
+  }
+};
+
 const tron: AppSpec<Transaction> = {
   name: "Tron",
   currency,
@@ -26,6 +37,7 @@ const tron: AppSpec<Transaction> = {
     model: DeviceModelId.nanoS,
     appName: "Tron",
   },
+  genericDeviceAction: acceptTransaction,
   testTimeout: 2 * 60 * 1000,
   mutations: [
     {
@@ -49,10 +61,11 @@ const tron: AppSpec<Transaction> = {
         };
       },
       test: ({ accountBeforeTransaction, operation, account }) => {
-        expect(account.spendableBalance.toString()).toBe(
-          accountBeforeTransaction.spendableBalance
-            .minus(operation.value)
-            .toString()
+        botTest("account spendable balance decreased with operation", () =>
+          expectedApproximate(
+            account.spendableBalance,
+            accountBeforeTransaction.spendableBalance.minus(operation.value)
+          )
         );
       },
     },
@@ -76,7 +89,9 @@ const tron: AppSpec<Transaction> = {
         };
       },
       test: ({ account }) => {
-        expect(account.spendableBalance.toString()).toBe("0");
+        botTest("account spendable balance is zero", () =>
+          expect(account.spendableBalance.toString()).toBe("0")
+        );
       },
     },
     {
@@ -124,8 +139,10 @@ const tron: AppSpec<Transaction> = {
           `tronResources.frozen.${resourceType}.amount`,
           new BigNumber(0)
         );
-        expect(expectedAmount.toString()).toBe(
-          currentRessourceAmount.toString()
+        botTest("frozen amount is accumulated in resources", () =>
+          expect(expectedAmount.toString()).toBe(
+            currentRessourceAmount.toString()
+          )
         );
       },
     },
@@ -164,7 +181,9 @@ const tron: AppSpec<Transaction> = {
           `tronResources.frozen.${TxResource}`,
           undefined
         );
-        expect(currentFrozen).toBeUndefined();
+        botTest("no current frozen", () =>
+          expect(currentFrozen).toBeUndefined()
+        );
         const TPBeforeTx = new BigNumber(
           get(accountBeforeTransaction, "tronResources.tronPower", 0)
         );
@@ -172,7 +191,9 @@ const tron: AppSpec<Transaction> = {
           get(account, "tronResources.tronPower", 0)
         );
         const expectedTronPower = TPBeforeTx.minus(transaction.amount);
-        expect(currentTP.toString()).toBe(expectedTronPower.toString());
+        botTest("tron power", () =>
+          expectedApproximate(currentTP, expectedTronPower)
+        );
       },
     },
     {
@@ -225,7 +246,7 @@ const tron: AppSpec<Transaction> = {
         const currentVotes = sortBy(get(account, "tronResources.votes", []), [
           "address",
         ]);
-        expect(currentVotes).toEqual(votes);
+        botTest("current votes", () => expect(currentVotes).toEqual(votes));
       },
     },
     {
@@ -277,10 +298,14 @@ const tron: AppSpec<Transaction> = {
         if (!trc10account) throw new Error("no trc10 account");
 
         if (transaction.useAllAmount) {
-          expect(trc10account.balance.toString()).toBe("0");
+          botTest("trc10 balance became zero", () =>
+            expect(trc10account.balance.toString()).toBe("0")
+          );
         } else {
-          expect(trc10account.balance.toString()).toBe(
-            trc10accountBefore.balance.minus(transaction.amount).toString()
+          botTest("trc10 balance decreased with operation", () =>
+            expect(trc10account.balance.toString()).toBe(
+              trc10accountBefore.balance.minus(transaction.amount).toString()
+            )
           );
         }
       },
@@ -337,10 +362,14 @@ const tron: AppSpec<Transaction> = {
         if (!trc20account) throw new Error("no trc20 account");
 
         if (transaction.useAllAmount) {
-          expect(trc20account.balance.toString()).toBe("0");
+          botTest("trc10 balance became zero", () =>
+            expect(trc20account.balance.toString()).toBe("0")
+          );
         } else {
-          expect(trc20account.balance.toString()).toBe(
-            trc20accountBefore.balance.minus(transaction.amount).toString()
+          botTest("trc10 balance decreased with operation", () =>
+            expect(trc20account.balance.toString()).toBe(
+              trc20accountBefore.balance.minus(transaction.amount).toString()
+            )
           );
         }
 
@@ -349,21 +378,27 @@ const tron: AppSpec<Transaction> = {
             0
           )
         ) {
-          expect(account.balance.lt(accountBeforeTransaction.balance)).toBe(
-            true
+          botTest("account balance decreased", () =>
+            expect(account.balance.lt(accountBeforeTransaction.balance)).toBe(
+              true
+            )
           );
         } else {
-          expect(
-            get(account, "tronResources.energy", new BigNumber(0)).lt(
-              get(
-                accountBeforeTransaction,
-                "tronResources.energy",
-                new BigNumber(0)
+          botTest("energy decreased", () =>
+            expect(
+              get(account, "tronResources.energy", new BigNumber(0)).lt(
+                get(
+                  accountBeforeTransaction,
+                  "tronResources.energy",
+                  new BigNumber(0)
+                )
               )
+            ).toBe(true)
+          );
+          botTest("balance didn't change", () =>
+            expect(account.balance.eq(accountBeforeTransaction.balance)).toBe(
+              true
             )
-          ).toBe(true);
-          expect(account.balance.eq(accountBeforeTransaction.balance)).toBe(
-            true
           );
         }
       },
@@ -396,8 +431,10 @@ const tron: AppSpec<Transaction> = {
           get(account, "tronResources.unwithdrawnReward", "0")
         );
         const nextRewardDate = getNextRewardDate(account as TronAccount);
-        expect(rewards.eq(0)).toBe(true);
-        expect(nextRewardDate && nextRewardDate > Date.now()).toBe(true);
+        botTest("rewards is zero", () => expect(rewards.eq(0)).toBe(true));
+        botTest("next reward date settled", () =>
+          expect(nextRewardDate && nextRewardDate > Date.now()).toBe(true)
+        );
       },
     },
   ],

package/src/families/tron/speculos-deviceActions.ts

@@ -15,89 +15,90 @@ const resourceExpected = ({ transaction: { resource } }) =>
     ? resource.slice(0, 1).toUpperCase() + resource.slice(1).toLowerCase()
     : "";
 
-const acceptTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
-  steps: [
-    {
-      title: "Review",
-      button: "Rr", // TODO define expectedValue
-    },
-    {
-      title: "Claim",
-      button: "Rr",
-    },
-    {
-      title: "Gain",
-      button: "Rr",
-      expectedValue: (arg) => resourceExpected(arg),
-    },
-    {
-      title: "Resource",
-      button: "Rr",
-      expectedValue: (arg) => resourceExpected(arg),
-    },
-    {
-      title: "Amount",
-      button: "Rr",
-      expectedValue: ({ account, status }) =>
-        formatCurrencyUnit(
-          {
-            ...account.unit,
-            code: account.currency.deviceTicker || account.unit.code,
-          },
-          status.amount,
-          {
-            disableRounding: true,
-          }
-        ),
-    },
-    {
-      title: "Token",
-      button: "Rr",
-      expectedValue: ({ account, transaction }) =>
-        transaction.subAccountId
-          ? subAccount(transaction.subAccountId, account).token.ticker
-          : "TRX",
-    },
-    {
-      title: "From Address",
-      button: "Rr",
-      expectedValue: ({ account }) => account.freshAddress,
-    },
-    {
-      title: "Freeze To",
-      button: "Rr",
-      expectedValue: ({ account }) => account.freshAddress,
-    },
-    {
-      title: "Delegated To",
-      button: "Rr",
-      expectedValue: ({ account }) => account.freshAddress,
-    },
-    {
-      title: "Send To",
-      button: "Rr",
-      expectedValue: ({ transaction }) => transaction.recipient,
-    },
-    {
-      title: "Sign",
-      button: "LRlr",
-      final: true,
-    },
-  ],
-  fallback: ({ event, transaction }) => {
-    if (transaction.mode === "vote") {
-      for (const vote of transaction.votes) {
-        const title = `${vote.address.slice(0, 5)}...${vote.address.slice(
-          vote.address.length - 5
-        )}`;
+export const acceptTransaction: DeviceAction<Transaction, any> =
+  deviceActionFlow({
+    steps: [
+      {
+        title: "Review",
+        button: "Rr", // TODO define expectedValue
+      },
+      {
+        title: "Claim",
+        button: "Rr",
+      },
+      {
+        title: "Gain",
+        button: "Rr",
+        expectedValue: (arg) => resourceExpected(arg),
+      },
+      {
+        title: "Resource",
+        button: "Rr",
+        expectedValue: (arg) => resourceExpected(arg),
+      },
+      {
+        title: "Amount",
+        button: "Rr",
+        expectedValue: ({ account, status }) =>
+          formatCurrencyUnit(
+            {
+              ...account.unit,
+              code: account.currency.deviceTicker || account.unit.code,
+            },
+            status.amount,
+            {
+              disableRounding: true,
+            }
+          ),
+      },
+      {
+        title: "Token",
+        button: "Rr",
+        expectedValue: ({ account, transaction }) =>
+          transaction.subAccountId
+            ? subAccount(transaction.subAccountId, account).token.ticker
+            : "TRX",
+      },
+      {
+        title: "From Address",
+        button: "Rr",
+        expectedValue: ({ account }) => account.freshAddress,
+      },
+      {
+        title: "Freeze To",
+        button: "Rr",
+        expectedValue: ({ account }) => account.freshAddress,
+      },
+      {
+        title: "Delegated To",
+        button: "Rr",
+        expectedValue: ({ account }) => account.freshAddress,
+      },
+      {
+        title: "Send To",
+        button: "Rr",
+        expectedValue: ({ transaction }) => transaction.recipient,
+      },
+      {
+        title: "Sign",
+        button: "LRlr",
+        final: true,
+      },
+    ],
+    fallback: ({ event, transaction }) => {
+      if (transaction.mode === "vote") {
+        for (const vote of transaction.votes) {
+          const title = `${vote.address.slice(0, 5)}...${vote.address.slice(
+            vote.address.length - 5
+          )}`;
 
-        if (event.text === title) {
-          return voteAction(vote, title);
+          if (event.text === title) {
+            return voteAction(vote, title);
+          }
         }
       }
-    }
-  },
-});
+    },
+  });
 
 function voteAction(
   vote: Vote,
@@ -109,7 +110,3 @@ function voteAction(
     expectedValue: () => String(vote.voteCount),
   };
 }
-
-export default {
-  acceptTransaction,
-};

package/src/hw/getGenuineCheckFromDeviceId.test.ts

@@ -0,0 +1,98 @@
+import { from, of } from "rxjs";
+import { delay } from "rxjs/operators";
+import Transport from "@ledgerhq/hw-transport";
+import { withDevice } from "./deviceAccess";
+import getDeviceInfo from "./getDeviceInfo";
+import genuineCheck from "./genuineCheck";
+import { DeviceInfo } from "@ledgerhq/types-live";
+import {
+  getGenuineCheckFromDeviceId,
+  GetGenuineCheckFromDeviceIdResult,
+} from "./getGenuineCheckFromDeviceId";
+
+jest.mock("./deviceAccess");
+jest.mock("./getDeviceInfo");
+jest.mock("./genuineCheck");
+jest.useFakeTimers();
+
+const mockedGetDeviceInfo = jest.mocked(getDeviceInfo);
+const mockedGenuineCheck = jest.mocked(genuineCheck);
+const mockedWithDevice = jest.mocked(withDevice);
+
+mockedWithDevice.mockReturnValue((job) => from(job(new Transport())));
+
+const aDeviceInfo = {
+  mcuVersion: "A_MCU_VERSION",
+  version: "A_VERSION",
+  majMin: "A_MAJ_MIN",
+  targetId: "0.0",
+  isBootloader: true,
+  isOSU: true,
+  providerName: undefined,
+  managerAllowed: false,
+  pinValidated: true,
+};
+
+describe("getGenuineCheckFromDeviceId", () => {
+  beforeEach(() => {
+    mockedGetDeviceInfo.mockResolvedValue(aDeviceInfo);
+  });
+
+  afterEach(() => {
+    mockedGetDeviceInfo.mockClear();
+    mockedGenuineCheck.mockClear();
+    jest.clearAllTimers();
+  });
+
+  describe("When the device is locked before doing a genuine check, and it timed out", () => {
+    it("should notify the function consumer of the need to unlock the device, and once done, continue the genuine check flow", (done) => {
+      // Delays the device info response
+      mockedGetDeviceInfo.mockReturnValue(
+        of(aDeviceInfo as DeviceInfo)
+          .pipe(delay(1001))
+          .toPromise()
+      );
+
+      mockedGenuineCheck.mockReturnValue(
+        of({
+          type: "device-permission-requested",
+          wording: "",
+        })
+      );
+
+      let step = 0;
+      getGenuineCheckFromDeviceId({
+        deviceId: "A_DEVICE_ID",
+        lockedDeviceTimeoutMs: 1000,
+      }).subscribe({
+        next: ({
+          socketEvent,
+          deviceIsLocked,
+        }: GetGenuineCheckFromDeviceIdResult) => {
+          switch (step) {
+            case 0:
+              expect(socketEvent).toBeNull();
+              expect(deviceIsLocked).toBe(true);
+              break;
+            case 1:
+              expect(socketEvent).toBeNull();
+              expect(deviceIsLocked).toBe(false);
+              break;
+            case 2:
+              expect(socketEvent).toEqual({
+                type: "device-permission-requested",
+                wording: "",
+              });
+              expect(deviceIsLocked).toBe(false);
+              done();
+              break;
+          }
+          jest.advanceTimersByTime(1);
+          step += 1;
+        },
+      });
+
+      jest.advanceTimersByTime(1000);
+    });
+  });
+});

package/src/hw/getGenuineCheckFromDeviceId.ts

@@ -0,0 +1,61 @@
+import type { SocketEvent } from "@ledgerhq/types-live";
+import { from, Observable } from "rxjs";
+import { mergeMap } from "rxjs/operators";
+import getDeviceInfo from "./getDeviceInfo";
+import { withDevice } from "./deviceAccess";
+import genuineCheck from "./genuineCheck";
+
+export type GetGenuineCheckFromDeviceIdArgs = {
+  deviceId: string;
+  lockedDeviceTimeoutMs?: number;
+};
+
+export type GetGenuineCheckFromDeviceIdResult = {
+  socketEvent: SocketEvent | null;
+  deviceIsLocked: boolean;
+};
+
+export type GetGenuineCheckFromDeviceIdOutput =
+  Observable<GetGenuineCheckFromDeviceIdResult>;
+
+/**
+ * Get a genuine check for a device only from its id
+ * @param deviceId A device id, or an empty string if device is usb plugged
+ * @param lockedDeviceTimeoutMs Time of no response from device after which the device is considered locked, in ms. Default 1000ms.
+ * @returns An Observable pushing objects containing:
+ * - socketEvent: a SocketEvent giving the current status of the genuine check,
+ *     null if the genuine check process did not reach any state yet
+ * - deviceIsLocked: a boolean set to true if the device is currently locked, false otherwise
+ */
+export const getGenuineCheckFromDeviceId = ({
+  deviceId,
+  lockedDeviceTimeoutMs = 1000,
+}: GetGenuineCheckFromDeviceIdArgs): GetGenuineCheckFromDeviceIdOutput => {
+  return new Observable((o) => {
+    // In order to know if a device is locked or not.
+    // As we're not timing out inside the genuineCheckObservable flow (with rxjs timeout for ex)
+    // once the device is unlock, getDeviceInfo should return the device info and
+    // the flow will continue. No need to handle a retry strategy
+    const lockedDeviceTimeout = setTimeout(() => {
+      o.next({ socketEvent: null, deviceIsLocked: true });
+    }, lockedDeviceTimeoutMs);
+
+    // withDevice handles the unsubscribing cleaning when leaving the useEffect
+    withDevice(deviceId)((t) =>
+      from(getDeviceInfo(t)).pipe(
+        mergeMap((deviceInfo) => {
+          clearTimeout(lockedDeviceTimeout);
+          o.next({ socketEvent: null, deviceIsLocked: false });
+          return genuineCheck(t, deviceInfo);
+        })
+      )
+    ).subscribe({
+      next: (socketEvent: SocketEvent) => {
+        o.next({ socketEvent, deviceIsLocked: false });
+      },
+      error: (e) => {
+        o.error(e);
+      },
+    });
+  });
+};

package/src/hw/getLatestAvailableFirmwareFromDeviceId.ts

@@ -0,0 +1,37 @@
+import { from, Observable } from "rxjs";
+import { map, mergeMap } from "rxjs/operators";
+import type { FirmwareUpdateContext, DeviceId } from "@ledgerhq/types-live";
+import manager from "../manager";
+import { withDevice } from "./deviceAccess";
+import getDeviceInfo from "./getDeviceInfo";
+
+export type GetLatestAvailableFirmwareFromDeviceIdArgs = {
+  deviceId: DeviceId;
+};
+
+export type GetLatestAvailableFirmwareFromDeviceIdResult = {
+  firmwareUpdateContext: FirmwareUpdateContext | null | undefined;
+};
+
+export type GetLatestAvailableFirmwareFromDeviceIdOutput =
+  Observable<GetLatestAvailableFirmwareFromDeviceIdResult>;
+
+/**
+ * Get the latest available firmware for a device only from its id
+ * @param deviceId A device id, or an empty string if device is usb plugged
+ * @returns An Observable pushing objects containing:
+ * - firmwareUpdateContext A FirmwareUpdateContext if found, or null or undefined otherwise
+ */
+export const getLatestAvailableFirmwareFromDeviceId = ({
+  deviceId,
+}: GetLatestAvailableFirmwareFromDeviceIdArgs): GetLatestAvailableFirmwareFromDeviceIdOutput => {
+  return withDevice(deviceId)((t) =>
+    from(getDeviceInfo(t)).pipe(
+      mergeMap((deviceInfo) =>
+        from(manager.getLatestFirmwareForDevice(deviceInfo)).pipe(
+          map((firmwareUpdateContext) => ({ firmwareUpdateContext }))
+        )
+      )
+    )
+  );
+};