@ledgerhq/live-common 31.0.0 → 31.1.0

package/src/deviceSDK/hooks/useToggleOnboardingEarlyChecks.test.ts

@@ -0,0 +1,125 @@
+import { renderHook, act } from "@testing-library/react-hooks";
+import {
+  UseToggleOnboardingEarlyCheckArgs,
+  useToggleOnboardingEarlyCheck,
+} from "./useToggleOnboardingEarlyChecks";
+import { of } from "rxjs";
+import { delay } from "rxjs/operators";
+
+jest.useFakeTimers();
+
+const mockedToggleOnboardingEarlyCheckAction = jest.fn();
+
+describe("useToggleOnboardingEarlyCheck", () => {
+  beforeEach(() => {
+    mockedToggleOnboardingEarlyCheckAction.mockClear();
+  });
+
+  it("should return a success state when the toggle action is successful", async () => {
+    mockedToggleOnboardingEarlyCheckAction.mockReturnValue(
+      of({ toggleStatus: "success" })
+    );
+    const { result } = renderHook(() =>
+      useToggleOnboardingEarlyCheck({
+        toggleOnboardingEarlyCheckAction:
+          mockedToggleOnboardingEarlyCheckAction,
+        deviceId: "",
+        toggleType: "enter",
+      })
+    );
+
+    await act(async () => {
+      jest.advanceTimersByTime(1);
+    });
+
+    expect(result.current.state).toEqual({
+      toggleStatus: "success",
+    });
+  });
+
+  it("should return a state initialized and reset at null when successively triggering the hook", async () => {
+    const delayMs = 1000;
+    mockedToggleOnboardingEarlyCheckAction.mockReturnValue(
+      of({ toggleStatus: "success" }).pipe(delay(delayMs))
+    );
+
+    // Step 1: enter
+    let toggleType: UseToggleOnboardingEarlyCheckArgs["toggleType"] = "enter";
+
+    const { result, rerender } = renderHook(() =>
+      useToggleOnboardingEarlyCheck({
+        toggleOnboardingEarlyCheckAction:
+          mockedToggleOnboardingEarlyCheckAction,
+        deviceId: "",
+        toggleType,
+      })
+    );
+
+    // No response for now from the action -> reset to `none` value
+    expect(result.current.state).toEqual(
+      expect.objectContaining({
+        toggleStatus: "none",
+      })
+    );
+
+    await act(async () => {
+      jest.advanceTimersByTime(delayMs);
+    });
+
+    expect(result.current.state).toEqual({
+      toggleStatus: "success",
+    });
+
+    // Step 2: exit
+    toggleType = "exit";
+    rerender();
+
+    // No response for now from the action -> reset to `none` value
+    expect(result.current.state).toEqual(
+      expect.objectContaining({
+        toggleStatus: "none",
+      })
+    );
+
+    await act(async () => {
+      jest.advanceTimersByTime(delayMs);
+    });
+
+    expect(result.current.state).toEqual({
+      toggleStatus: "success",
+    });
+
+    // Step 3: consumer reset manually with a `null` value
+    toggleType = null;
+    rerender();
+
+    await act(async () => {
+      jest.advanceTimersByTime(1);
+    });
+
+    expect(result.current.state).toEqual(
+      expect.objectContaining({
+        toggleStatus: "none",
+      })
+    );
+
+    // Step 4: again an enter
+    toggleType = "enter";
+    rerender();
+
+    // No response for now from the action -> reset to `none` value
+    expect(result.current.state).toEqual(
+      expect.objectContaining({
+        toggleStatus: "none",
+      })
+    );
+
+    await act(async () => {
+      jest.advanceTimersByTime(delayMs);
+    });
+
+    expect(result.current.state).toEqual({
+      toggleStatus: "success",
+    });
+  });
+});

package/src/deviceSDK/hooks/useToggleOnboardingEarlyChecks.ts

