@ledgerhq/live-common 24.0.0 → 24.1.0

package/src/families/ethereum/synchronisation.ts

@@ -20,7 +20,7 @@ import { API, apiForCurrency, Tx } from "../../api/Ethereum";
 import { digestTokenAccounts, prepareTokenAccounts } from "./modules";
 import { findTokenByAddressInCurrency } from "@ledgerhq/cryptoassets";
 import { encodeNftId, isNFTActive, nftsFromOperations } from "../../nft";
-import { encodeOperationId } from "../../operation";
+import { encodeOperationId, encodeSubOperationId } from "../../operation";
 import {
   encodeERC1155OperationId,
   encodeERC721OperationId,
@@ -46,7 +46,13 @@ export const getAccountShape: GetAccountShape = async (
     : [];
   // fetch transactions, incrementally if possible
   const mostRecentStableOperation = initialStableOperations[0];
+  const currentBlockP = fetchCurrentBlock(currency);
+  const balanceP = api.getAccountBalance(address);
   // when new tokens are added / blacklist changes, we need to sync again because we need to go through all operations again
+  // Check if the block hash exists on chain to prevent reorg issue
+  const blockHashExistsOnChain = await api
+    .getBlockByHash(mostRecentStableOperation?.blockHash)
+    .then(Boolean);
   const syncHash =
     JSON.stringify(blacklistedTokenIds || []) +
     "_" +
@@ -58,12 +64,11 @@ export const getAccountShape: GetAccountShape = async (
     initialAccount &&
     areAllOperationsLoaded(initialAccount) &&
     mostRecentStableOperation &&
+    blockHashExistsOnChain &&
     !outdatedSyncHash
       ? mostRecentStableOperation.blockHash
       : undefined;
   const txsP = fetchAllTransactions(api, address, pullFromBlockHash);
-  const currentBlockP = fetchCurrentBlock(currency);
-  const balanceP = api.getAccountBalance(address);
   const [txs, currentBlock, balance] = await Promise.all([
     txsP,
     currentBlockP,
@@ -167,7 +172,10 @@ export const getAccountShape: GetAccountShape = async (
     ...o,
     subOperations: inferSubOperations(o.hash, subAccounts),
   }));
-  const operations = mergeOps(initialStableOperations, newOps);
+  const operations = mergeOps(
+    blockHashExistsOnChain ? initialStableOperations : [],
+    newOps
+  );
 
   const nfts = isNFTActive(currency)
     ? mergeNfts(
@@ -274,7 +282,7 @@ const txToOps =
     // We are putting the sub operations in place for now, but they will later be exploded out of the operations back to their token accounts
     const subOperations = !transfer_events
       ? []
-      : flatMap(transfer_events.list, (event) => {
+      : flatMap(transfer_events.list, (event, i) => {
           const from = safeEncodeEIP55(event.from);
           const to = safeEncodeEIP55(event.to);
           const sending = addr === from;
@@ -296,7 +304,7 @@ const txToOps =
           if (sending) {
             const type = "OUT";
             all.push({
-              id: encodeOperationId(accountId, hash, type),
+              id: encodeSubOperationId(accountId, hash, type, i),
               hash,
               type,
               value,
@@ -315,7 +323,7 @@ const txToOps =
           if (receiving) {
             const type = "IN";
             all.push({
-              id: encodeOperationId(accountId, hash, type),
+              id: encodeSubOperationId(accountId, hash, type, i),
               hash,
               type,
               value,

package/src/hw/extractOnboardingState.test.ts

@@ -0,0 +1,251 @@
+import {
+  extractOnboardingState,
+  OnboardingStep,
+} from "./extractOnboardingState";
+
+describe("@hw/extractOnboardingState", () => {
+  describe("extractOnboardingState", () => {
+    describe("When the flag bytes are incorrect", () => {
+      it("should throw an error", () => {
+        const incompleteFlagsBytes = Buffer.from([0, 0]);
+        // DeviceExtractOnboardingStateError is not of type Error,
+        // so cannot check in toThrow(DeviceExtractOnboardingStateError)
+        expect(() => extractOnboardingState(incompleteFlagsBytes)).toThrow();
+      });
+    });
+
+    describe("When the device is onboarded", () => {
+      it("should return a device state that is onboarded", () => {
+        const flagsBytes = Buffer.from([1 << 2, 0, 0, 0]);
+
+        const onboardingState = extractOnboardingState(flagsBytes);
+
+        expect(onboardingState).not.toBeNull();
+        expect(onboardingState?.isOnboarded).toBe(true);
+      });
+    });
+
+    describe("When the device is in recovery mode", () => {
+      it("should return a device state that is in recovery mode", () => {
+        const flagsBytes = Buffer.from([1, 0, 0, 0]);
+
+        const onboardingState = extractOnboardingState(flagsBytes);
+
+        expect(onboardingState).not.toBeNull();
+        expect(onboardingState?.isInRecoveryMode).toBe(true);
+      });
+    });
+
+    describe("When the device is not onboarded and in normal mode", () => {
+      let flagsBytes: Buffer;
+
+      beforeEach(() => {
+        flagsBytes = Buffer.from([0, 0, 0, 0]);
+      });
+
+      describe("and the user is on the welcome screen", () => {
+        beforeEach(() => {
+          flagsBytes[3] = 0;
+        });
+
+        it("should return an onboarding step that is set at the welcome screen", () => {
+          const onboardingState = extractOnboardingState(flagsBytes);
+
+          expect(onboardingState).not.toBeNull();
+          expect(onboardingState?.currentOnboardingStep).toBe(
+            OnboardingStep.WelcomeScreen
+          );
+        });
+      });
+
+      describe("and the user is choosing what kind of setup they want", () => {
+        beforeEach(() => {
+          flagsBytes[3] = 1;
+        });
+
+        it("should return an onboarding step that is set at the setup choice", () => {
+          const onboardingState = extractOnboardingState(flagsBytes);
+
+          expect(onboardingState).not.toBeNull();
+          expect(onboardingState?.currentOnboardingStep).toBe(
+            OnboardingStep.SetupChoice
+          );
+        });
+      });
+
+      describe("and the user is setting their pin", () => {
+        beforeEach(() => {
+          flagsBytes[3] = 2;
+        });
+
+        it("should return an onboarding step that is set at setting the pin", () => {
+          const onboardingState = extractOnboardingState(flagsBytes);
+
+          expect(onboardingState).not.toBeNull();
+          expect(onboardingState?.currentOnboardingStep).toBe(
+            OnboardingStep.Pin
+          );
+        });
+      });
+
+      describe("and the user is generating a new seed", () => {
+        describe("and the seed phrase type is set to 24 words", () => {
+          beforeEach(() => {
+            // 24-words seed
+            flagsBytes[2] |= 0 << 5;
+          });
+
+          it("should return a device state with the correct seed phrase type", () => {
+            const onboardingState = extractOnboardingState(flagsBytes);
+
+            expect(onboardingState).not.toBeNull();
+            expect(onboardingState?.seedPhraseType).toBe("24-words");
+          });
+
+          describe("and the user is writing the seed word i", () => {
+            beforeEach(() => {
+              flagsBytes[3] = 3;
+            });
+
+            it("should return an onboarding step that is set at writting the seed phrase", () => {
+              const onboardingState = extractOnboardingState(flagsBytes);
+
+              expect(onboardingState).not.toBeNull();
+              expect(onboardingState?.currentOnboardingStep).toBe(
+                OnboardingStep.NewDevice
+              );
+            });
+
+            it("should return a device state with the index of the current seed word being written", () => {
+              const byte3 = flagsBytes[2];
+              for (let wordIndex = 0; wordIndex < 24; wordIndex++) {
+                flagsBytes[2] = byte3 | wordIndex;
+
+                const onboardingState = extractOnboardingState(flagsBytes);
+
+                expect(onboardingState).not.toBeNull();
+                expect(onboardingState?.currentSeedWordIndex).toBe(wordIndex);
+              }
+            });
+          });
+
+          describe("and the user is confirming the seed word i", () => {
+            beforeEach(() => {
+              flagsBytes[3] = 4;
+            });
+
+            it("should return an onboarding step that is set at confirming the seed phrase", () => {
+              const onboardingState = extractOnboardingState(flagsBytes);
+
+              expect(onboardingState).not.toBeNull();
+              expect(onboardingState?.currentOnboardingStep).toBe(
+                OnboardingStep.NewDeviceConfirming
+              );
+            });
+
+            it("should return a device state with the index of the current seed word being confirmed", () => {
+              const byte3 = flagsBytes[2];
+              for (let wordIndex = 0; wordIndex < 24; wordIndex++) {
+                flagsBytes[2] = byte3 | wordIndex;
+
+                const onboardingState = extractOnboardingState(flagsBytes);
+
+                expect(onboardingState).not.toBeNull();
+                expect(onboardingState?.currentSeedWordIndex).toBe(wordIndex);
+              }
+            });
+          });
+        });
+      });
+
+      describe("and the user is recovering a seed", () => {
+        describe("and the seed phrase type is set to X words", () => {
+          it("should return a device state with the correct seed phrase type", () => {
+            const byte3 = flagsBytes[2];
+
+            // 24-words
+            flagsBytes[2] = byte3 | (0 << 5);
+            let onboardingState = extractOnboardingState(flagsBytes);
+
+            expect(onboardingState).not.toBeNull();
+            expect(onboardingState?.seedPhraseType).toBe("24-words");
+
+            // 18-words
+            flagsBytes[2] = byte3 | (1 << 5);
+            onboardingState = extractOnboardingState(flagsBytes);
+
+            expect(onboardingState).not.toBeNull();
+            expect(onboardingState?.seedPhraseType).toBe("18-words");
+
+            // 12-words
+            flagsBytes[2] = byte3 | (2 << 5);
+            onboardingState = extractOnboardingState(flagsBytes);
+
+            expect(onboardingState).not.toBeNull();
+            expect(onboardingState?.seedPhraseType).toBe("12-words");
+          });
+
+          describe("and the user is confirming (seed recovery) the seed word i", () => {
+            beforeEach(() => {
+              // 24-words seed
+              flagsBytes[2] |= 0 << 5;
+
+              flagsBytes[3] = 5;
+            });
+
+            it("should return an onboarding step that is set at confirming the restored seed phrase", () => {
+              const onboardingState = extractOnboardingState(flagsBytes);
+
+              expect(onboardingState).not.toBeNull();
+              expect(onboardingState?.currentOnboardingStep).toBe(
+                OnboardingStep.RestoreSeed
+              );
+            });
+
+            it("should return a device state with the index of the current seed word being confirmed", () => {
+              const byte3 = flagsBytes[2];
+              for (let wordIndex = 0; wordIndex < 24; wordIndex++) {
+                flagsBytes[2] = byte3 | wordIndex;
+
+                const onboardingState = extractOnboardingState(flagsBytes);
+
+                expect(onboardingState).not.toBeNull();
+                expect(onboardingState?.currentSeedWordIndex).toBe(wordIndex);
+              }
+            });
+          });
+        });
+      });
+
+      describe("and the user is on the safety warning screen", () => {
+        beforeEach(() => {
+          flagsBytes[3] = 6;
+        });
+
+        it("should return an onboarding step that is set at the safety warning screen", () => {
+          const onboardingState = extractOnboardingState(flagsBytes);
+
+          expect(onboardingState).not.toBeNull();
+          expect(onboardingState?.currentOnboardingStep).toBe(
+            OnboardingStep.SafetyWarning
+          );
+        });
+      });
+
+      describe("and the user finished the onboarding process", () => {
+        beforeEach(() => {
+          flagsBytes[3] = 7;
+        });
+
+        it("should return an onboarding step that is set at ready", () => {
+          const onboardingState = extractOnboardingState(flagsBytes);
+
+          expect(onboardingState).not.toBeNull();
+          expect(onboardingState?.currentOnboardingStep).toBe(
+            OnboardingStep.Ready
+          );
+        });
+      });
+    });
+  });
+});

package/src/hw/extractOnboardingState.ts

@@ -0,0 +1,97 @@
+import { DeviceExtractOnboardingStateError } from "@ledgerhq/errors";
+import { SeedPhraseType } from "../types/manager";
+
+const onboardingFlagsBytesLength = 4;
+
+const onboardedMask = 0x04;
+const inRecoveryModeMask = 0x01;
+const seedPhraseTypeMask = 0x60;
+const seedPhraseTypeFlagOffset = 5;
+const currentSeedWordIndexMask = 0x1f;
+
+const fromBitsToSeedPhraseType = new Map<number, SeedPhraseType>([
+  [0, SeedPhraseType.TwentyFour],
+  [1, SeedPhraseType.Eighteen],
+  [2, SeedPhraseType.Twelve],
+]);
+
+export enum OnboardingStep {
+  WelcomeScreen = "WELCOME_SCREEN",
+  SetupChoice = "SETUP_CHOICE",
+  Pin = "PIN",
+  NewDevice = "NEW_DEVICE", // path "new device" & currentSeedWordIndex available
+  NewDeviceConfirming = "NEW_DEVICE_CONFIRMING", // path "new device" & currentSeedWordIndex available
+  RestoreSeed = "RESTORE_SEED", // path "restore seed" & currentSeedWordIndex available
+  SafetyWarning = "SAFETY WARNING",
+  Ready = "READY",
+}
+
+const fromBitsToOnboardingStep = new Map<number, OnboardingStep>([
+  [0, OnboardingStep.WelcomeScreen],
+  [1, OnboardingStep.SetupChoice],
+  [2, OnboardingStep.Pin],
+  [3, OnboardingStep.NewDevice],
+  [4, OnboardingStep.NewDeviceConfirming],
+  [5, OnboardingStep.RestoreSeed],
+  [6, OnboardingStep.SafetyWarning],
+  [7, OnboardingStep.Ready],
+]);
+
+export type OnboardingState = {
+  // Device not yet onboarded otherwise
+  isOnboarded: boolean;
+  // In normal mode otherwise
+  isInRecoveryMode: boolean;
+
+  seedPhraseType: SeedPhraseType;
+
+  currentOnboardingStep: OnboardingStep;
+  currentSeedWordIndex: number;
+};
+
+/**
+ * Extracts the onboarding state of the device
+ * @param flagsBytes Buffer of bytes of length onboardingFlagsBytesLength reprensenting the device state flags
+ * @returns An OnboardingState
+ */
+export const extractOnboardingState = (flagsBytes: Buffer): OnboardingState => {
+  if (!flagsBytes || flagsBytes.length < onboardingFlagsBytesLength) {
+    throw new DeviceExtractOnboardingStateError(
+      "Incorrect onboarding flags bytes"
+    );
+  }
+
+  const isOnboarded = Boolean(flagsBytes[0] & onboardedMask);
+  const isInRecoveryMode = Boolean(flagsBytes[0] & inRecoveryModeMask);
+
+  const seedPhraseTypeBits =
+    (flagsBytes[2] & seedPhraseTypeMask) >> seedPhraseTypeFlagOffset;
+  const seedPhraseType = fromBitsToSeedPhraseType.get(seedPhraseTypeBits);
+
+  if (!seedPhraseType) {
+    throw new DeviceExtractOnboardingStateError(
+      "Incorrect onboarding bits for the seed phrase type"
+    );
+  }
+
+  const currentOnboardingStepBits = flagsBytes[3];
+  const currentOnboardingStep = fromBitsToOnboardingStep.get(
+    currentOnboardingStepBits
+  );
+
+  if (!currentOnboardingStep) {
+    throw new DeviceExtractOnboardingStateError(
+      "Incorrect onboarding bits for the current onboarding step"
+    );
+  }
+
+  const currentSeedWordIndex = flagsBytes[2] & currentSeedWordIndexMask;
+
+  return {
+    isOnboarded,
+    isInRecoveryMode,
+    seedPhraseType,
+    currentOnboardingStep,
+    currentSeedWordIndex,
+  };
+};

package/src/hw/getOnboardingStatePolling.test.ts

@@ -0,0 +1,247 @@
+import { getOnboardingStatePolling } from "./getOnboardingStatePolling";
+import { from, Subscription, TimeoutError } from "rxjs";
+import * as rxjsOperators from "rxjs/operators";
+import { DeviceModelId } from "@ledgerhq/devices";
+import Transport from "@ledgerhq/hw-transport";
+import {
+  DeviceExtractOnboardingStateError,
+  DisconnectedDevice,
+} from "@ledgerhq/errors";
+import { withDevice } from "./deviceAccess";
+import getVersion from "./getVersion";
+import {
+  extractOnboardingState,
+  OnboardingState,
+  OnboardingStep,
+} from "./extractOnboardingState";
+import { SeedPhraseType } from "../types/manager";
+
+jest.mock("./deviceAccess");
+jest.mock("./getVersion");
+jest.mock("./extractOnboardingState");
+jest.mock("@ledgerhq/hw-transport");
+jest.useFakeTimers();
+
+const aDevice = {
+  deviceId: "DEVICE_ID_A",
+  deviceName: "DEVICE_NAME_A",
+  modelId: DeviceModelId.nanoFTS,
+  wired: false,
+};
+
+// As extractOnboardingState is mocked, the firmwareInfo
+// returned by getVersion does not matter
+const aFirmwareInfo = {
+  isBootloader: false,
+  rawVersion: "",
+  targetId: 0,
+  mcuVersion: "",
+  flags: Buffer.from([]),
+};
+
+const pollingPeriodMs = 1000;
+
+const mockedGetVersion = jest.mocked(getVersion);
+
+const mockedWithDevice = jest.mocked(withDevice);
+mockedWithDevice.mockReturnValue((job) => from(job(new Transport())));
+
+const mockedExtractOnboardingState = jest.mocked(extractOnboardingState);
+
+describe("getOnboardingStatePolling", () => {
+  let anOnboardingState: OnboardingState;
+  let onboardingStatePollingSubscription: Subscription | null;
+
+  beforeEach(() => {
+    anOnboardingState = {
+      isOnboarded: false,
+      isInRecoveryMode: false,
+      seedPhraseType: SeedPhraseType.TwentyFour,
+      currentSeedWordIndex: 0,
+      currentOnboardingStep: OnboardingStep.NewDevice,
+    };
+  });
+
+  afterEach(() => {
+    mockedGetVersion.mockClear();
+    mockedExtractOnboardingState.mockClear();
+    jest.clearAllTimers();
+    onboardingStatePollingSubscription?.unsubscribe();
+  });
+
+  describe("When a communication error occurs while fetching the device state", () => {
+    describe("and when the error is allowed and thrown before the defined timeout", () => {
+      it("should update the onboarding state to null and keep track of the allowed error", (done) => {
+        mockedGetVersion.mockRejectedValue(
+          new DisconnectedDevice("An allowed error")
+        );
+        mockedExtractOnboardingState.mockReturnValue(anOnboardingState);
+
+        const device = aDevice;
+
+        getOnboardingStatePolling({
+          deviceId: device.deviceId,
+          pollingPeriodMs,
+        }).subscribe({
+          next: (value) => {
+            expect(value.onboardingState).toBeNull();
+            expect(value.allowedError).toBeInstanceOf(DisconnectedDevice);
+            done();
+          },
+        });
+
+        // The timeout is equal to pollingPeriodMs by default
+        jest.advanceTimersByTime(pollingPeriodMs - 1);
+      });
+    });
+
+    describe("and when a timeout occurred before the error (or the fetch took too long)", () => {
+      it("should update the allowed error value to notify the consumer - default value for the timeout", (done) => {
+        mockedGetVersion.mockResolvedValue(aFirmwareInfo);
+        mockedExtractOnboardingState.mockReturnValue(anOnboardingState);
+
+        const device = aDevice;
+
+        getOnboardingStatePolling({
+          deviceId: device.deviceId,
+          pollingPeriodMs,
+        }).subscribe({
+          next: (value) => {
+            expect(value.onboardingState).toBeNull();
+            expect(value.allowedError).toBeInstanceOf(TimeoutError);
+            done();
+          },
+        });
+
+        // Waits more than the timeout
+        jest.advanceTimersByTime(pollingPeriodMs + 1);
+      });
+
+      it("should update the allowed error value to notify the consumer - timeout value set by the consumer", (done) => {
+        const fetchingTimeoutMs = pollingPeriodMs + 500;
+        mockedGetVersion.mockResolvedValue(aFirmwareInfo);
+        mockedExtractOnboardingState.mockReturnValue(anOnboardingState);
+
+        const device = aDevice;
+
+        getOnboardingStatePolling({
+          deviceId: device.deviceId,
+          pollingPeriodMs,
+          fetchingTimeoutMs,
+        }).subscribe({
+          next: (value) => {
+            expect(value.onboardingState).toBeNull();
+            expect(value.allowedError).toBeInstanceOf(TimeoutError);
+            done();
+          },
+        });
+
+        // Waits more than the timeout
+        jest.advanceTimersByTime(fetchingTimeoutMs + 1);
+      });
+    });
+
+    describe("and when the error is fatal and thrown before the defined timeout", () => {
+      it("should notify the consumer that a unallowed error occurred", (done) => {
+        mockedGetVersion.mockRejectedValue(new Error("Unknown error"));
+
+        const device = aDevice;
+
+        getOnboardingStatePolling({
+          deviceId: device.deviceId,
+          pollingPeriodMs,
+        }).subscribe({
+          error: (error) => {
+            expect(error).toBeInstanceOf(Error);
+            expect(error?.message).toBe("Unknown error");
+            done();
+          },
+        });
+
+        jest.advanceTimersByTime(pollingPeriodMs - 1);
+      });
+    });
+  });
+
+  describe("When the fetched device state is incorrect", () => {
+    it("should return a null onboarding state, and keep track of the extract error", (done) => {
+      mockedGetVersion.mockResolvedValue(aFirmwareInfo);
+      mockedExtractOnboardingState.mockImplementation(() => {
+        throw new DeviceExtractOnboardingStateError(
+          "Some incorrect device info"
+        );
+      });
+
+      const device = aDevice;
+
+      onboardingStatePollingSubscription = getOnboardingStatePolling({
+        deviceId: device.deviceId,
+        pollingPeriodMs,
+      }).subscribe({
+        next: (value) => {
+          expect(value.onboardingState).toBeNull();
+          expect(value.allowedError).toBeInstanceOf(
+            DeviceExtractOnboardingStateError
+          );
+          done();
+        },
+      });
+
+      jest.advanceTimersByTime(pollingPeriodMs - 1);
+    });
+  });
+
+  describe("When polling returns a correct device state", () => {
+    it("should return a correct onboarding state", (done) => {
+      mockedGetVersion.mockResolvedValue(aFirmwareInfo);
+      mockedExtractOnboardingState.mockReturnValue(anOnboardingState);
+
+      const device = aDevice;
+
+      onboardingStatePollingSubscription = getOnboardingStatePolling({
+        deviceId: device.deviceId,
+        pollingPeriodMs,
+      }).subscribe({
+        next: (value) => {
+          expect(value.allowedError).toBeNull();
+          expect(value.onboardingState).toEqual(anOnboardingState);
+          done();
+        },
+        error: (error) => {
+          done(error);
+        },
+      });
+
+      jest.advanceTimersByTime(pollingPeriodMs - 1);
+    });
+
+    it("should poll a new onboarding state after the defined period of time", (done) => {
+      mockedGetVersion.mockResolvedValue(aFirmwareInfo);
+      mockedExtractOnboardingState.mockReturnValue(anOnboardingState);
+
+      const device = aDevice;
+
+      // Did not manage to test that the polling is repeated by using jest's fake timer
+      // and advanceTimersByTime method or equivalent.
+      // Hacky test: spy on the repeat operator to see if it has been called.
+      const spiedRepeat = jest.spyOn(rxjsOperators, "repeat");
+
+      onboardingStatePollingSubscription = getOnboardingStatePolling({
+        deviceId: device.deviceId,
+        pollingPeriodMs,
+      }).subscribe({
+        next: (value) => {
+          expect(value.onboardingState).toEqual(anOnboardingState);
+          expect(value.allowedError).toBeNull();
+          expect(spiedRepeat).toHaveBeenCalledTimes(1);
+          done();
+        },
+        error: (error) => {
+          done(error);
+        },
+      });
+
+      jest.runOnlyPendingTimers();
+    });
+  });
+});