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

package/src/postOnboarding/hooks/usePostOnboardingHubState.test.ts

@@ -0,0 +1,184 @@
+import { useFeatureFlags } from "../../featureFlags";
+import { hubStateSelector } from "../reducer";
+import { usePostOnboardingContext } from "./usePostOnboardingContext";
+import { getPostOnboardingAction, mockedFeatureIdToTest } from "../mock";
+import { renderHook } from "@testing-library/react-hooks";
+import { DeviceModelId } from "@ledgerhq/types-devices";
+import { PostOnboardingActionId } from "@ledgerhq/types-live";
+import { usePostOnboardingHubState } from "./usePostOnboardingHubState";
+
+jest.mock("react-redux", () => ({
+  useSelector: (val) => val(),
+}));
+jest.mock("../../featureFlags");
+jest.mock("./usePostOnboardingContext");
+jest.mock("../reducer");
+
+const mockedUseFeatureFlags = jest.mocked(useFeatureFlags);
+const mockedGetFeatureWithMockFeatureEnabled = (enabled) => ({
+  getFeature: (id) => {
+    if (id === mockedFeatureIdToTest) return { enabled };
+    return { enabled: true };
+  },
+  overrideFeature: () => {},
+  resetFeature: () => {},
+});
+
+const mockedUsePostOnboardingContext = jest.mocked(usePostOnboardingContext);
+
+const mockedHubStateSelector = jest.mocked(hubStateSelector);
+
+const defaultHubState = {
+  deviceModelId: DeviceModelId.nanoX,
+  actionsToComplete: [],
+  actionsCompleted: {},
+  lastActionCompleted: null,
+};
+
+const stateAllCompleted = {
+  deviceModelId: DeviceModelId.nanoX,
+  actionsToComplete: [
+    PostOnboardingActionId.claimMock,
+    PostOnboardingActionId.personalizeMock,
+    PostOnboardingActionId.migrateAssetsMock,
+  ],
+  actionsCompleted: {
+    [PostOnboardingActionId.claimMock]: true,
+    [PostOnboardingActionId.personalizeMock]: true,
+    [PostOnboardingActionId.migrateAssetsMock]: true,
+  },
+  lastActionCompleted: PostOnboardingActionId.personalizeMock,
+};
+
+const stateAllNotCompleted = {
+  deviceModelId: DeviceModelId.nanoX,
+  actionsToComplete: [
+    PostOnboardingActionId.claimMock,
+    PostOnboardingActionId.personalizeMock,
+    PostOnboardingActionId.migrateAssetsMock,
+  ],
+  actionsCompleted: {
+    [PostOnboardingActionId.claimMock]: false,
+    [PostOnboardingActionId.personalizeMock]: false,
+    [PostOnboardingActionId.migrateAssetsMock]: false,
+  },
+  lastActionCompleted: null,
+};
+
+describe("usePostOnboardingHubState", () => {
+  beforeEach(() => {
+    mockedUseFeatureFlags.mockReturnValue(
+      mockedGetFeatureWithMockFeatureEnabled(true)
+    );
+    mockedUsePostOnboardingContext.mockReturnValue({
+      getPostOnboardingActionsForDevice: () => [],
+      navigateToPostOnboardingHub: () => {},
+      getPostOnboardingAction,
+    });
+  });
+
+  it("should return an empty state if the context isn't properly set (`getPostOnboardingAction` missing)", () => {
+    const state = stateAllCompleted;
+    mockedHubStateSelector.mockReturnValue(state);
+    mockedUsePostOnboardingContext.mockReturnValue({
+      getPostOnboardingActionsForDevice: () => [],
+      navigateToPostOnboardingHub: () => {},
+      getPostOnboardingAction: undefined,
+    });
+
+    const { result } = renderHook(() => usePostOnboardingHubState());
+
+    expect(result.current).toEqual({
+      deviceModelId: state.deviceModelId,
+      lastActionCompleted: null,
+      actionsState: [],
+    });
+  });
+
+  it("should return an empty state if the store is in an empty state", () => {
+    const state = defaultHubState;
+    mockedHubStateSelector.mockReturnValue(state);
+
+    const { result } = renderHook(() => usePostOnboardingHubState());
+
+    expect(result.current).toEqual({
+      deviceModelId: state.deviceModelId,
+      lastActionCompleted: null,
+      actionsState: [],
+    });
+  });
+
+  it("should not return actions that have a disabled feature flag ", () => {
+    const state = stateAllCompleted;
+    mockedHubStateSelector.mockReturnValue(state);
+    mockedUseFeatureFlags.mockReturnValue(
+      mockedGetFeatureWithMockFeatureEnabled(false)
+    );
+
+    const {
+      result: {
+        current: { actionsState, lastActionCompleted },
+      },
+    } = renderHook(() => usePostOnboardingHubState());
+
+    expect(
+      actionsState.find(
+        (action) => action.featureFlagId === mockedFeatureIdToTest
+      )
+    ).toBe(undefined);
+    expect(lastActionCompleted).toBe(null);
+  });
+
+  it("should return actions that have a feature flag enabled", () => {
+    const state = stateAllCompleted;
+    mockedHubStateSelector.mockReturnValue(state);
+    mockedUseFeatureFlags.mockReturnValue(
+      mockedGetFeatureWithMockFeatureEnabled(true)
+    );
+
+    const {
+      result: {
+        current: { actionsState, lastActionCompleted },
+      },
+    } = renderHook(() => usePostOnboardingHubState());
+
+    expect(
+      actionsState.find(
+        (action) => action.featureFlagId === mockedFeatureIdToTest
+      )
+    ).toBeTruthy();
+    expect(lastActionCompleted).toBeTruthy();
+  });
+
+  it("should return actions in their correct state (all actions completed)", () => {
+    const state = stateAllCompleted;
+    mockedHubStateSelector.mockReturnValue(state);
+    mockedUseFeatureFlags.mockReturnValue(
+      mockedGetFeatureWithMockFeatureEnabled(true)
+    );
+
+    const {
+      result: {
+        current: { actionsState },
+      },
+    } = renderHook(() => usePostOnboardingHubState());
+
+    expect(actionsState.every((action) => action.completed)).toBe(true);
+  });
+
+  it("should return actions in their correct state (no actions completed)", () => {
+    const state = stateAllNotCompleted;
+    mockedHubStateSelector.mockReturnValue(state);
+    mockedUseFeatureFlags.mockReturnValue(
+      mockedGetFeatureWithMockFeatureEnabled(true)
+    );
+
+    const {
+      result: {
+        current: { actionsState },
+      },
+    } = renderHook(() => usePostOnboardingHubState());
+
+    expect(actionsState.every((action) => action.completed)).toBe(false);
+  });
+});