@@ -0,0 +1,71 @@
+import { useEffect, useState } from "react";
+import { log } from "@ledgerhq/logs";
+import {
+  ToggleOnboardingEarlyCheckActionArgs,
+  ToggleOnboardingEarlyCheckActionState,
+  toggleOnboardingEarlyCheckAction as defaultToggleOnboardingEarlyCheckAction,
+  initialState,
+} from "../actions/toggleOnboardingEarlyCheck";
+
+export type UseToggleOnboardingEarlyCheckArgs = {
+  toggleOnboardingEarlyCheckAction?: typeof defaultToggleOnboardingEarlyCheckAction;
+  deviceId: string;
+  toggleType: ToggleOnboardingEarlyCheckActionArgs["toggleType"] | null;
+};
+
+/**
+ * Hook making the device enter or exit the early security check steps, during the onboarding
+ *
+ * This hook only puts (or moves out) the device to the state/step of the early security check.
+ * It does not starts any "security checks".
+ *
+ * If the device is not in the WELCOME or WELCOME_STEP2 onboarding state, this hook will update
+ * its `toggleStatus` to `failure`.
+ *
+ * You can reset the result state by updating `toggleType` to null
+ *
+ * @param deviceId The id of the targeted device that can be
+ * @param toggleType either null, "enter" or "exit".
+ *  If null, the hook does not subscribe to the underlying device action, and nothing happens.
+ *  Useful to enable/disable this hook.
+ * @param toggleOnboardingEarlyCheckAction dependency injected action. A default implementation is provided.
+ * @returns an object containing the state of the onboarding early check toggling with possible error.
+ *   The resulting state is reset to its initial state on each new triggering of the toggle action (when `toggleType` is updated):
+ * {
+ *   toggleStatus: "none",
+ *   ...initialSharedActionState,
+ * }
+ */
+export const useToggleOnboardingEarlyCheck = ({
+  toggleOnboardingEarlyCheckAction = defaultToggleOnboardingEarlyCheckAction,
+  deviceId,
+  toggleType,
+}: UseToggleOnboardingEarlyCheckArgs): {
+  state: ToggleOnboardingEarlyCheckActionState;
+} => {
+  const [state, setState] =
+    useState<ToggleOnboardingEarlyCheckActionState>(initialState);
+
+  useEffect(() => {
+    if (toggleType === null) return;
+
+    const subscription = toggleOnboardingEarlyCheckAction({
+      deviceId,
+      toggleType,
+    }).subscribe({
+      next: setState,
+      error: (error: unknown) => {
+        log("useToggleOnboardingEarlyCheck", "Unknown error", error);
+      },
+    });
+
+    return () => {
+      // Resets the resulting state on each new triggering
+      setState(initialState);
+
+      subscription.unsubscribe();
+    };
+  }, [deviceId, toggleOnboardingEarlyCheckAction, toggleType]);
+
+  return { state };
+};

package/src/deviceSDK/tasks/core.ts

@@ -55,7 +55,7 @@ export function sharedLogicTaskWrapper<TaskArgsType, TaskEventsType>(
                   error instanceof TransportRaceCondition
                 ) {
                   // Emits to the action a locked device error event so it is aware of it before retrying
-                  subscriber.next({ type: "error", error });
+                  subscriber.next({ type: "error" as const, error });
                   acceptedError = true;
                 }
 

package/src/deviceSDK/tasks/toggleOnboardingEarlyCheck.test.ts

@@ -0,0 +1,111 @@
+import { from, of, throwError } from "rxjs";
+import { StatusCodes, TransportStatusError } from "@ledgerhq/errors";
+import { toggleOnboardingEarlyCheckTask } from "./toggleOnboardingEarlyCheck";
+import { toggleOnboardingEarlyCheckCmd } from "../commands/toggleOnboardingEarlyCheck";
+import { withTransport } from "../transports/core";
+import { aTransportRefBuilder } from "../mocks/aTransportRef";
+
+jest.mock("../commands/toggleOnboardingEarlyCheck");
+const mockedToggleOnboardingEarlyCheckCmd = jest.mocked(
+  toggleOnboardingEarlyCheckCmd
+);
+
+jest.mock("../transports/core");
+const mockedWithTransport = jest.mocked(withTransport);
+
+describe("@deviceSDK/tasks/toggleOnboardingEarlyCheckTask", () => {
+  beforeAll(async () => {
+    const transportRef = await aTransportRefBuilder();
+    mockedWithTransport.mockReturnValue((job) => from(job({ transportRef })));
+  });
+
+  describe("When the device is in the expected onboarding state", () => {
+    it("should emit a success event after being able to enter or exit the onboarding early checks step successfully", (done) => {
+      mockedToggleOnboardingEarlyCheckCmd.mockReturnValue(
+        of({ type: "success" })
+      );
+
+      // `enter` and `exit` have the same behavior
+      toggleOnboardingEarlyCheckTask({
+        deviceId: "",
+        toggleType: "exit",
+      }).subscribe({
+        next: (event) => {
+          expect(event.type).toBe("success");
+          done();
+        },
+        error: (error: unknown) => {
+          done(`No error should have been thrown: ${JSON.stringify(error)}`);
+        },
+      });
+    });
+  });
+
+  describe("When the device is neither in the WELCOME and WELCOME_STEP2 onboarding state, and it returns 0x6982", () => {
+    it("should emit a task error event with the correct error type", (done) => {
+      mockedToggleOnboardingEarlyCheckCmd.mockReturnValue(
+        throwError(
+          new TransportStatusError(StatusCodes.SECURITY_STATUS_NOT_SATISFIED)
+        )
+      );
+
+      toggleOnboardingEarlyCheckTask({
+        deviceId: "",
+        toggleType: "enter",
+      }).subscribe({
+        next: (event) => {
+          try {
+            if (event.type === "taskError") {
+              expect(event.error).toBe("DeviceInInvalidState");
+              done();
+            } else {
+              done(`The event is incorrect: ${JSON.stringify(event)}`);
+            }
+          } catch (expectError) {
+            done(expectError);
+          }
+        },
+        error: (error: unknown) => {
+          done(
+            `The error should have been mapped to an event, not thrown: ${JSON.stringify(
+              error
+            )}`
+          );
+        },
+      });
+    });
+  });
+
+  describe("When the command is not respected the expected APDU format", () => {
+    it("should emit a task error event with the correct error type", (done) => {
+      mockedToggleOnboardingEarlyCheckCmd.mockReturnValue(
+        throwError(new TransportStatusError(StatusCodes.INCORRECT_LENGTH))
+      );
+
+      toggleOnboardingEarlyCheckTask({
+        deviceId: "",
+        toggleType: "enter",
+      }).subscribe({
+        next: (event) => {
+          try {
+            if (event.type === "taskError") {
+              expect(event.error).toBe("InternalError");
+              done();
+            } else {
+              done(`The event is incorrect: ${JSON.stringify(event)}`);
+            }
+          } catch (expectError) {
+            done(expectError);
+          }
+        },
+        error: (error: unknown) => {
+          done(
+            `The error should have been mapped to an event, not thrown: ${JSON.stringify(
+              error
+            )}`
+          );
+        },
+      });
+    });
+  });
+});

