@ledgerhq/live-common 31.2.0 → 31.3.0-next.0

package/src/generated/transaction.ts

@@ -7,9 +7,11 @@ import elrond from "../families/elrond/transaction";
 import ethereum from "../families/ethereum/transaction";
 import filecoin from "../families/filecoin/transaction";
 import hedera from "../families/hedera/transaction";
+import internet_computer from "../families/internet_computer/transaction";
 import near from "../families/near/transaction";
 import ripple from "../families/ripple/transaction";
 import solana from "../families/solana/transaction";
+import stacks from "../families/stacks/transaction";
 import stellar from "../families/stellar/transaction";
 import tezos from "../families/tezos/transaction";
 import tron from "../families/tron/transaction";
@@ -27,9 +29,11 @@ export default {
   ethereum,
   filecoin,
   hedera,
+  internet_computer,
   near,
   ripple,
   solana,
+  stacks,
   stellar,
   tezos,
   tron,

package/src/generated/types.ts

@@ -42,6 +42,10 @@ import { Transaction as hederaTransaction } from "../families/hedera/types";
 import { TransactionRaw as hederaTransactionRaw } from "../families/hedera/types";
 import { TransactionStatus as hederaTransactionStatus } from "../families/hedera/types";
 import { TransactionStatusRaw as hederaTransactionStatusRaw } from "../families/hedera/types";
+import { Transaction as internet_computerTransaction } from "../families/internet_computer/types";
+import { TransactionRaw as internet_computerTransactionRaw } from "../families/internet_computer/types";
+import { TransactionStatus as internet_computerTransactionStatus } from "../families/internet_computer/types";
+import { TransactionStatusRaw as internet_computerTransactionStatusRaw } from "../families/internet_computer/types";
 import { Transaction as nearTransaction } from "../families/near/types";
 import { TransactionRaw as nearTransactionRaw } from "../families/near/types";
 import { TransactionStatus as nearTransactionStatus } from "../families/near/types";
@@ -58,6 +62,10 @@ import { Transaction as solanaTransaction } from "../families/solana/types";
 import { TransactionRaw as solanaTransactionRaw } from "../families/solana/types";
 import { TransactionStatus as solanaTransactionStatus } from "../families/solana/types";
 import { TransactionStatusRaw as solanaTransactionStatusRaw } from "../families/solana/types";
+import { Transaction as stacksTransaction } from "../families/stacks/types";
+import { TransactionRaw as stacksTransactionRaw } from "../families/stacks/types";
+import { TransactionStatus as stacksTransactionStatus } from "../families/stacks/types";
+import { TransactionStatusRaw as stacksTransactionStatusRaw } from "../families/stacks/types";
 import { Transaction as stellarTransaction } from "../families/stellar/types";
 import { TransactionRaw as stellarTransactionRaw } from "../families/stellar/types";
 import { TransactionStatus as stellarTransactionStatus } from "../families/stellar/types";
@@ -83,10 +91,12 @@ export type Transaction =
   | evmTransaction
   | filecoinTransaction
   | hederaTransaction
+  | internet_computerTransaction
   | nearTransaction
   | polkadotTransaction
   | rippleTransaction
   | solanaTransaction
+  | stacksTransaction
   | stellarTransaction
   | tezosTransaction
   | tronTransaction;
@@ -103,10 +113,12 @@ export type TransactionRaw =
   | evmTransactionRaw
   | filecoinTransactionRaw
   | hederaTransactionRaw
+  | internet_computerTransactionRaw
   | nearTransactionRaw
   | polkadotTransactionRaw
   | rippleTransactionRaw
   | solanaTransactionRaw
+  | stacksTransactionRaw
   | stellarTransactionRaw
   | tezosTransactionRaw
   | tronTransactionRaw;
@@ -123,10 +135,12 @@ export type TransactionStatus =
   | evmTransactionStatus
   | filecoinTransactionStatus
   | hederaTransactionStatus
+  | internet_computerTransactionStatus
   | nearTransactionStatus
   | polkadotTransactionStatus
   | rippleTransactionStatus
   | solanaTransactionStatus
+  | stacksTransactionStatus
   | stellarTransactionStatus
   | tezosTransactionStatus
   | tronTransactionStatus;
@@ -143,10 +157,12 @@ export type TransactionStatusRaw =
   | evmTransactionStatusRaw
   | filecoinTransactionStatusRaw
   | hederaTransactionStatusRaw
+  | internet_computerTransactionStatusRaw
   | nearTransactionStatusRaw
   | polkadotTransactionStatusRaw
   | rippleTransactionStatusRaw
   | solanaTransactionStatusRaw
+  | stacksTransactionStatusRaw
   | stellarTransactionStatusRaw
   | tezosTransactionStatusRaw
   | tronTransactionStatusRaw;

package/src/hooks/recoverFeatueFlag.ts

@@ -1,5 +1,9 @@
 import { useMemo } from "react";
 import { Feature } from "@ledgerhq/types-live";
+import { defaultFeatures } from "../featureFlags";
+
+type DesktopFeature = (typeof defaultFeatures)["protectServicesDesktop"]["params"];
+type MobileFeature = (typeof defaultFeatures)["protectServicesMobile"]["params"];
 
 export function useReplacedURI(uri?: string, id?: string): string | undefined {
   return useMemo(() => {
@@ -7,31 +11,69 @@ export function useReplacedURI(uri?: string, id?: string): string | undefined {
   }, [id, uri]);
 }
 
-export function usePostOnboardingURI(servicesConfig: Feature<any> | null): string | undefined {
+function usePath(servicesConfig: Feature<unknown> | null, uri?: string) {
+  return useMemo(() => {
+    return servicesConfig?.enabled ? uri?.replace("ledgerlive://", "/") : undefined;
+  }, [servicesConfig?.enabled, uri]);
+}
+
+export function usePostOnboardingURI(
+  servicesConfig: Feature<MobileFeature | DesktopFeature> | null,
+): string | undefined {
   const uri = servicesConfig?.params?.onboardingRestore?.postOnboardingURI;
   const id = servicesConfig?.params?.protectId;
 
   return useReplacedURI(uri, id);
 }
 
-export function usePostOnboardingPath(servicesConfig: Feature<any> | null): string | undefined {
+export function usePostOnboardingPath(
+  servicesConfig: Feature<DesktopFeature> | null,
+): string | undefined {
   const uri = usePostOnboardingURI(servicesConfig);
 
-  return useMemo(() => {
-    return servicesConfig?.enabled ? uri?.replace("ledgerlive://", "/") : undefined;
-  }, [servicesConfig?.enabled, uri]);
+  return usePath(servicesConfig, uri);
 }
 
-export function useLearnMoreURI(servicesConfig: Feature<any> | null): string | undefined {
+export function useLearnMoreURI(servicesConfig: Feature<MobileFeature> | null): string | undefined {
   const uri = servicesConfig?.params?.managerStatesData?.NEW?.learnMoreURI;
   const id = servicesConfig?.params?.protectId;
 
   return useReplacedURI(uri, id);
 }
 
-export function useAlreadySubscribedURI(servicesConfig: Feature<any> | null): string | undefined {
+export function useAlreadySubscribedURI(
+  servicesConfig: Feature<MobileFeature> | null,
+): string | undefined {
   const uri = servicesConfig?.params?.managerStatesData?.NEW?.alreadySubscribedURI;
   const id = servicesConfig?.params?.protectId;
 
   return useReplacedURI(uri, id);
 }
+
+export function useUpsellURI(servicesConfig: Feature<DesktopFeature> | null): string | undefined {
+  const uri = servicesConfig?.params?.onboardingCompleted?.upsellURI;
+  const id = servicesConfig?.params?.protectId;
+
+  return useReplacedURI(uri, id);
+}
+
+export function useUpsellPath(servicesConfig: Feature<DesktopFeature> | null): string | undefined {
+  const uri = useUpsellURI(servicesConfig);
+
+  return usePath(servicesConfig, uri);
+}
+
+export function useLoginURI(
+  servicesConfig: Feature<MobileFeature | DesktopFeature> | null,
+): string | undefined {
+  const uri = servicesConfig?.params?.account?.loginURI;
+  const id = servicesConfig?.params?.protectId;
+
+  return useReplacedURI(uri, id);
+}
+
+export function useLoginPath(servicesConfig: Feature<DesktopFeature> | null): string | undefined {
+  const uri = useLoginURI(servicesConfig);
+
+  return usePath(servicesConfig, uri);
+}

package/src/hw/getLatestAvailableFirmwareFromDeviceId.test.ts

@@ -58,6 +58,50 @@ describe("getLatestAvailableFirmwareFromDeviceId", () => {
     jest.clearAllTimers();
   });
 
+  describe("The device is in a correct state", () => {
+    it("should return the latest available firmware for the device", done => {
+      // Happy path
+      mockedGetDeviceInfo.mockResolvedValue(aDeviceInfo);
+      mockedGetLatestFirmwareForDevice.mockResolvedValue(aLatestFirmwareContext);
+
+      let step = 1;
+
+      getLatestAvailableFirmwareFromDeviceId({
+        deviceId: "A_DEVICE_ID",
+      }).subscribe({
+        next: ({
+          firmwareUpdateContext,
+          deviceInfo,
+          lockedDevice,
+          status,
+        }: GetLatestAvailableFirmwareFromDeviceIdResult) => {
+          try {
+            switch (step) {
+              case 1:
+                expect(firmwareUpdateContext).toBeNull();
+                expect(deviceInfo).toEqual(aDeviceInfo);
+                expect(lockedDevice).toBe(false);
+                expect(status).toBe("started");
+                // No need to advance the timer, as the retry timer is mocked to return directly, without a timeout
+                break;
+              case 2:
+                expect(firmwareUpdateContext).toEqual(aLatestFirmwareContext);
+                expect(deviceInfo).toEqual(aDeviceInfo);
+                expect(lockedDevice).toBe(false);
+                expect(status).toBe("done");
+                done();
+                break;
+            }
+          } catch (expectError) {
+            done(expectError);
+          }
+
+          step += 1;
+        },
+      });
+    });
+  });
+
   describe("The device is locked, and the mechanism to know that a device is locked is a 0x5515 locked-device response", () => {
     it("should notify the function consumer of the need to unlock the device, and once done, continue the get latest available firmware flow", done => {
       let count = 0;
@@ -84,6 +128,7 @@ describe("getLatestAvailableFirmwareFromDeviceId", () => {
       }).subscribe({
         next: ({
           firmwareUpdateContext,
+          deviceInfo,
           lockedDevice,
           status,
         }: GetLatestAvailableFirmwareFromDeviceIdResult) => {
@@ -91,6 +136,7 @@ describe("getLatestAvailableFirmwareFromDeviceId", () => {
             switch (step) {
               case 1:
                 expect(firmwareUpdateContext).toBeNull();
+                expect(deviceInfo).toBeNull();
                 expect(lockedDevice).toBe(true);
                 expect(status).toBe("started");
                 // No need to advance the timer, as the retry timer is mocked to return directly, without a timeout
@@ -98,11 +144,13 @@ describe("getLatestAvailableFirmwareFromDeviceId", () => {
               // A retry happened, this time with an unlocked device
               case 2:
                 expect(firmwareUpdateContext).toBeNull();
+                expect(deviceInfo).toEqual(aDeviceInfo);
                 expect(lockedDevice).toBe(false);
                 expect(status).toBe("started");
                 break;
               case 3:
                 expect(firmwareUpdateContext).toEqual(aLatestFirmwareContext);
+                expect(deviceInfo).toEqual(aDeviceInfo);
                 expect(lockedDevice).toBe(false);
                 expect(status).toBe("done");
                 done();

package/src/hw/getLatestAvailableFirmwareFromDeviceId.ts

@@ -1,6 +1,6 @@
-import { from, Observable } from "rxjs";
+import { forkJoin, from, Observable, of } from "rxjs";
 import { mergeMap, retryWhen } from "rxjs/operators";
-import type { FirmwareUpdateContext, DeviceId } from "@ledgerhq/types-live";
+import type { FirmwareUpdateContext, DeviceId, DeviceInfo } from "@ledgerhq/types-live";
 import manager from "../manager";
 import { retryWhileErrors, withDevice } from "./deviceAccess";
 import getDeviceInfo from "./getDeviceInfo";
@@ -14,6 +14,7 @@ export type GetLatestAvailableFirmwareFromDeviceIdStatus = "started" | "done";
 
 export type GetLatestAvailableFirmwareFromDeviceIdResult = {
   firmwareUpdateContext: FirmwareUpdateContext | null;
+  deviceInfo: DeviceInfo | null;
   status: GetLatestAvailableFirmwareFromDeviceIdStatus;
   lockedDevice: boolean;
 };
@@ -26,6 +27,7 @@ export type GetLatestAvailableFirmwareFromDeviceIdOutput =
  * @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
+ * - deviceInfo: a DeviceInfo if found, or null otherwise (if device locked for ex)
  * - lockedDevice: a boolean set to true if the device is currently locked, false otherwise
  * - status: to notify the consumer on the state of the request
  */
@@ -39,10 +41,12 @@ export const getLatestAvailableFirmwareFromDeviceId = ({
         mergeMap(deviceInfo => {
           subscriber.next({
             firmwareUpdateContext: null,
+            deviceInfo,
             lockedDevice: false,
             status: "started",
           });
-          return from(manager.getLatestFirmwareForDevice(deviceInfo));
+
+          return forkJoin([of(deviceInfo), from(manager.getLatestFirmwareForDevice(deviceInfo))]);
         }),
       ),
     ) // Needs to retry with withDevice
@@ -52,6 +56,7 @@ export const getLatestAvailableFirmwareFromDeviceId = ({
             if (e instanceof LockedDeviceError) {
               subscriber.next({
                 firmwareUpdateContext: null,
+                deviceInfo: null,
                 lockedDevice: true,
                 status: "started",
               });
@@ -63,12 +68,14 @@ export const getLatestAvailableFirmwareFromDeviceId = ({
         ),
       )
       .subscribe({
-        next: (firmwareUpdateContext: FirmwareUpdateContext | null) =>
+        next: ([deviceInfo, firmwareUpdateContext]: [DeviceInfo, FirmwareUpdateContext | null]) => {
           subscriber.next({
             firmwareUpdateContext,
+            deviceInfo,
             status: "done",
             lockedDevice: false,
-          }),
+          });
+        },
         error: e => subscriber.error(e),
         complete: () => subscriber.complete(),
       });

package/src/hw/hooks/useGetLatestAvailableFirmware.test.ts

@@ -1,7 +1,8 @@
 import { of } from "rxjs";
-import { FirmwareUpdateContext } from "@ledgerhq/types-live";
+import { DeviceInfo, FirmwareUpdateContext } from "@ledgerhq/types-live";
 import { renderHook, act } from "@testing-library/react-hooks";
 import { aLatestFirmwareContextBuilder } from "../../mock/fixtures/aLatestFirmwareContext";
+import { aDeviceInfoBuilder } from "../../mock/fixtures/aDeviceInfo";
 import { getLatestAvailableFirmwareFromDeviceId } from "../getLatestAvailableFirmwareFromDeviceId";
 import { useGetLatestAvailableFirmware } from "./useGetLatestAvailableFirmware";
 
@@ -14,9 +15,11 @@ const mockedGetLatestAvailableFirmwareFromDeviceId = jest.mocked(
 
 describe("useGetLatestAvailableFirmware", () => {
   let aLatestFirmwareContext: FirmwareUpdateContext;
+  let aDeviceInfo: DeviceInfo;
 
   beforeEach(() => {
     aLatestFirmwareContext = aLatestFirmwareContextBuilder();
+    aDeviceInfo = aDeviceInfoBuilder();
   });
 
   afterEach(() => {
@@ -25,10 +28,11 @@ describe("useGetLatestAvailableFirmware", () => {
   });
 
   describe("When no new firmware update is available for a device", () => {
-    it("should notify the hook consumer that there is no latest available firmware", async () => {
+    it("should notify the hook consumer that there is no latest available firmware, and returns the device info", async () => {
       mockedGetLatestAvailableFirmwareFromDeviceId.mockReturnValue(
         of({
           firmwareUpdateContext: null,
+          deviceInfo: aDeviceInfo,
           lockedDevice: false,
           status: "done",
         }),
@@ -47,14 +51,16 @@ describe("useGetLatestAvailableFirmware", () => {
       expect(result.current.status).toEqual("no-available-firmware");
       expect(result.current.error).toBeNull();
       expect(result.current.latestFirmware).toBeNull();
+      expect(result.current.deviceInfo).toEqual(aDeviceInfo);
     });
   });
 
   describe("When a new firmware update is available for a device", () => {
-    it("should notify the hook consumer that there is a new latest available firmware", async () => {
+    it("should notify the hook consumer that there is a new latest available firmware, and return the device info", async () => {
       mockedGetLatestAvailableFirmwareFromDeviceId.mockReturnValue(
         of({
           firmwareUpdateContext: aLatestFirmwareContext,
+          deviceInfo: aDeviceInfo,
           lockedDevice: false,
           status: "done",
         }),
@@ -73,6 +79,7 @@ describe("useGetLatestAvailableFirmware", () => {
       expect(result.current.status).toEqual("available-firmware");
       expect(result.current.error).toBeNull();
       expect(result.current.latestFirmware).toEqual(aLatestFirmwareContext);
+      expect(result.current.deviceInfo).toEqual(aDeviceInfo);
     });
   });
 
@@ -81,6 +88,7 @@ describe("useGetLatestAvailableFirmware", () => {
       mockedGetLatestAvailableFirmwareFromDeviceId.mockReturnValue(
         of({
           firmwareUpdateContext: null,
+          deviceInfo: null,
           lockedDevice: true,
           status: "started",
         }),
@@ -101,6 +109,7 @@ describe("useGetLatestAvailableFirmware", () => {
       expect(result.current.status).toEqual("checking");
       expect(result.current.error).toBeNull();
       expect(result.current.latestFirmware).toBeNull();
+      expect(result.current.deviceInfo).toBeNull();
     });
   });
 });

package/src/hw/hooks/useGetLatestAvailableFirmware.ts

@@ -1,5 +1,5 @@
 import { useEffect, useState } from "react";
-import type { FirmwareUpdateContext, DeviceId } from "@ledgerhq/types-live";
+import type { FirmwareUpdateContext, DeviceId, DeviceInfo } from "@ledgerhq/types-live";
 import type {
   GetLatestAvailableFirmwareFromDeviceIdArgs,
   GetLatestAvailableFirmwareFromDeviceIdResult,
@@ -26,6 +26,7 @@ export type useGetLatestAvailableFirmwareArgs = {
 
 export type useGetLatestAvailableFirmwareResult = {
   latestFirmware: FirmwareUpdateContext | null;
+  deviceInfo: DeviceInfo | null;
   status: FirmwareUpdateGettingStatus;
   lockedDevice: boolean;
   error: Error | null;
@@ -39,8 +40,9 @@ export type useGetLatestAvailableFirmwareResult = {
  * @param isHookEnabled A boolean to enable (true, default value) or disable (false) the hook
  * @param deviceId A device id, or an empty string if device is usb plugged
  * @returns An object containing:
- * - latestFirmware A FirmwareUpdateContext if found, or null if still processing or no available firmware update
- * - status A FirmwareUpdateGettingStatus to notify consumer on the hook state
+ * - latestFirmware: A FirmwareUpdateContext if found, or null if still processing or no available firmware update
+ * - deviceInfo: a DeviceInfo if found, or null otherwise (if device locked for ex)
+ * - status: A FirmwareUpdateGettingStatus to notify consumer on the hook state
  * - lockedDevice: a boolean set to true if the device is currently locked, false otherwise
  * - error: any error that occurred during the process, or null
  */
@@ -51,6 +53,7 @@ export const useGetLatestAvailableFirmware = ({
 }: useGetLatestAvailableFirmwareArgs &
   useGetLatestAvailableFirmwareDependencies): useGetLatestAvailableFirmwareResult => {
   const [latestFirmware, setLatestFirmware] = useState<FirmwareUpdateContext | null>(null);
+  const [deviceInfo, setDeviceInfo] = useState<DeviceInfo | null>(null);
   const [error, setError] = useState<Error | null>(null);
   const [status, setStatus] = useState<FirmwareUpdateGettingStatus>("unchecked");
   const [lockedDevice, setLockedDevice] = useState<boolean>(false);
@@ -64,11 +67,13 @@ export const useGetLatestAvailableFirmware = ({
     const sub = getLatestAvailableFirmwareFromDeviceId({ deviceId }).subscribe({
       next: ({
         firmwareUpdateContext,
+        deviceInfo,
         lockedDevice,
         status: getStatus,
       }: GetLatestAvailableFirmwareFromDeviceIdResult) => {
         // A boolean, this will not trigger a rendering if the value is the same
         setLockedDevice(lockedDevice);
+        setDeviceInfo(deviceInfo);
 
         if (getStatus === "done") {
           if (!firmwareUpdateContext) {
@@ -80,7 +85,7 @@ export const useGetLatestAvailableFirmware = ({
           }
         }
       },
-      error: (e: any) => {
+      error: (e: unknown) => {
         if (e instanceof Error) {
           setError(e);
         } else {
@@ -94,5 +99,5 @@ export const useGetLatestAvailableFirmware = ({
     };
   }, [deviceId, getLatestAvailableFirmwareFromDeviceId, isHookEnabled]);
 
-  return { latestFirmware, error, status, lockedDevice };
+  return { latestFirmware, deviceInfo, error, status, lockedDevice };
 };

package/src/hw/signMessage/index.test.ts

@@ -1,10 +1,8 @@
 import BigNumber from "bignumber.js";
 import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
-import type { Account } from "@ledgerhq/types-live";
+import type { Account, AnyMessage } from "@ledgerhq/types-live";
 import { createFixtureCryptoCurrency } from "../../mock/fixtures/cryptoCurrencies";
-import { TypedMessageData } from "../../families/ethereum/types";
 import { prepareMessageToSign } from "./index";
-import { MessageData } from "./types";
 
 const signResult = {
   message: "Sign results",
@@ -32,7 +30,7 @@ describe("prepareMessageToSign", () => {
     const message = "whatever";
 
     // When
-    let result: MessageData | TypedMessageData | undefined;
+    let result: AnyMessage | undefined;
     let error: unknown = null;
     try {
       result = prepareMessageToSign(account, message);
@@ -51,19 +49,13 @@ describe("prepareMessageToSign", () => {
     const currency = createFixtureCryptoCurrency("bitcoin");
     const account = createAccount(currency);
     const message = "4d6573736167652064652074657374";
-    const expectedPath = "44'/60'/0'/0/0";
-    const expectedRawMessage = "0x4d6573736167652064652074657374";
 
     // // When
     const result = prepareMessageToSign(account, message);
 
     // // Then
     expect(result).toEqual({
-      currency,
-      path: expectedPath,
-      derivationMode: account.derivationMode,
       message: "Message de test",
-      rawMessage: expectedRawMessage,
     });
   });
 
@@ -74,7 +66,7 @@ describe("prepareMessageToSign", () => {
     const message = "whatever";
 
     // When
-    let result: MessageData | TypedMessageData | undefined;
+    let result: AnyMessage | undefined;
     let error: Error | null = null;
     try {
       result = prepareMessageToSign(account, message);

package/src/hw/signMessage/index.ts

@@ -1,69 +1,52 @@
-import { DeviceAppVerifyNotSupported, UserRefusedAddress } from "@ledgerhq/errors";
+import { UserRefusedAddress } from "@ledgerhq/errors";
 import { log } from "@ledgerhq/logs";
 import invariant from "invariant";
 import { useCallback, useEffect, useRef, useState } from "react";
 import { from, Observable } from "rxjs";
 import perFamily from "../../generated/hw-signMessage";
-import { Account } from "@ledgerhq/types-live";
+import { Account, AnyMessage } from "@ledgerhq/types-live";
 import type { AppRequest, AppState } from "../actions/app";
 import { createAction as createAppAction } from "../actions/app";
 import type { Device } from "../actions/types";
 import type { ConnectAppEvent, Input as ConnectAppInput } from "../connectApp";
 import { withDevice } from "../deviceAccess";
-import type { MessageData, SignMessage, Result } from "./types";
-import { DerivationMode } from "@ledgerhq/coin-framework/derivation";
-import { TypedMessageData } from "../../families/ethereum/types";
+import type { SignMessage, Result } from "./types";
 
-export const prepareMessageToSign = (
-  account: Account,
-  message: string,
-): MessageData | TypedMessageData => {
-  const { currency, freshAddressPath, derivationMode } = account;
+export const prepareMessageToSign = (account: Account, message: string): AnyMessage => {
+  const utf8Message = Buffer.from(message, "hex").toString();
 
-  if (!perFamily[currency.family]) {
+  if (!perFamily[account.currency.family]) {
     throw new Error("Crypto does not support signMessage");
   }
 
-  if ("prepareMessageToSign" in perFamily[currency.family]) {
-    return perFamily[currency.family].prepareMessageToSign(
-      currency,
-      freshAddressPath,
-      derivationMode,
-      message,
-    );
+  if ("prepareMessageToSign" in perFamily[account.currency.family]) {
+    return perFamily[account.currency.family].prepareMessageToSign({
+      account,
+      message: utf8Message,
+    });
   }
 
   // Default implementation
-  return {
-    currency: currency,
-    path: freshAddressPath,
-    derivationMode: derivationMode as DerivationMode,
-    message: Buffer.from(message, "hex").toString(),
-    rawMessage: "0x" + message,
-  };
+  return { message: utf8Message };
 };
 
-const signMessage: SignMessage = (transport, opts) => {
-  const { currency, verify } = opts;
+const signMessage: SignMessage = (transport, account, opts) => {
+  const { currency } = account;
   const signMessage = perFamily[currency.family].signMessage;
   invariant(signMessage, `signMessage is not implemented for ${currency.id}`);
-  return signMessage(transport, opts)
+  return signMessage(transport, account, opts)
     .then(result => {
       log(
         "hw",
-        `signMessage ${currency.id} on ${opts.path} with message [${opts.message}]`,
+        `signMessage ${currency.id} on ${account.freshAddressPath} with message [${opts.message}]`,
         result,
       );
       return result;
     })
     .catch(e => {
-      log("hw", `signMessage ${currency.id} on ${opts.path} FAILED ${String(e)}`);
+      log("hw", `signMessage ${currency.id} on ${account.freshAddressPath} FAILED ${String(e)}`);
 
       if (e && e.name === "TransportStatusError") {
-        if (e.statusCode === 0x6b00 && verify) {
-          throw new DeviceAppVerifyNotSupported();
-        }
-
         if (e.statusCode === 0x6985 || e.statusCode === 0x5501) {
           throw new UserRefusedAddress();
         }
@@ -74,14 +57,14 @@ const signMessage: SignMessage = (transport, opts) => {
 };
 
 type BaseState = {
-  signMessageRequested: MessageData | TypedMessageData | null | undefined;
+  signMessageRequested: AnyMessage | null | undefined;
   signMessageError: Error | null | undefined;
   signMessageResult: string | null | undefined;
 };
 
 export type State = AppState & BaseState;
 export type Request = AppRequest & {
-  message: MessageData | TypedMessageData;
+  message: AnyMessage;
 };
 
 export type Input = {
@@ -90,8 +73,12 @@ export type Input = {
 };
 
 export const signMessageExec = ({ request, deviceId }: Input): Observable<Result> => {
+  if (!request.account) {
+    throw new Error("account is required");
+  }
+
   const result: Observable<Result> = withDevice(deviceId)(transport =>
-    from(signMessage(transport, request.message)),
+    from(signMessage(transport, request.account!, request.message)),
   );
   return result;
 };

package/src/hw/signMessage/types.ts

@@ -1,24 +1,23 @@
-import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 import Transport from "@ledgerhq/hw-transport";
-import type { DerivationMode } from "@ledgerhq/coin-framework/derivation";
-import { TypedMessageData } from "../../families/ethereum/types";
+import { Account, DeviceId, AnyMessage } from "@ledgerhq/types-live";
+
 export type Result = {
   rsv: {
     r: string;
     s: string;
-    v: number;
+    v: number | string;
   };
   signature: string;
 };
-export type MessageData = {
-  currency: CryptoCurrency;
-  path: string;
-  verify?: boolean;
-  derivationMode: DerivationMode;
-  message: string;
-  rawMessage: string;
-};
+
 export type SignMessage = (
   transport: Transport,
-  message: MessageData | TypedMessageData,
+  account: Account,
+  messageData: AnyMessage,
+) => Promise<Result>;
+
+export type MessageSignerFn = (
+  deviceId: DeviceId,
+  account: Account,
+  messageData: AnyMessage,
 ) => Promise<Result>;