package/src/postOnboarding/hooks/usePostOnboardingHubState.ts

@@ -0,0 +1,56 @@
+import { useSelector } from "react-redux";
+import { useMemo } from "react";
+import { PostOnboardingHubState } from "@ledgerhq/types-live";
+import { useFeatureFlags } from "../../featureFlags";
+import { hubStateSelector } from "../reducer";
+import { usePostOnboardingContext } from "./usePostOnboardingContext";
+
+/**
+ * @returns an object representing the state that should be rendered on the post
+ * onboarding hub screen.
+ *
+ * This takes feature flagging into account so the logic is
+ * resistant to flags getting enabled/disabled over time (for a given disabled
+ * feature flag, the actions pointing to it will be excluded).
+ * TODO: unit test this
+ * */
+export function usePostOnboardingHubState(): PostOnboardingHubState {
+  const hubState = useSelector(hubStateSelector);
+  const postOnboardingContext = usePostOnboardingContext();
+  const { getPostOnboardingAction } = postOnboardingContext;
+  const { getFeature } = useFeatureFlags();
+  return useMemo(() => {
+    if (!getPostOnboardingAction)
+      return {
+        deviceModelId: hubState.deviceModelId,
+        lastActionCompleted: null,
+        actionsState: [],
+      };
+    const actionsState = hubState.actionsToComplete
+      .map((actionId) => ({
+        ...getPostOnboardingAction(actionId),
+        completed: !!hubState.actionsCompleted[actionId],
+      }))
+      .filter(
+        (actionWithState) =>
+          !actionWithState.featureFlagId ||
+          getFeature(actionWithState.featureFlagId)?.enabled
+      );
+    const lastActionCompleted = hubState.lastActionCompleted
+      ? getPostOnboardingAction(hubState.lastActionCompleted)
+      : null;
+
+    const isLastActionCompletedEnabled =
+      lastActionCompleted &&
+      (!lastActionCompleted.featureFlagId ||
+        getFeature(lastActionCompleted.featureFlagId)?.enabled);
+
+    return {
+      deviceModelId: hubState.deviceModelId,
+      lastActionCompleted: isLastActionCompletedEnabled
+        ? lastActionCompleted
+        : null,
+      actionsState,
+    };
+  }, [getFeature, hubState, getPostOnboardingAction]);
+}

