@ledgerhq/live-common 34.38.1-hotfix.0 → 34.38.2-nightly.0

package/src/hw/extractOnboardingState.test.ts

@@ -1,5 +1,5 @@
 import { DeviceExtractOnboardingStateError } from "@ledgerhq/errors";
-import { extractOnboardingState, OnboardingStep } from "./extractOnboardingState";
+import { CharonStatus, extractOnboardingState, OnboardingStep } from "./extractOnboardingState";
 
 describe("@hw/extractOnboardingState", () => {
   describe("extractOnboardingState", () => {
@@ -22,6 +22,76 @@ describe("@hw/extractOnboardingState", () => {
         expect(onboardingState).not.toBeNull();
         expect(onboardingState?.isOnboarded).toBe(true);
       });
+
+      describe("and the user is on the charon backup screen", () => {
+        const flagsBytes = Buffer.from([1 << 2, 0, 0, 0xb]);
+
+        describe("and the device was seeded with charon", () => {
+          it("should return an onboarding step that is set at the charon screen", () => {
+            const charonState = Buffer.from([0x0]);
+            const onboardingState = extractOnboardingState(flagsBytes, charonState);
+
+            expect(onboardingState).not.toBeNull();
+            expect(onboardingState?.currentOnboardingStep).toBe(OnboardingStep.Ready);
+            expect(onboardingState?.charonStatus).toBeNull();
+          });
+        });
+
+        describe("and the user refuse to backup the charon", () => {
+          it("should return an onboarding step that is set at ready", () => {
+            const charonState = Buffer.from([0x1]);
+            const onboardingState = extractOnboardingState(flagsBytes, charonState);
+
+            expect(onboardingState).not.toBeNull();
+            expect(onboardingState?.currentOnboardingStep).toBe(OnboardingStep.Ready);
+            expect(onboardingState?.charonStatus).toBe(CharonStatus.Rejected);
+          });
+
+          describe("and charon backup process started but not finished", () => {
+            it("should return an onboarding step that is set at the charon screen", () => {
+              const charonState = Buffer.from([0x3]);
+              const onboardingState = extractOnboardingState(flagsBytes, charonState);
+
+              expect(onboardingState).not.toBeNull();
+              expect(onboardingState?.currentOnboardingStep).toBe(OnboardingStep.BackupCharon);
+              expect(onboardingState?.charonStatus).toBe(CharonStatus.Running);
+            });
+
+            describe("and the charon backup is done and naming not finished", () => {
+              it("should return an onboarding step that is set at the charon screen", () => {
+                const charonState = Buffer.from([0x4]);
+                const onboardingState = extractOnboardingState(flagsBytes, charonState);
+
+                expect(onboardingState).not.toBeNull();
+                expect(onboardingState?.currentOnboardingStep).toBe(OnboardingStep.BackupCharon);
+                expect(onboardingState?.charonStatus).toBe(CharonStatus.Naming);
+              });
+
+              describe("and the charon backup is done and backup-process exited", () => {
+                it("should return an onboarding step that is set at ready", () => {
+                  const charonState = Buffer.from([0x5]);
+                  const onboardingState = extractOnboardingState(flagsBytes, charonState);
+
+                  expect(onboardingState).not.toBeNull();
+                  expect(onboardingState?.currentOnboardingStep).toBe(OnboardingStep.Ready);
+                  expect(onboardingState?.charonStatus).toBe(CharonStatus.Ready);
+                });
+              });
+            });
+          });
+        });
+
+        describe("and charon backup is not started and not fully refused", () => {
+          it("should return an onboarding step that is set at ready", () => {
+            const charonState = Buffer.from([0x2]);
+            const onboardingState = extractOnboardingState(flagsBytes, charonState);
+
+            expect(onboardingState).not.toBeNull();
+            expect(onboardingState?.currentOnboardingStep).toBe(OnboardingStep.BackupCharon);
+            expect(onboardingState?.charonStatus).toBe(CharonStatus.Choice);
+          });
+        });
+      });
     });
 
     describe("When the device is in recovery mode", () => {
@@ -282,9 +352,26 @@ describe("@hw/extractOnboardingState", () => {
         });
       });
 
-      describe("and the user finished the onboarding process", () => {
+      describe("and the user finished the onboarding process with a device that does not support charon", () => {
         beforeEach(() => {
           flagsBytes[3] = 11;
+          flagsBytes[4] = 0; // recover
+          flagsBytes[5] = undefined as unknown as number; // charon not supported
+        });
+
+        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);
+        });
+      });
+
+      describe("and the user finished the onboarding process with a device that does not support recover and charon", () => {
+        beforeEach(() => {
+          flagsBytes[3] = 11;
+          flagsBytes[4] = undefined as unknown as number; // recover not supported
+          flagsBytes[5] = undefined as unknown as number; // charon not supported
         });
 
         it("should return an onboarding step that is set at ready", () => {
@@ -309,6 +396,39 @@ describe("@hw/extractOnboardingState", () => {
           );
         });
       });
+
+      describe("and the user is on the restore charon screen", () => {
+        beforeEach(() => {
+          flagsBytes = Buffer.from([0, 0, 0, 0x10]);
+        });
+
+        it("should return an onboarding step that is set at the restore from charon screen", () => {
+          const onboardingState = extractOnboardingState(flagsBytes);
+
+          expect(onboardingState).not.toBeNull();
+          expect(onboardingState?.currentOnboardingStep).toBe(OnboardingStep.RestoreCharon);
+        });
+      });
+    });
+
+    describe("When charon flags are provided", () => {
+      it("should return charonSupported=true", () => {
+        const onboardingState = extractOnboardingState(
+          Buffer.from([0, 0, 0, 0]),
+          Buffer.from([0x0]),
+        );
+
+        expect(onboardingState).not.toBeNull();
+        expect(onboardingState?.charonSupported).toBe(true);
+      });
+    });
+    describe("When charon flags are not provided", () => {
+      it("should return charonSupported=false", () => {
+        const onboardingState = extractOnboardingState(Buffer.from([0, 0, 0, 0]));
+
+        expect(onboardingState).not.toBeNull();
+        expect(onboardingState?.charonSupported).toBe(false);
+      });
     });
   });
 });

