@ledgerhq/live-common 27.1.0 → 27.2.0-next.0

package/src/hw/deviceAccess.ts

@@ -76,7 +76,7 @@ const identifyTransport = (t) => (typeof t.id === "string" ? t.id : "");
 const needsCleanup = {};
 // when a series of APDUs are interrupted, this is called
 // so we don't forget to cleanup on the next withDevice
-export const cancelDeviceAction = (transport: Transport) => {
+export const cancelDeviceAction = (transport: Transport): void => {
   needsCleanup[identifyTransport(transport)] = true;
 };
 const deviceQueues = {};
@@ -158,7 +158,7 @@ export const withDevice =
         if (sub) sub.unsubscribe();
       };
     });
-export const genericCanRetryOnError = (err: Error | null | undefined) => {
+export const genericCanRetryOnError = (err: unknown): boolean => {
   if (err instanceof WrongAppForCurrency) return false;
   if (err instanceof WrongDeviceForAccount) return false;
   if (err instanceof CantOpenDevice) return false;

package/src/hw/getOnboardingStatePolling.ts

@@ -16,6 +16,7 @@ import {
   DeviceExtractOnboardingStateError,
   DisconnectedDevice,
   CantOpenDevice,
+  TransportRaceCondition,
 } from "@ledgerhq/errors";
 import { FirmwareInfo } from "@ledgerhq/types-live";
 import {
@@ -142,13 +143,16 @@ export const getOnboardingStatePolling = ({
   return delayedOnceOnboardingStateObservable.pipe(repeat());
 };
 
-export const isAllowedOnboardingStatePollingError = (error: Error): boolean => {
+export const isAllowedOnboardingStatePollingError = (
+  error: unknown
+): boolean => {
   if (
     error &&
     // Timeout error is thrown by rxjs's timeout
     (error instanceof TimeoutError ||
       error instanceof DisconnectedDevice ||
       error instanceof CantOpenDevice ||
+      error instanceof TransportRaceCondition ||
       error instanceof TransportStatusError)
   ) {
     return true;

package/src/hw/installLanguage.ts

@@ -125,7 +125,7 @@ export default function installLanguage({
 
               subscriber.complete();
             }),
-            catchError((e: Error) => {
+            catchError((e: unknown) => {
               if (
                 e instanceof DeviceOnDashboardExpected ||
                 (e &&

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

@@ -1,19 +1,38 @@
+import BigNumber from "bignumber.js";
 import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 import type { Account } from "@ledgerhq/types-live";
-import BigNumber from "bignumber.js";
+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",
+  rawMessage: "Sign raw results",
+};
+const signFunction = jest.fn(() => signResult);
+jest.mock("../../generated/hw-signMessage", () => {
+  return {
+    signExistFamily: {
+      prepareMessageToSign: function () {
+        return signFunction();
+      },
+    },
+    bitcoin: {
+      otherMethod: function () {},
+    },
+  };
+});
+
 describe("prepareMessageToSign", () => {
-  it("returns the prepared data from a simple string", () => {
+  it("calls the perFamily function if it's exist and returns this function results", () => {
     // Given
-    const crypto = createCryptoCurrency("ethereum");
+    const crypto = createFixtureCryptoCurrency("signExistFamily");
     const account = createAccount(crypto);
-    const message = "4d6573736167652064652074657374";
-    const expectedRawMessage = "0x4d6573736167652064652074657374";
+    const message = "whatever";
 
     // When
-    let result: MessageData | null = null;
+    let result: MessageData | TypedMessageData | undefined;
     let error: unknown = null;
     try {
       result = prepareMessageToSign(account, message);
@@ -23,10 +42,26 @@ describe("prepareMessageToSign", () => {
 
     // Then
     expect(error).toBeNull();
+    expect(signFunction).toBeCalledTimes(1);
+    expect(result).toEqual(signResult);
+  });
+
+  it("returns a default implementation if account is linked to a crypto able to sign but with no prepareMessageToSign function", () => {
+    // Given
+    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: crypto,
-      path: "44'/60'/0'/0/0",
-      derivationMode: "ethM",
+      currency,
+      path: expectedPath,
+      derivationMode: account.derivationMode,
       message: "Message de test",
       rawMessage: expectedRawMessage,
     });
@@ -34,12 +69,12 @@ describe("prepareMessageToSign", () => {
 
   it("returns an error if account is not linked to a crypto able to sign a message", () => {
     // Given
-    const crypto = createCryptoCurrency("mycoin");
+    const crypto = createFixtureCryptoCurrency("mycoin");
     const account = createAccount(crypto);
-    const message = "4d6573736167652064652074657374";
+    const message = "whatever";
 
     // When
-    let result: MessageData | null = null;
+    let result: MessageData | TypedMessageData | undefined;
     let error: Error | null = null;
     try {
       result = prepareMessageToSign(account, message);
@@ -48,43 +83,11 @@ describe("prepareMessageToSign", () => {
     }
 
     // Then
-    expect(result).toBeNull();
+    expect(result).toBeUndefined();
     expect(error).toEqual(Error("Crypto does not support signMessage"));
   });
 });
 
-const createCryptoCurrency = (family: string): CryptoCurrency => ({
-  type: "CryptoCurrency",
-  id: "testCoinId",
-  coinType: 8008,
-  name: "MyCoin",
-  managerAppName: "MyCoin",
-  ticker: "MYC",
-  countervalueTicker: "MYC",
-  scheme: "mycoin",
-  color: "#ff0000",
-  family,
-  units: [
-    {
-      name: "MYC",
-      code: "MYC",
-      magnitude: 8,
-    },
-    {
-      name: "SmallestUnit",
-      code: "SMALLESTUNIT",
-      magnitude: 0,
-    },
-  ],
-  explorerViews: [
-    {
-      address: "https://mycoinexplorer.com/account/$address",
-      tx: "https://mycoinexplorer.com/transaction/$hash",
-      token: "https://mycoinexplorer.com/token/$contractAddress/?a=$address",
-    },
-  ],
-});
-
 const createAccount = (crypto: CryptoCurrency): Account => ({
   type: "Account",
   id: "ethereumjs:2:ethereum:0x01:",

package/src/hw/signMessage/index.ts

@@ -13,17 +13,29 @@ 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, Resolver, Result } from "./types";
+import type { MessageData, SignMessage, Result } from "./types";
 import { DerivationMode } from "../../derivation";
 
 export const prepareMessageToSign = (
-  { currency, freshAddressPath, derivationMode }: Account,
+  account: Account,
   message: string
-): MessageData | null => {
+): MessageData => {
+  const { currency, freshAddressPath, derivationMode } = account;
+
   if (!perFamily[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
+    );
+  }
+
+  // Default implementation
   return {
     currency: currency,
     path: freshAddressPath,
@@ -33,9 +45,9 @@ export const prepareMessageToSign = (
   };
 };
 
-const dispatch: Resolver = (transport, opts) => {
+const signMessage: SignMessage = (transport, opts) => {
   const { currency, verify } = opts;
-  const signMessage = perFamily[currency.family];
+  const signMessage = perFamily[currency.family].signMessage;
   invariant(signMessage, `signMessage is not implemented for ${currency.id}`);
   return signMessage(transport, opts)
     .then((result) => {
@@ -87,7 +99,7 @@ export const signMessageExec = ({
   deviceId,
 }: Input): Observable<Result> => {
   const result: Observable<Result> = withDevice(deviceId)((transport) =>
-    from(dispatch(transport, request.message))
+    from(signMessage(transport, request.message))
   );
   return result;
 };
@@ -99,8 +111,10 @@ const initialState: BaseState = {
 };
 
 export const createAction = (
-  connectAppExec: (arg0: ConnectAppInput) => Observable<ConnectAppEvent>,
-  signMessage: (arg0: Input) => Observable<Result> = signMessageExec
+  connectAppExec: (
+    connectAppInput: ConnectAppInput
+  ) => Observable<ConnectAppEvent>,
+  signMessage: (input: Input) => Observable<Result> = signMessageExec
 ) => {
   const useHook = (
     reduxDevice: Device | null | undefined,
@@ -175,4 +189,4 @@ export const createAction = (
     }),
   };
 };
-export default dispatch;
+export default signMessage;

package/src/hw/signMessage/types.ts

@@ -17,4 +17,7 @@ export type MessageData = {
   message: string;
   rawMessage: string;
 };
-export type Resolver = (arg0: Transport, arg1: MessageData) => Promise<Result>;
+export type SignMessage = (
+  transport: Transport,
+  message: MessageData
+) => Promise<Result>;

package/src/hw/uninstallLanguage.ts

@@ -82,7 +82,7 @@ export default function unistallLanguage({
 
               subscriber.complete();
             }),
-            catchError((e: Error) => {
+            catchError((e: unknown) => {
               if (
                 e instanceof DeviceOnDashboardExpected ||
                 (e &&

package/src/walletconnect/index.ts

@@ -39,7 +39,7 @@ export type WCCallRequest =
       method: "send" | "sign";
       data: Transaction;
     };
-type Parser = (arg0: Account, arg1: WCPayload) => Promise<WCCallRequest>;
+type Parser = (account: Account, payload: WCPayload) => Promise<WCCallRequest>;
 export const parseCallRequest: Parser = async (account, payload) => {
   let wcTransactionData, bridge, transaction, message, rawMessage, hashes;
 
@@ -52,12 +52,11 @@ export const parseCallRequest: Parser = async (account, payload) => {
 
     // @dev: Today, `eth_signTypedData` is versionned. We can't only check `eth_signTypedData`
     //       This regex matches `eth_signTypedData` and `eth_signTypedData_v[0-9]`
+    // https://docs.metamask.io/guide/signing-data.html
     case payload.method.match(/eth_signTypedData(_v.)?$/)?.input:
       message = JSON.parse(payload.params[1]);
       hashes = {
-        // $FlowFixMe
         domainHash: bufferToHex(domainHash(message)),
-        // $FlowFixMe
         messageHash: bufferToHex(messageHash(message)),
       };
     case "eth_sign":
@@ -67,7 +66,6 @@ export const parseCallRequest: Parser = async (account, payload) => {
         stringHash:
           "0x" +
           sha("sha256")
-            // $FlowFixMe
             .update(Buffer.from(payload.params[1].slice(2), "hex"))
             .digest("hex"),
       };
@@ -76,16 +74,10 @@ export const parseCallRequest: Parser = async (account, payload) => {
         message || Buffer.from(payload.params[0].slice(2), "hex").toString();
       rawMessage = rawMessage || payload.params[0];
       hashes = hashes || {
-        stringHash:
-          "0x" +
-          sha("sha256")
-            // $FlowFixMe
-            .update(message)
-            .digest("hex"),
+        stringHash: "0x" + sha("sha256").update(message).digest("hex"),
       };
       return {
         type: "message",
-        // $FlowFixMe (can't figure out MessageData | TypedMessageData)
         data: {
           path: account.freshAddressPath,
           message,

package/src/walletconnect/walletconnect.test.ts

@@ -51,6 +51,7 @@ describe("walletconnect", () => {
       })
     ).rejects.toThrow("wrong payload");
   });
+
   test("should parse personal_sign payloads", async () => {
     expect(
       await parseCallRequest(account, {
@@ -132,6 +133,7 @@ describe("walletconnect", () => {
       type: "message",
     });
   });
+
   test("should parse eth_sendTransaction payloads", async () => {
     const raw: WCPayloadTransaction = {
       data: "0x",