package/src/postOnboarding/hooks/useStartPostOnboardingCallback.ts

@@ -0,0 +1,38 @@
+import { useDispatch } from "react-redux";
+import { DeviceModelId } from "@ledgerhq/types-devices";
+import { usePostOnboardingContext } from "./usePostOnboardingContext";
+import { useCallback, useMemo } from "react";
+import { initPostOnboarding } from "../actions";
+
+/**
+ * Use this to initialize AND navigate to the post onboarding hub for a given
+ * device model.
+ *
+ * @param deviceModelId
+ * @returns a function that can be called to initialize the post
+ * onboarding for the given device model and navigate to the post onboarding
+ * hub.
+ * TODO: unit test this
+ */
+export function useStartPostOnboardingCallback(
+  deviceModelId: DeviceModelId,
+  mock = false
+): () => void {
+  const dispatch = useDispatch();
+  const { getPostOnboardingActionsForDevice, navigateToPostOnboardingHub } =
+    usePostOnboardingContext();
+  const actions = useMemo(
+    () => getPostOnboardingActionsForDevice(deviceModelId, mock),
+    [deviceModelId, mock, getPostOnboardingActionsForDevice]
+  );
+  return useCallback(() => {
+    dispatch(
+      initPostOnboarding({
+        deviceModelId,
+        actionsIds: actions.map((action) => action.id),
+      })
+    );
+    if (actions.length === 0) return;
+    navigateToPostOnboardingHub();
+  }, [actions, deviceModelId, dispatch, navigateToPostOnboardingHub]);
+}

package/src/postOnboarding/mock.ts

@@ -0,0 +1,53 @@
+/** mocks for unit tests */
+
+import {
+  FeatureId,
+  PostOnboardingAction,
+  PostOnboardingActionId,
+} from "@ledgerhq/types-live";
+
+const MockIcon = (): null => null;
+
+export const mockedFeatureIdToTest: FeatureId = "mockFeature";
+
+export const claimTestMock: PostOnboardingAction = {
+  id: PostOnboardingActionId.claimMock,
+  Icon: MockIcon,
+  title: "Claim my NFT",
+  description: "A special NFT for you.",
+  tagLabel: "Free",
+  actionCompletedPopupLabel: "NFT claimed",
+  actionCompletedHubTitle: "Kickstart your Web3 journey.",
+  navigationParams: [],
+};
+
+export const personalizeTestMock: PostOnboardingAction = {
+  id: PostOnboardingActionId.personalizeMock,
+  Icon: MockIcon,
+  featureFlagId: mockedFeatureIdToTest,
+  title: `Personalize my device`,
+  description: "By customizing the screen.",
+  actionCompletedPopupLabel: "Device personalized",
+  actionCompletedHubTitle: "That screen is looking neat.",
+  navigationParams: [],
+};
+
+export const migrateAssetsTestMock: PostOnboardingAction = {
+  id: PostOnboardingActionId.migrateAssetsMock,
+  Icon: MockIcon,
+  title: "Transfer assets to my Ledger",
+  description: "Easily secure assets from coinbase or another exchange.",
+  actionCompletedPopupLabel: "Assets transfered",
+  actionCompletedHubTitle: "Something about being a crypto pro.",
+  navigationParams: [],
+};
+
+export function getPostOnboardingAction(
+  id: PostOnboardingActionId
+): PostOnboardingAction {
+  return {
+    [PostOnboardingActionId.claimMock]: claimTestMock,
+    [PostOnboardingActionId.personalizeMock]: personalizeTestMock,
+    [PostOnboardingActionId.migrateAssetsMock]: migrateAssetsTestMock,
+  }[id];
+}

package/src/postOnboarding/reducer.test.ts