package/src/hw/extractOnboardingState.ts

@@ -1,6 +1,8 @@
 import { DeviceExtractOnboardingStateError } from "@ledgerhq/errors";
 import { SeedPhraseType } from "@ledgerhq/types-live";
 
+const CHARON_STEP_BIT_MASK = 0x1000;
+
 const onboardingFlagsBytesLength = 4;
 
 const onboardedMask = 0x04;
@@ -38,25 +40,34 @@ export enum OnboardingStep {
   RecoverRestore = "RECOVER_RESTORE", // path "restore with Recover"
   SafetyWarning = "SAFETY WARNING",
   Ready = "READY",
+  BackupCharon = "BACKUP_CHARON",
+  RestoreCharon = "RESTORE_CHARON",
 }
 
 const fromBitsToOnboardingStep = new Map<number, OnboardingStep>([
-  [0, OnboardingStep.WelcomeScreen1],
-  [1, OnboardingStep.WelcomeScreen2],
-  [2, OnboardingStep.WelcomeScreen3],
-  [3, OnboardingStep.WelcomeScreen4],
-  [4, OnboardingStep.WelcomeScreenReminder],
-  [5, OnboardingStep.SetupChoice],
-  [6, OnboardingStep.Pin],
-  [7, OnboardingStep.NewDevice],
-  [8, OnboardingStep.NewDeviceConfirming],
-  [9, OnboardingStep.RestoreSeed],
-  [10, OnboardingStep.SafetyWarning],
-  [11, OnboardingStep.Ready],
-  [12, OnboardingStep.ChooseName],
-  [13, OnboardingStep.RecoverRestore],
-  [14, OnboardingStep.SetupChoiceRestore],
-  [15, OnboardingStep.OnboardingEarlyCheck],
+  [0x0, OnboardingStep.WelcomeScreen1],
+  [0x1, OnboardingStep.WelcomeScreen2],
+  [0x2, OnboardingStep.WelcomeScreen3],
+  [0x3, OnboardingStep.WelcomeScreen4],
+  [0x4, OnboardingStep.WelcomeScreenReminder],
+  [0x5, OnboardingStep.SetupChoice],
+  [0x6, OnboardingStep.Pin],
+  [0x7, OnboardingStep.NewDevice],
+  [0x8, OnboardingStep.NewDeviceConfirming],
+  [0x9, OnboardingStep.RestoreSeed],
+  [0xa, OnboardingStep.SafetyWarning],
+  [0xb, OnboardingStep.Ready],
+  [0xc, OnboardingStep.ChooseName],
+  [0xd, OnboardingStep.RecoverRestore],
+  [0xe, OnboardingStep.SetupChoiceRestore],
+  [0xf, OnboardingStep.OnboardingEarlyCheck],
+  [0x10, OnboardingStep.RestoreCharon],
+  [CHARON_STEP_BIT_MASK + 0x0, OnboardingStep.Ready], // default state, after boot, if no backup was pending, this is also the state right after the device is seeded (if it was seeded with Charon)
+  [CHARON_STEP_BIT_MASK + 0x1, OnboardingStep.Ready], // backup fully refused
+  [CHARON_STEP_BIT_MASK + 0x2, OnboardingStep.BackupCharon], // backup not started or fully refused, this is the state right after the device is seeded (unless it was seeded with Charon)
+  [CHARON_STEP_BIT_MASK + 0x3, OnboardingStep.BackupCharon], // backup process started but not finished
+  [CHARON_STEP_BIT_MASK + 0x4, OnboardingStep.BackupCharon], // backup done on RK and naming not finished
+  [CHARON_STEP_BIT_MASK + 0x5, OnboardingStep.Ready], // backup done on RK and backup-process exited
 ]);
 
 export type OnboardingState = {
@@ -69,14 +80,36 @@ export type OnboardingState = {
 
   currentOnboardingStep: OnboardingStep;
   currentSeedWordIndex: number;
+  charonSupported: boolean;
+  charonStatus: CharonStatus | null;
 };
 
+export enum CharonStatus {
+  Rejected = 1,
+  Choice,
+  Running,
+  Naming,
+  Ready,
+}
+
+export const fromBitsToCharonStatusMap = new Map<number, CharonStatus>([
+  [0x1, CharonStatus.Rejected],
+  [0x2, CharonStatus.Choice],
+  [0x3, CharonStatus.Running],
+  [0x4, CharonStatus.Naming],
+  [0x5, CharonStatus.Ready],
+]);
+
 /**
  * Extracts the onboarding state of the device
  * @param flagsBytes Buffer of bytes of length onboardingFlagsBytesLength representing the device state flags
+ * @param charonStatusFlags Buffer of bytes of length charonStatusFlagsLength representing the charon status flags
  * @returns An OnboardingState
  */
-export const extractOnboardingState = (flagsBytes: Buffer): OnboardingState => {
+export const extractOnboardingState = (
+  flagsBytes: Buffer,
+  charonState?: Buffer,
+): OnboardingState => {
   if (!flagsBytes || flagsBytes.length < onboardingFlagsBytesLength) {
     throw new DeviceExtractOnboardingStateError("Incorrect onboarding flags bytes");
   }
@@ -94,7 +127,7 @@ export const extractOnboardingState = (flagsBytes: Buffer): OnboardingState => {
   }
 
   const currentOnboardingStepBits = flagsBytes[3];
-  const currentOnboardingStep = fromBitsToOnboardingStep.get(currentOnboardingStepBits);
+  let currentOnboardingStep = fromBitsToOnboardingStep.get(currentOnboardingStepBits);
 
   if (!currentOnboardingStep) {
     throw new DeviceExtractOnboardingStateError(
@@ -104,11 +137,41 @@ export const extractOnboardingState = (flagsBytes: Buffer): OnboardingState => {
 
   const currentSeedWordIndex = flagsBytes[2] & currentSeedWordIndexMask;
 
+  /*
+   * Once the device is seeded, there are some additional states for backing up with Charon (for devices that support it)
+   * There are 2 scenarios:
+   *  - After the seeding of the device, the user goes through the safety warnings screens (step SafetyWarning), and then, compatible devices will display the backup screens.
+   *    Then, the value of "currentOnboardingStep" is "Ready", and the additional information about the status of the backup is in the "charonState" buffer.
+   *  - If the device is rebooted while the backup screens are displayed on the device, it will still display the backup screens when it is turned back on.
+   *    Then, the value of "currentOnboardingStep" is "WelcomeScreen1", and the additional information about the status of the backup is in the "charonState" buffer.
+   */
+  if (
+    isOnboarded &&
+    [OnboardingStep.Ready, OnboardingStep.WelcomeScreen1].includes(currentOnboardingStep) &&
+    charonState !== undefined
+  ) {
+    currentOnboardingStep = fromBitsToOnboardingStep.get(charonState[0] + CHARON_STEP_BIT_MASK);
+
+    if (!currentOnboardingStep) {
+      throw new DeviceExtractOnboardingStateError(
+        "Incorrect onboarding bits for the current charon step",
+      );
+    }
+  }
+
+  const charonSupported = charonState !== undefined && charonState.length > 0;
+  const charonStatus =
+    charonSupported && fromBitsToCharonStatusMap.has(charonState[0])
+      ? fromBitsToCharonStatusMap.get(charonState[0])!
+      : null;
+
   return {
     isOnboarded,
     isInRecoveryMode,
     seedPhraseType,
     currentOnboardingStep,
     currentSeedWordIndex,
+    charonSupported,
+    charonStatus,
   };
 };

package/src/hw/getDeviceInfo.ts

@@ -61,10 +61,11 @@ export default async function (transport: Transport): Promise<DeviceInfo> {
     mcuBlVersion,
     mcuVersion,
     mcuTargetId,
-    flags,
     bootloaderVersion,
     hardwareVersion,
     languageId,
+    charonState,
+    flags,
   } = res;
   const isOSU = rawVersion.includes("-osu");
   const version = rawVersion.replace("-osu", "");
@@ -114,5 +115,7 @@ export default async function (transport: Transport): Promise<DeviceInfo> {
     bootloaderVersion,
     hardwareVersion,
     languageId,
+    charonState,
+    seFlags: flags,
   };
 }

package/src/hw/getGenuineCheckFromDeviceId.test.ts

@@ -41,7 +41,7 @@ jest.mock("./genuineCheck");
 const mockedGetDeviceInfo = jest.mocked(getDeviceInfo);
 const mockedGenuineCheck = jest.mocked(genuineCheck);
 
-const aDeviceInfo = {
+const aDeviceInfo: DeviceInfo = {
   mcuVersion: "A_MCU_VERSION",
   version: "A_VERSION",
   majMin: "A_MAJ_MIN",
@@ -51,6 +51,7 @@ const aDeviceInfo = {
   providerName: undefined,
   managerAllowed: false,
   pinValidated: true,
+  seFlags: Buffer.alloc(0),
 };
 
 describe("getGenuineCheckFromDeviceId", () => {

package/src/hw/getOnboardingStatePolling.test.ts

@@ -56,6 +56,8 @@ describe("getOnboardingStatePolling", () => {
       seedPhraseType: SeedPhraseType.TwentyFour,
       currentSeedWordIndex: 0,
       currentOnboardingStep: OnboardingStep.NewDevice,
+      charonSupported: false,
+      charonStatus: null,
     };
   });
 

package/src/hw/getOnboardingStatePolling.ts

@@ -83,7 +83,7 @@ export const getOnboardingStatePolling = ({
           }
 
           try {
-            onboardingState = extractOnboardingState(firmwareInfo.flags);
+            onboardingState = extractOnboardingState(firmwareInfo.flags, firmwareInfo.charonState);
           } catch (error: unknown) {
             if (error instanceof DeviceExtractOnboardingStateError) {
               return {

package/src/hw/isFirmwareUpdateVersionSupported.test.ts

@@ -1,4 +1,5 @@
 import { DeviceModelId } from "@ledgerhq/devices";
+import { DeviceInfo } from "@ledgerhq/types-live";
 import isFirmwareUpdateVersionSupported from "./isFirmwareUpdateVersionSupported";
 import { setEnv } from "@ledgerhq/live-env";
 
@@ -17,7 +18,7 @@ const badDataset: { [key in DeviceModelId]?: string[] } = {
 };
 
 describe("Firmware update version availability checks", () => {
-  const getDeviceInfo = version => ({
+  const getDeviceInfo = (version): DeviceInfo => ({
     version,
     mcuVersion: "0.0",
     majMin: "0.0",
@@ -27,6 +28,7 @@ describe("Firmware update version availability checks", () => {
     isBootloader: false,
     managerAllowed: false,
     pinValidated: false,
+    seFlags: Buffer.alloc(0),
   });
 
   describe("Fails with bad values", () => {

package/src/mock/fixtures/aDeviceInfo.ts

@@ -11,6 +11,7 @@ export const aDeviceInfoBuilder = (props?: Partial<DeviceInfo>): DeviceInfo => {
     providerName: undefined,
     managerAllowed: false,
     pinValidated: true,
+    seFlags: Buffer.alloc(0),
     ...props,
   };
 };

package/src/modularDrawer/__test__/useModularDrawerVisibility.test.ts

@@ -0,0 +1,149 @@
+/**
+ * @jest-environment jsdom
+ */
+import { renderHook } from "@testing-library/react";
+import { useModularDrawerVisibility } from "../useModularDrawerVisibility";
+import { ModularDrawerLocation } from "../enums";
+import {
+  makeMockedFeatureFlagsProviderWrapper,
+  makeMockedContextValue,
+} from "../../featureFlags/mock";
+
+describe("useModularDrawerVisibility", () => {
+  describe("lldModularDrawer", () => {
+    it("should return false if the feature flag is not enabled", () => {
+      const mockedFeatures = {
+        lldModularDrawer: {
+          enabled: false,
+          params: { [ModularDrawerLocation.ADD_ACCOUNT]: true },
+        },
+      };
+
+      const { result } = renderHook(
+        () =>
+          useModularDrawerVisibility({
+            modularDrawerFeatureFlagKey: "lldModularDrawer",
+          }),
+        {
+          wrapper: makeMockedFeatureFlagsProviderWrapper(makeMockedContextValue(mockedFeatures)),
+        },
+      );
+
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.ADD_ACCOUNT)).toBe(false);
+    });
+
+    it("should return false if the location param is not set", () => {
+      const mockedFeatures = {
+        lldModularDrawer: { enabled: true, params: {} },
+      };
+
+      const { result } = renderHook(
+        () =>
+          useModularDrawerVisibility({
+            modularDrawerFeatureFlagKey: "lldModularDrawer",
+          }),
+        {
+          wrapper: makeMockedFeatureFlagsProviderWrapper(makeMockedContextValue(mockedFeatures)),
+        },
+      );
+
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.ADD_ACCOUNT)).toBe(false);
+    });
+
+    it("should return the correct visibility for each location", () => {
+      const mockedFeatures = {
+        lldModularDrawer: {
+          enabled: true,
+          params: {
+            [ModularDrawerLocation.ADD_ACCOUNT]: true,
+            [ModularDrawerLocation.EARN_FLOW]: false,
+          },
+        },
+      };
+
+      const { result } = renderHook(
+        () =>
+          useModularDrawerVisibility({
+            modularDrawerFeatureFlagKey: "lldModularDrawer",
+          }),
+        {
+          wrapper: makeMockedFeatureFlagsProviderWrapper(makeMockedContextValue(mockedFeatures)),
+        },
+      );
+
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.ADD_ACCOUNT)).toBe(true);
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.EARN_FLOW)).toBe(false);
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.LIVE_APP)).toBe(false);
+    });
+  });
+
+  describe("llmModularDrawer", () => {
+    it("should return false if the feature flag is not enabled", () => {
+      const mockedFeatures = {
+        llmModularDrawer: {
+          enabled: false,
+          params: { [ModularDrawerLocation.ADD_ACCOUNT]: true },
+        },
+      };
+
+      const { result } = renderHook(
+        () =>
+          useModularDrawerVisibility({
+            modularDrawerFeatureFlagKey: "llmModularDrawer",
+          }),
+        {
+          wrapper: makeMockedFeatureFlagsProviderWrapper(makeMockedContextValue(mockedFeatures)),
+        },
+      );
+
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.ADD_ACCOUNT)).toBe(false);
+    });
+
+    it("should return false if the location param is not set", () => {
+      const mockedFeatures = {
+        llmModularDrawer: { enabled: true, params: {} },
+      };
+
+      const { result } = renderHook(
+        () =>
+          useModularDrawerVisibility({
+            modularDrawerFeatureFlagKey: "llmModularDrawer",
+          }),
+        {
+          wrapper: makeMockedFeatureFlagsProviderWrapper(makeMockedContextValue(mockedFeatures)),
+        },
+      );
+
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.ADD_ACCOUNT)).toBe(false);
+    });
+
+    it("should return the correct visibility for each location", () => {
+      const mockedFeatures = {
+        llmModularDrawer: {
+          enabled: true,
+          params: {
+            [ModularDrawerLocation.ADD_ACCOUNT]: false,
+            [ModularDrawerLocation.EARN_FLOW]: true,
+            [ModularDrawerLocation.RECEIVE_FLOW]: true,
+          },
+        },
+      };
+
+      const { result } = renderHook(
+        () =>
+          useModularDrawerVisibility({
+            modularDrawerFeatureFlagKey: "llmModularDrawer",
+          }),
+        {
+          wrapper: makeMockedFeatureFlagsProviderWrapper(makeMockedContextValue(mockedFeatures)),
+        },
+      );
+
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.ADD_ACCOUNT)).toBe(false);
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.EARN_FLOW)).toBe(true);
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.RECEIVE_FLOW)).toBe(true);
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.LIVE_APP)).toBe(false);
+      expect(result.current.isModularDrawerVisible(ModularDrawerLocation.SEND_FLOW)).toBe(false);
+    });
+  });
+});