package/src/deviceSDK/tasks/toggleOnboardingEarlyCheck.ts

@@ -0,0 +1,92 @@
+import { Observable } from "rxjs";
+import { log } from "@ledgerhq/logs";
+import type { DeviceId } from "@ledgerhq/types-live";
+import { SharedTaskEvent } from "./core";
+import { withTransport } from "../transports/core";
+import {
+  toggleOnboardingEarlyCheckCmd,
+  ToggleTypeP2,
+} from "../commands/toggleOnboardingEarlyCheck";
+import { StatusCodes, TransportStatusError } from "@ledgerhq/errors";
+
+export type ToggleOnboardingEarlyCheckTaskError =
+  | "DeviceInInvalidState"
+  | "InternalError"
+  | "Unknown";
+
+export type ToggleOnboardingEarlyCheckTaskErrorEvent = {
+  type: "taskError";
+  error: ToggleOnboardingEarlyCheckTaskError;
+};
+
+export type ToggleOnboardingEarlyCheckTaskEvent =
+  | { type: "success" }
+  | ToggleOnboardingEarlyCheckTaskErrorEvent
+  | SharedTaskEvent;
+
+export type ToggleOnboardingEarlyCheckTaskArgs = {
+  deviceId: DeviceId;
+  toggleType: "enter" | "exit";
+};
+
+/**
+ * During the onboarding, makes the device enter or exit the early security check steps
+ *
+ * This task only puts (or moves out) the device to the state/step of the early security check.
+ * It does not starts any "security checks".
+ *
+ * If the device is not in the WELCOME or WELCOME_STEP2 onboarding state, this task will emit
+ * a "DeviceInInvalidState" event.
+ *
+ * @param deviceId The id of the targeted device
+ * @param toggleType either "enter" or "exit"
+ * @returns An observable that emits a success, error or shared-task event
+ */
+export function toggleOnboardingEarlyCheckTask({
+  deviceId,
+  toggleType,
+}: ToggleOnboardingEarlyCheckTaskArgs): Observable<ToggleOnboardingEarlyCheckTaskEvent> {
+  const p2 =
+    toggleType === "enter"
+      ? ToggleTypeP2.EnterChecking
+      : ToggleTypeP2.ExitChecking;
+
+  return new Observable((subscriber) => {
+    withTransport(deviceId)(({ transportRef }) =>
+      toggleOnboardingEarlyCheckCmd({
+        transport: transportRef.current,
+        p2,
+      })
+    ).subscribe({
+      next: (_) => subscriber.next({ type: "success" }),
+      error: (error: unknown) => {
+        if (error instanceof TransportStatusError) {
+          // @ts-expect-error TransportStatusError not typed correctly
+          if (error.statusCode === StatusCodes.SECURITY_STATUS_NOT_SATISFIED) {
+            subscriber.next({
+              type: "taskError",
+              error: "DeviceInInvalidState",
+            });
+            return;
+          }
+          // @ts-expect-error TransportStatusError not typed correctly
+          else if (error.statusCode === StatusCodes.INCORRECT_LENGTH) {
+            subscriber.next({
+              type: "taskError",
+              error: "InternalError",
+            });
+            return;
+          }
+        }
+        // Otherwise unknown error
+        let message = "";
+        if (error instanceof Error) {
+          message = `${error.name}: ${error.message}`;
+        }
+        log("toggleOnboardingEarlyCheckTask", `Error: ${message}`);
+        subscriber.next({ type: "taskError", error: "Unknown" });
+      },
+      complete: () => subscriber.complete(),
+    });
+  });
+}

