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

package/src/families/filecoin/__snapshots__/bridge.integration.test.ts.snap

@@ -2,6 +2,32 @@
 
 exports[`filecoin currency bridge scanAccounts filecoin seed 1 1`] = `
 Array [
+  Object {
+    "balance": "1000000000000000",
+    "currencyId": "filecoin",
+    "derivationMode": "gliflegacy",
+    "freshAddress": "t15lauyzdivqj7m3yob3rxmzdsy7uyhfflwyheuri",
+    "freshAddressPath": "44'/1'/0'/0/0",
+    "freshAddresses": Array [
+      Object {
+        "address": "t15lauyzdivqj7m3yob3rxmzdsy7uyhfflwyheuri",
+        "derivationPath": "44'/1'/0'/0/0",
+      },
+    ],
+    "id": "js:2:filecoin:t15lauyzdivqj7m3yob3rxmzdsy7uyhfflwyheuri:gliflegacy",
+    "index": 0,
+    "name": "Filecoin 1",
+    "nfts": undefined,
+    "operationsCount": 0,
+    "pendingOperations": Array [],
+    "seedIdentifier": "04ca7b02cafdf36e8b4caaf530a96b949764af71b956b2a3328b7a10940794c860f574a9199be98bde3c261887fec8e5fd94bc5f104908bf5f992f52ef2a89abb0",
+    "spendableBalance": "1000000000000000",
+    "starred": false,
+    "swapHistory": Array [],
+    "syncHash": undefined,
+    "unitMagnitude": 18,
+    "used": true,
+  },
   Object {
     "balance": "100000000000000000",
     "currencyId": "filecoin",
@@ -59,6 +85,7 @@ Array [
 
 exports[`filecoin currency bridge scanAccounts filecoin seed 1 2`] = `
 Array [
+  Array [],
   Array [
     Object {
       "accountId": "js:2:filecoin:f1p74d4mlmeyc4agflhjqsnvoyzyfdai7fmkyso2a:",

package/src/families/filecoin/bridge.integration.test.ts

@@ -31,9 +31,13 @@ const filecoin: CurrenciesData<Transaction> = {
       => 06010000142c000080cd010080000000800000000000000000
       <= 04ca7b02cafdf36e8b4caaf530a96b949764af71b956b2a3328b7a10940794c860f574a9199be98bde3c261887fec8e5fd94bc5f104908bf5f992f52ef2a89abb015017ff83e316c2605c018ab3a6126d5d8ce0a3023e529663170373464346d6c6d657963346167666c686a71736e766f797a796664616937666d6b79736f32619000
       => 0600000000
-      <= 0000160200330000049000
+      <= 0000160500311000049000
       => 06010000142c00008001000080000000800000000000000000
-      <= 04433296b4adc4c68ae79f6ed6ff1b09875c932d993a20dd068b07346c2dcefe42a791287afae0932dea2ded54982e9a4ca38e614a60f320c68ddb554949953094150111b66c4555016c4ea8677f4d71c954a869790d1a2974316367336779726b7661667765356b64687035677864736b757662757873646932686e7377646d699000
+      <= 04d493dab3ff63d6f0673454f8f6d6adec08db19e8c0298c65cfcace76a10757774afdee518b15a8b82452531bcb7860eefce02a89ef9051037646f5d4d6bd74171501eac14c6468ac13f66f0e0ee3766472c7e98394ab297431356c6175797a646976716a376d33796f623372786d7a6473793775796866666c777968657572699000
+      => 0600000000
+      <= 0000160500311000049000
+      => 06010000142c00008001000080000000800000000001000000
+      <= 040cbb57791d797268e34340565393f8a014ae754026159973fbe46bdcef3b6d28d155f4923256a2beb9bcff3bd39e5066d1c778306f28a2d4faa3a66dbf70453e150148c9b66fef1fce116652099bec6301ced31e56472974316a6465336d33377064376862637a737362676e36797979627a336a7234767368676370696b32619000
       => 0600000000
       <= 0000160500311000049000
       => 06010000142c000080cd010080000000800000000001000000

package/src/families/filecoin/hw-signMessage.ts

@@ -1,10 +1,10 @@
 import Fil from "@zondax/ledger-filecoin";
 import { log } from "@ledgerhq/logs";
 
-import type { Resolver, Result } from "../../hw/signMessage/types";
+import type { SignMessage, Result } from "../../hw/signMessage/types";
 import { getBufferFromString, getPath, isError } from "./utils";
 
-const resolver: Resolver = async (
+const signMessage: SignMessage = async (
   transport,
   { path, message }
 ): Promise<Result> => {
@@ -27,4 +27,4 @@ const resolver: Resolver = async (
   };
 };
 
-export default resolver;
+export default { signMessage };

package/src/families/osmosis/specs.ts

@@ -192,13 +192,15 @@ const osmosis: AppSpec<Transaction> = {
             (d) => d.validatorAddress === v.address
           );
           invariant(d, "delegated %s must be found in account", v.address);
-          expect({
-            address: v.address,
-            amount: approximateValue(v.amount),
-          }).toMatchObject({
-            address: (d as CosmosDelegation).validatorAddress,
-            amount: approximateValue((d as CosmosDelegation).amount),
-          });
+          botTest("delegator have planned address and amount", () =>
+            expect({
+              address: v.address,
+              amount: approximateValue(v.amount),
+            }).toMatchObject({
+              address: (d as CosmosDelegation).validatorAddress,
+              amount: approximateValue((d as CosmosDelegation).amount),
+            })
+          );
         });
       },
     },
@@ -260,13 +262,15 @@ const osmosis: AppSpec<Transaction> = {
             (d) => d.validatorAddress === v.address
           );
           invariant(d, "undelegated %s must be found in account", v.address);
-          expect({
-            address: v.address,
-            amount: approximateValue(v.amount),
-          }).toMatchObject({
-            address: (d as CosmosUnbonding).validatorAddress,
-            amount: approximateValue((d as CosmosUnbonding).amount),
-          });
+          botTest("validator have planned address and amount", () =>
+            expect({
+              address: v.address,
+              amount: approximateValue(v.amount),
+            }).toMatchObject({
+              address: (d as CosmosUnbonding).validatorAddress,
+              amount: approximateValue((d as CosmosUnbonding).amount),
+            })
+          );
         });
       },
     },