package/src/modularDrawer/enums.ts

@@ -0,0 +1,7 @@
+export enum ModularDrawerLocation {
+  ADD_ACCOUNT = "add_account",
+  EARN_FLOW = "earn_flow",
+  LIVE_APP = "live_app",
+  RECEIVE_FLOW = "receive_flow",
+  SEND_FLOW = "send_flow",
+}

package/src/modularDrawer/useModularDrawerVisibility.ts

@@ -0,0 +1,25 @@
+import { useCallback } from "react";
+import { useFeature } from "../featureFlags";
+import { ModularDrawerLocation } from "./enums";
+
+type ModularDrawerFeatureFlagKey = "lldModularDrawer" | "llmModularDrawer";
+
+export function useModularDrawerVisibility({
+  modularDrawerFeatureFlagKey,
+}: {
+  modularDrawerFeatureFlagKey: ModularDrawerFeatureFlagKey;
+}) {
+  const featureModularDrawer = useFeature(modularDrawerFeatureFlagKey);
+
+  const isModularDrawerVisible = useCallback(
+    (location: ModularDrawerLocation) => {
+      if (!featureModularDrawer?.enabled) return false;
+      return featureModularDrawer.params?.[location] ?? false;
+    },
+    [featureModularDrawer],
+  );
+
+  return {
+    isModularDrawerVisible,
+  };
+}