@@ -0,0 +1,247 @@
+import { DeviceModelId } from "@ledgerhq/types-devices";
+import {
+  PostOnboardingActionId,
+  PostOnboardingState,
+} from "@ledgerhq/types-live";
+import reducer, { initialState } from "./reducer";
+
+import {
+  importPostOnboardingState,
+  initPostOnboarding,
+  setPostOnboardingActionCompleted,
+  clearPostOnboardingLastActionCompleted,
+  hidePostOnboardingWalletEntryPoint,
+} from "./actions";
+
+const initializationParamsA: Parameters<typeof initPostOnboarding> = [
+  {
+    deviceModelId: DeviceModelId.nanoX,
+    actionsIds: [
+      PostOnboardingActionId.claimMock,
+      PostOnboardingActionId.migrateAssetsMock,
+      PostOnboardingActionId.personalizeMock,
+    ],
+  },
+];
+
+// initialState -> importPostOnboardingState(...initializationParamsA)
+const stateA0: PostOnboardingState = {
+  deviceModelId: DeviceModelId.nanoX,
+  walletEntryPointDismissed: false,
+  actionsToComplete: [
+    PostOnboardingActionId.claimMock,
+    PostOnboardingActionId.migrateAssetsMock,
+    PostOnboardingActionId.personalizeMock,
+  ],
+  actionsCompleted: {
+    [PostOnboardingActionId.claimMock]: false,
+    [PostOnboardingActionId.migrateAssetsMock]: false,
+    [PostOnboardingActionId.personalizeMock]: false,
+  },
+  lastActionCompleted: null,
+};
+
+// stateA0 -> setPostOnboardingActionCompleted(claimMock)
+const stateA1: PostOnboardingState = {
+  deviceModelId: DeviceModelId.nanoX,
+  walletEntryPointDismissed: false,
+  actionsToComplete: [
+    PostOnboardingActionId.claimMock,
+    PostOnboardingActionId.migrateAssetsMock,
+    PostOnboardingActionId.personalizeMock,
+  ],
+  actionsCompleted: {
+    [PostOnboardingActionId.claimMock]: true, // stateA0 -> setPostOnboardingActionCompleted(claimMock)
+    [PostOnboardingActionId.migrateAssetsMock]: false,
+    [PostOnboardingActionId.personalizeMock]: false,
+  },
+  lastActionCompleted: PostOnboardingActionId.claimMock, // stateA0 -> setPostOnboardingActionCompleted(claimMock)
+};
+
+// stateA1 -> clearPostOnboardingLastActionCompleted()
+const stateA2: PostOnboardingState = {
+  deviceModelId: DeviceModelId.nanoX,
+  walletEntryPointDismissed: false,
+  actionsToComplete: [
+    PostOnboardingActionId.claimMock,
+    PostOnboardingActionId.migrateAssetsMock,
+    PostOnboardingActionId.personalizeMock,
+  ],
+  actionsCompleted: {
+    [PostOnboardingActionId.claimMock]: true,
+    [PostOnboardingActionId.migrateAssetsMock]: false,
+    [PostOnboardingActionId.personalizeMock]: false,
+  },
+  lastActionCompleted: null, // stateA1 -> clearPostOnboardingLastActionCompleted()
+};
+
+// stateA2 -> setPostOnboardingActionCompleted(personalizeMock)
+const stateA3: PostOnboardingState = {
+  deviceModelId: DeviceModelId.nanoX,
+  walletEntryPointDismissed: false,
+  actionsToComplete: [
+    PostOnboardingActionId.claimMock,
+    PostOnboardingActionId.migrateAssetsMock,
+    PostOnboardingActionId.personalizeMock,
+  ],
+  actionsCompleted: {
+    [PostOnboardingActionId.claimMock]: true,
+    [PostOnboardingActionId.migrateAssetsMock]: false,
+    [PostOnboardingActionId.personalizeMock]: true, // stateA2 -> setPostOnboardingActionCompleted(personalizeMock)
+  },
+  lastActionCompleted: PostOnboardingActionId.personalizeMock, // stateA2 -> setPostOnboardingActionCompleted(personalizeMock)
+};
+
+// stateA3 -> hidePostOnboardingWalletEntryPoint()
+const stateA4: PostOnboardingState = {
+  deviceModelId: DeviceModelId.nanoX,
+  walletEntryPointDismissed: true, // stateA3 -> hidePostOnboardingWalletEntryPoint()
+  actionsToComplete: [
+    PostOnboardingActionId.claimMock,
+    PostOnboardingActionId.migrateAssetsMock,
+    PostOnboardingActionId.personalizeMock,
+  ],
+  actionsCompleted: {
+    [PostOnboardingActionId.claimMock]: true,
+    [PostOnboardingActionId.migrateAssetsMock]: false,
+    [PostOnboardingActionId.personalizeMock]: true,
+  },
+  lastActionCompleted: PostOnboardingActionId.personalizeMock,
+};
+
+const initializationParamsB: Parameters<typeof initPostOnboarding> = [
+  {
+    deviceModelId: DeviceModelId.nanoS,
+    actionsIds: [PostOnboardingActionId.claimMock],
+  },
+];
+
+// initialState -> importPostOnboardingState(...initializationParamsB)
+const stateB0 = {
+  deviceModelId: DeviceModelId.nanoS,
+  walletEntryPointDismissed: false,
+  actionsToComplete: [PostOnboardingActionId.claimMock],
+  actionsCompleted: { [PostOnboardingActionId.claimMock]: false },
+  lastActionCompleted: null,
+};
+
+// stateB0 -> setPostOnboardingActionCompleted(claimMock)
+const stateB1 = {
+  deviceModelId: DeviceModelId.nanoS,
+  walletEntryPointDismissed: false,
+  actionsToComplete: [PostOnboardingActionId.claimMock],
+  actionsCompleted: { [PostOnboardingActionId.claimMock]: true },
+  lastActionCompleted: PostOnboardingActionId.claimMock,
+};
+
+const initializationParamsC: Parameters<typeof initPostOnboarding> = [
+  {
+    deviceModelId: DeviceModelId.nanoSP,
+    actionsIds: [],
+  },
+];
+
+// initialState -> importPostOnboardingState(...initializationParamsC)
+const stateC0 = {
+  deviceModelId: DeviceModelId.nanoSP,
+  walletEntryPointDismissed: false,
+  actionsToComplete: [],
+  actionsCompleted: {},
+  lastActionCompleted: null,
+};
+
+describe("postOnboarding reducer (& action creators)", () => {
+  let state;
+  beforeEach(() => {
+    // reset state to initial state;
+    state = reducer(undefined, {});
+  });
+
+  it("should initialize the state properly", () => {
+    expect(state).toEqual(initialState);
+  });
+
+  it("should handle importPostOnboardingState", () => {
+    state = reducer(state, importPostOnboardingState({ newState: stateA0 }));
+    expect(state).toEqual(stateA0);
+    state = reducer(state, importPostOnboardingState({ newState: stateA1 }));
+    expect(state).toEqual(stateA1);
+  });
+
+  it("it should handle initPostOnboarding", () => {
+    state = reducer(state, initPostOnboarding(...initializationParamsA));
+    expect(state).toEqual(stateA0);
+  });
+
+  it("it should handle setPostOnboardingActionCompleted", () => {
+    state = stateA0;
+    state = reducer(
+      state,
+      setPostOnboardingActionCompleted({
+        actionId: PostOnboardingActionId.claimMock,
+      })
+    );
+    expect(state).toEqual(stateA1);
+  });
+
+  it("it should handle clearPostOnboardingLastActionCompleted", () => {
+    state = stateA1;
+    state = reducer(state, clearPostOnboardingLastActionCompleted());
+    expect(state).toEqual(stateA2);
+  });
+
+  it("it should handle hidePostOnboardingWalletEntryPoint", () => {
+    state = stateA3;
+    state = reducer(state, hidePostOnboardingWalletEntryPoint());
+    expect(state).toEqual(stateA4);
+  });
+
+  it("it should handle successive actions properly", () => {
+    // initializing state with new device & set of actions
+    state = reducer(state, initPostOnboarding(...initializationParamsA));
+    expect(state).toEqual(stateA0);
+
+    // setting completed for claimMock
+    state = reducer(
+      state,
+      setPostOnboardingActionCompleted({
+        actionId: PostOnboardingActionId.claimMock,
+      })
+    );
+    expect(state).toEqual(stateA1);
+
+    // clearing last completed action
+    state = reducer(state, clearPostOnboardingLastActionCompleted());
+    expect(state).toEqual(stateA2);
+
+    // setting completed for personalizeMock
+    state = reducer(
+      state,
+      setPostOnboardingActionCompleted({
+        actionId: PostOnboardingActionId.personalizeMock,
+      })
+    );
+    expect(state).toEqual(stateA3);
+
+    // hiding wallet entrypoint
+    state = reducer(state, hidePostOnboardingWalletEntryPoint());
+    expect(state).toEqual(stateA4);
+
+    // initializing state with new device & set of actions
+    state = reducer(state, initPostOnboarding(...initializationParamsB));
+    expect(state).toEqual(stateB0);
+
+    // setting completed for claimMock
+    state = reducer(
+      state,
+      setPostOnboardingActionCompleted({
+        actionId: PostOnboardingActionId.claimMock,
+      })
+    );
+    expect(state).toEqual(stateB1);
+
+    // initializing state with new device & set of actions
+    state = reducer(state, initPostOnboarding(...initializationParamsC));
+    expect(state).toEqual(stateC0);
+  });
+});