package/src/families/bitcoin/descriptor.ts

@@ -2,7 +2,10 @@ import { Observable, from, of, EMPTY } from "rxjs";
 import { concatMap } from "rxjs/operators";
 import invariant from "invariant";
 import bs58 from "bs58";
-import type { DerivationMode } from "@ledgerhq/coin-framework/derivation";
+import type {
+  DerivationMode,
+  GetAddressOptions,
+} from "@ledgerhq/coin-framework/derivation";
 import type { Result } from "../../hw/getAddress/types";
 import { hash256, hash160 } from "../../crypto";
 import {
@@ -159,7 +162,7 @@ export function scanDescriptors(
   currency: CryptoCurrency,
   limit = 10
 ): Observable<AccountDescriptor> {
-  const derivateAddress = (opts) =>
+  const derivateAddress = (opts: GetAddressOptions) =>
     withDevice(deviceId)((transport) => from(getAddress(transport, opts)));
 
   function stepAddress({

package/src/families/bitcoin/satstack.ts

@@ -35,6 +35,7 @@ export type RPCNodeConfig = {
   username: string;
   password: string;
   tls?: boolean;
+  notls?: boolean;
 };
 
 export function isValidHost(host: string): boolean {

package/src/families/bitcoin/walletApiAdapter.test.ts

@@ -1,9 +1,12 @@
 import btc from "./walletApiAdapter";
 import { BitcoinTransaction as WalletAPITransaction } from "@ledgerhq/wallet-api-core";
+import { Account } from "@ledgerhq/types-live";
 import BigNumber from "bignumber.js";
 import { Transaction } from "./types";
 
 describe("getPlatformTransactionSignFlowInfos", () => {
+  const dummyAccount = {} as Account;
+
   describe("should properly get infos for BTC platform tx", () => {
     test("without fees provided", () => {
       const btcPlatformTx: WalletAPITransaction = {
@@ -19,7 +22,10 @@ describe("getPlatformTransactionSignFlowInfos", () => {
       };
 
       const { canEditFees, hasFeesProvided, liveTx } =
-        btc.getWalletAPITransactionSignFlowInfos(btcPlatformTx);
+        btc.getWalletAPITransactionSignFlowInfos({
+          tx: btcPlatformTx,
+          account: dummyAccount,
+        });
 
       expect(canEditFees).toBe(true);
 
@@ -45,7 +51,10 @@ describe("getPlatformTransactionSignFlowInfos", () => {
       };
 
       const { canEditFees, hasFeesProvided, liveTx } =
-        btc.getWalletAPITransactionSignFlowInfos(btcPlatformTx);
+        btc.getWalletAPITransactionSignFlowInfos({
+          tx: btcPlatformTx,
+          account: dummyAccount,
+        });
 
       expect(canEditFees).toBe(true);
 

package/src/families/bitcoin/walletApiAdapter.ts

@@ -14,7 +14,7 @@ const areFeesProvided: AreFeesProvided<WalletAPIBitcoinTransaction> = (tx) =>
 const convertToLiveTransaction: ConvertToLiveTransaction<
   WalletAPIBitcoinTransaction,
   Transaction
-> = (tx) => {
+> = ({ tx }) => {
   const hasFeesProvided = areFeesProvided(tx);
 
   const liveTx: Partial<Transaction> = {
@@ -30,11 +30,11 @@ const convertToLiveTransaction: ConvertToLiveTransaction<
 const getWalletAPITransactionSignFlowInfos: GetWalletAPITransactionSignFlowInfos<
   WalletAPIBitcoinTransaction,
   Transaction
-> = (tx) => {
+> = (params) => {
   return {
     canEditFees: CAN_EDIT_FEES,
-    liveTx: convertToLiveTransaction(tx),
-    hasFeesProvided: areFeesProvided(tx),
+    liveTx: convertToLiveTransaction(params),
+    hasFeesProvided: areFeesProvided(params.tx),
   };
 };