package/src/onboarding/hooks/useOnboardingStatePolling.test.ts

@@ -36,6 +36,8 @@ describe("useOnboardingStatePolling", () => {
       seedPhraseType: SeedPhraseType.TwentyFour,
       currentSeedWordIndex: 0,
       currentOnboardingStep: OnboardingStep.NewDevice,
+      charonSupported: false,
+      charonStatus: null,
     };
 
     aSecondOnboardingState = {

package/src/wallet-api/types.ts

@@ -79,7 +79,7 @@ export type RecentlyUsedIdDb = {
 export type CurrentAccountHistIDb = Record<string, string>;
 
 export type DAppTrackingData = {
-  type: "approve" | "transfer";
+  type: string;
   currency: string;
   network: CryptoCurrency["id"];
 };

package/src/wallet-api/useDappLogic.ts

@@ -15,8 +15,8 @@ import BigNumber from "bignumber.js";
 import { safeEncodeEIP55 } from "@ledgerhq/coin-evm/logic";
 import { SmartWebsocket } from "./SmartWebsocket";
 import { stripHexPrefix } from "./helpers";
-import { DeviceTransactionField, getDeviceTransactionConfig } from "../transaction";
-import type { Transaction } from "../generated/types";
+import { getTxType } from "./utils/txTrackingHelper";
+import { Transaction as EvmTransaction } from "@ledgerhq/coin-evm/types/transaction";
 
 type MessageId = number | string | null;
 
@@ -205,16 +205,6 @@ function isParentAccountPresent(
   return true;
 }
 
-function getTransactionType(fields: Array<DeviceTransactionField>): string {
-  for (let i = 0; i < fields.length; i++) {
-    const field = fields[i];
-    if (field.type === "text" && field.label === "Type") {
-      return field.value;
-    }
-  }
-  return "";
-}
-
 export function useDappLogic({
   manifest,
   accounts,
@@ -490,20 +480,7 @@ export function useDappLogic({
                 account: currentAccount,
               });
 
-              const fields = getDeviceTransactionConfig({
-                account: currentAccount,
-                parentAccount: currentParentAccount,
-                transaction: signFlowInfos.liveTx as Transaction,
-                status: {
-                  errors: {},
-                  warnings: {},
-                  estimatedFees: new BigNumber(0),
-                  amount: new BigNumber(0),
-                  totalSpent: new BigNumber(0),
-                },
-              });
-
-              const transactionType = getTransactionType(fields);
+              const transactionType = getTxType(signFlowInfos.liveTx as EvmTransaction);
 
               const token = findTokenByAddress(tx.recipient);
 
@@ -518,7 +495,7 @@ export function useDappLogic({
                   : currentAccount.currency.id;
 
               trackingData = {
-                type: transactionType === "Approve" ? "approve" : "transfer",
+                type: transactionType,
                 currency: token ? token.name : accountCurrencyName,
                 network: token ? token.parentCurrency.id : accountNetwork,
               };