package/src/postOnboarding/reducer.ts

@@ -0,0 +1,105 @@
+import { DeviceModelId } from "@ledgerhq/types-devices";
+import {
+  PostOnboardingActionId,
+  PostOnboardingState,
+} from "@ledgerhq/types-live";
+import { handleActions } from "redux-actions";
+
+export const initialState: PostOnboardingState = {
+  deviceModelId: null,
+  walletEntryPointDismissed: false,
+  actionsToComplete: [],
+  actionsCompleted: {},
+  lastActionCompleted: null,
+};
+
+const handlers: Record<
+  string,
+  (state: PostOnboardingState, action: any) => PostOnboardingState
+> = {
+  POST_ONBOARDING_IMPORT_STATE: (
+    _,
+    action: { newState: Record<string, any> }
+  ): PostOnboardingState => action.newState as PostOnboardingState,
+  POST_ONBOARDING_INIT: (
+    _,
+    action: {
+      deviceModelId: DeviceModelId;
+      actionsIds: PostOnboardingActionId[];
+    }
+  ) => {
+    const { deviceModelId, actionsIds } = action;
+    return {
+      deviceModelId,
+      walletEntryPointDismissed: false,
+      actionsToComplete: actionsIds,
+      actionsCompleted: Object.fromEntries(actionsIds.map((id) => [id, false])),
+      lastActionCompleted: null,
+    };
+  },
+  POST_ONBOARDING_SET_ACTION_COMPLETED: (
+    state,
+    action: { actionId: PostOnboardingActionId }
+  ) => {
+    const { actionId } = action;
+    const actionsCompleted = { ...state.actionsCompleted, [actionId]: true };
+    return {
+      ...state,
+      actionsCompleted,
+      lastActionCompleted: actionId,
+    };
+  },
+  POST_ONBOARDING_CLEAR_LAST_ACTION_COMPLETED: (state) => ({
+    ...state,
+    lastActionCompleted: null,
+  }),
+  POST_ONBOARDING_HIDE_WALLET_ENTRY_POINT: (state) => ({
+    ...state,
+    walletEntryPointDismissed: true,
+  }),
+};
+
+export default handleActions(handlers, initialState);
+
+export const postOnboardingSelector = ({
+  postOnboarding,
+}: {
+  postOnboarding: PostOnboardingState;
+}): PostOnboardingState => postOnboarding;
+
+export const hubStateSelector = ({
+  postOnboarding,
+}: {
+  postOnboarding: PostOnboardingState;
+}): {
+  deviceModelId: PostOnboardingState["deviceModelId"];
+  actionsToComplete: PostOnboardingState["actionsToComplete"];
+  actionsCompleted: PostOnboardingState["actionsCompleted"];
+  lastActionCompleted: PostOnboardingState["lastActionCompleted"];
+} => {
+  const {
+    deviceModelId,
+    actionsToComplete,
+    actionsCompleted,
+    lastActionCompleted,
+  } = postOnboarding;
+  return {
+    deviceModelId,
+    actionsToComplete,
+    actionsCompleted,
+    lastActionCompleted,
+  };
+};
+
+export const postOnboardingDeviceModelIdSelector = ({
+  postOnboarding,
+}: {
+  postOnboarding: PostOnboardingState;
+}): PostOnboardingState["deviceModelId"] => postOnboarding.deviceModelId;
+
+export const walletPostOnboardingEntryPointDismissedSelector = ({
+  postOnboarding,
+}: {
+  postOnboarding: PostOnboardingState;
+}): PostOnboardingState["walletEntryPointDismissed"] =>
+  postOnboarding.walletEntryPointDismissed;