@@ -338,13 +342,15 @@ const osmosis: AppSpec<Transaction> = {
                   d.validatorSrcAddress === transaction.sourceValidator
               );
             invariant(d, "redelegated %s must be found in account", v.address);
-            expect({
-              address: v.address,
-              amount: approximateValue(v.amount),
-            }).toMatchObject({
-              address: (d as CosmosRedelegation).validatorDstAddress,
-              amount: approximateValue((d as CosmosRedelegation).amount),
-            });
+            botTest("validator have planned address and amount", () =>
+              expect({
+                address: v.address,
+                amount: approximateValue(v.amount),
+              }).toMatchObject({
+                address: (d as CosmosRedelegation).validatorDstAddress,
+                amount: approximateValue((d as CosmosRedelegation).amount),
+              })
+            );
           }
         });
       },
@@ -385,10 +391,14 @@ const osmosis: AppSpec<Transaction> = {
           const d = (cosmosResources as CosmosResources).delegations.find(
             (d) => d.validatorAddress === v.address
           );
-          invariant(d, "delegation %s must be found in account", v.address);
-          invariant(
-            !canClaimRewards(account as CosmosAccount, d as CosmosDelegation),
-            "reward no longer be claimable"
+          botTest("delegation exists in account", () =>
+            invariant(d, "delegation %s must be found in account", v.address)
+          );
+          botTest("reward is no longer claimable after claim", () =>
+            invariant(
+              !canClaimRewards(account as CosmosAccount, d as CosmosDelegation),
+              "reward no longer be claimable"
+            )
           );
         });
       },

package/src/families/tron/specs.ts

@@ -90,7 +90,7 @@ const tron: AppSpec<Transaction> = {
       },
       test: ({ account }) => {
         botTest("account spendable balance is zero", () =>
-          expect(account.spendableBalance.toString()).toBe("0")
+          expectedApproximate(account.spendableBalance, new BigNumber(0))
         );
       },
     },

package/src/featureFlags/defaultFeatures.ts

@@ -50,9 +50,6 @@ export const defaultFeatures: DefaultFeatures = {
   currencyFlareMobile: {
     enabled: false,
   },
-  currency: {
-    enabled: false,
-  },
   ratings: {
     enabled: false,
     params: {
@@ -103,4 +100,13 @@ export const defaultFeatures: DefaultFeatures = {
   counterValue: {
     enabled: false,
   },
+  llmUsbFirmwareUpdate: {
+    enabled: false,
+  },
+  ptxSmartRouting: {
+    enabled: false,
+  },
+  ptxSmartRoutingMobile: {
+    enabled: 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 {
@@ -149,6 +150,7 @@ export const isAllowedOnboardingStatePollingError = (error: Error): boolean => {
     (error instanceof TimeoutError ||
       error instanceof DisconnectedDevice ||
       error instanceof CantOpenDevice ||
+      error instanceof TransportRaceCondition ||
       error instanceof TransportStatusError)
   ) {
     return true;

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/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",