diff --git a/ts/features/payments/checkout/components/WalletPspListSkeleton.tsx b/ts/features/payments/checkout/components/WalletPspListSkeleton.tsx
index 4d94bbbed9b..c9bcd3e3511 100644
--- a/ts/features/payments/checkout/components/WalletPspListSkeleton.tsx
+++ b/ts/features/payments/checkout/components/WalletPspListSkeleton.tsx
@@ -9,13 +9,13 @@ import { View } from "react-native";
 import Placeholder from "rn-placeholder";
 
 export const WalletPspListSkeleton = () => (
-  <>
+  <View testID="wallet-psp-list-skeleton">
     <PspSkeleton showFeatured />
     <Divider />
     <PspSkeleton />
     <Divider />
     <PspSkeleton />
-  </>
+  </View>
 );
 
 type PspSkeletonProps = {
diff --git a/ts/features/payments/checkout/hooks/___tests___/useSortPspBottomSheet.test.tsx b/ts/features/payments/checkout/hooks/___tests___/useSortPspBottomSheet.test.tsx
new file mode 100644
index 00000000000..36c3011cac5
--- /dev/null
+++ b/ts/features/payments/checkout/hooks/___tests___/useSortPspBottomSheet.test.tsx
@@ -0,0 +1,77 @@
+import { fireEvent, render } from "@testing-library/react-native";
+import React from "react";
+import { Button, Text } from "react-native";
+import { WalletPaymentPspSortType } from "../../types";
+import { useSortPspBottomSheet } from "../useSortPspBottomSheet";
+
+// Mock bottom sheet hook
+jest.mock("../../../../../utils/hooks/bottomSheet", () => ({
+  useIOBottomSheetAutoresizableModal: jest.fn().mockReturnValue({
+    isVisible: false,
+    show: jest.fn(),
+    hide: jest.fn()
+  })
+}));
+
+// Test component to render and use the hook
+const ComponentWithPspBottomSheet = ({
+  onSortChange
+}: {
+  onSortChange: (sortType: WalletPaymentPspSortType) => void;
+}) => {
+  const { sortType, dismiss, present } = useSortPspBottomSheet({
+    onSortChange
+  });
+
+  return (
+    <>
+      <Text testID="current-sort-type">{sortType}</Text>
+      <Button title="Show" onPress={present} testID="show-button" />
+      <Button title="Hide" onPress={dismiss} testID="hide-button" />
+      <Button
+        title="Change to Name Sort"
+        onPress={() => onSortChange("name")}
+        testID="change-sort-button"
+      />
+    </>
+  );
+};
+
+describe("useSortPspBottomSheet", () => {
+  it("should initialize sortType to 'default'", () => {
+    const onSortChangeMock = jest.fn();
+    const { getByTestId } = render(
+      <ComponentWithPspBottomSheet onSortChange={onSortChangeMock} />
+    );
+
+    expect(getByTestId("current-sort-type").children[0]).toBe("default");
+  });
+
+  it("should update sortType and call onSortChange when handleChangeSort is called", () => {
+    const onSortChangeMock = jest.fn();
+    const { getByTestId } = render(
+      <ComponentWithPspBottomSheet onSortChange={onSortChangeMock} />
+    );
+
+    // Trigger the sort change
+    fireEvent.press(getByTestId("change-sort-button"));
+    expect(onSortChangeMock).toHaveBeenCalledWith("name");
+  });
+
+  it("should call show and hide methods for the bottom sheet modal", () => {
+    const onSortChangeMock = jest.fn();
+    const { getByTestId } = render(
+      <ComponentWithPspBottomSheet onSortChange={onSortChangeMock} />
+    );
+
+    const showButton = getByTestId("show-button");
+    const hideButton = getByTestId("hide-button");
+
+    // Trigger show and hide methods
+    fireEvent.press(showButton);
+    fireEvent.press(hideButton);
+
+    expect(showButton).toBeTruthy();
+    expect(hideButton).toBeTruthy();
+  });
+});
diff --git a/ts/features/payments/checkout/hooks/useSortPspBottomSheet.tsx b/ts/features/payments/checkout/hooks/useSortPspBottomSheet.tsx
index 4877e4cb77f..7c29e58eeb4 100644
--- a/ts/features/payments/checkout/hooks/useSortPspBottomSheet.tsx
+++ b/ts/features/payments/checkout/hooks/useSortPspBottomSheet.tsx
@@ -33,9 +33,9 @@ const useSortPspBottomSheet = ({
   const [sortType, setSortType] =
     React.useState<WalletPaymentPspSortType>("default");
 
-  const handleChangeSort = (sortType: WalletPaymentPspSortType) => {
-    setSortType(sortType);
-    onSortChange(sortType);
+  const handleChangeSort = (currentSortCriteria: WalletPaymentPspSortType) => {
+    setSortType(currentSortCriteria);
+    onSortChange(currentSortCriteria);
   };
 
   const getModalContent = () => (
diff --git a/ts/features/payments/checkout/screens/WalletPaymentPickPspScreen.tsx b/ts/features/payments/checkout/screens/WalletPaymentPickPspScreen.tsx
index e57dd8b0ba2..e4bfc9f4bbb 100644
--- a/ts/features/payments/checkout/screens/WalletPaymentPickPspScreen.tsx
+++ b/ts/features/payments/checkout/screens/WalletPaymentPickPspScreen.tsx
@@ -189,9 +189,11 @@ const WalletPaymentPickPspScreen = () => {
 
   return (
     <GradientScrollView
+      testID="wallet-payment-pick-psp-screen"
       primaryActionProps={
         canContinue
           ? {
+              testID: "wallet-payment-pick-psp-continue-button",
               label: I18n.t("wallet.payment.psp.continueButton"),
               accessibilityLabel: I18n.t("wallet.payment.psp.continueButton"),
               onPress: handleContinue,
@@ -202,7 +204,9 @@ const WalletPaymentPickPspScreen = () => {
       }
     >
       <SelectPspHeadingContent />
-      {!isLoading && (
+      {isLoading ? (
+        <WalletPspListSkeleton />
+      ) : (
         <RadioGroup<string>
           onPress={handlePspSelection}
           type="radioListItemWithAmount"
@@ -210,7 +214,6 @@ const WalletPaymentPickPspScreen = () => {
           items={getRadioItemsFromPspList(sortedPspList, showFeaturedPsp)}
         />
       )}
-      {isLoading && <WalletPspListSkeleton />}
       {sortPspBottomSheet}
     </GradientScrollView>
   );
diff --git a/ts/features/payments/checkout/screens/___tests___/WalletPaymentPickPspScreen.test.tsx b/ts/features/payments/checkout/screens/___tests___/WalletPaymentPickPspScreen.test.tsx
new file mode 100644
index 00000000000..121c6f3d53e
--- /dev/null
+++ b/ts/features/payments/checkout/screens/___tests___/WalletPaymentPickPspScreen.test.tsx
@@ -0,0 +1,176 @@
+import * as pot from "@pagopa/ts-commons/lib/pot";
+import { fireEvent } from "@testing-library/react-native";
+import * as O from "fp-ts/lib/Option";
+import React from "react";
+import { Store } from "redux";
+import configureMockStore from "redux-mock-store";
+import I18n from "../../../../../i18n";
+import { applicationChangeState } from "../../../../../store/actions/application";
+import { appReducer } from "../../../../../store/reducers";
+import { GlobalState } from "../../../../../store/reducers/types";
+import { renderScreenWithNavigationStoreContext } from "../../../../../utils/testWrapper";
+import { PaymentsCheckoutRoutes } from "../../navigation/routes";
+import { selectPaymentPspAction } from "../../store/actions/orchestration";
+import { PaymentsCheckoutState } from "../../store/reducers";
+import { WalletPaymentStepEnum } from "../../types";
+import { WalletPaymentPickPspScreen } from "../WalletPaymentPickPspScreen";
+
+describe("WalletPaymentPickPspScreen", () => {
+  const mockStore = configureMockStore<GlobalState>();
+
+  const checkout: PaymentsCheckoutState = {
+    currentStep: WalletPaymentStepEnum.PICK_PSP,
+    pspList: pot.someLoading([
+      {
+        id: "test"
+      }
+    ]),
+    paymentDetails: pot.none,
+    userWallets: pot.none,
+    recentUsedPaymentMethod: pot.none,
+    allPaymentMethods: pot.none,
+    selectedWallet: O.none,
+    selectedPaymentMethod: O.none,
+    selectedPsp: O.none,
+    transaction: pot.none,
+    authorizationUrl: pot.none
+  };
+
+  const globalState = appReducer(undefined, applicationChangeState("active"));
+  const state = {
+    ...globalState,
+    features: {
+      ...globalState.features,
+      payments: {
+        ...globalState.features.payments,
+        checkout
+      }
+    }
+  };
+
+  const renderPspScreen = (store: Store<GlobalState>) =>
+    renderScreenWithNavigationStoreContext<GlobalState>(
+      () => <WalletPaymentPickPspScreen />,
+      PaymentsCheckoutRoutes.PAYMENT_CHECKOUT_MAKE,
+      {},
+      store
+    );
+
+  it("should render the screen", () => {
+    const store: ReturnType<typeof mockStore> = mockStore(state);
+    const { getByTestId } = renderPspScreen(store);
+    expect(getByTestId("wallet-payment-pick-psp-screen")).toBeDefined();
+  });
+
+  it("should render with skeleton", () => {
+    const store: ReturnType<typeof mockStore> = mockStore({
+      ...state,
+      features: {
+        ...state.features,
+        payments: {
+          ...state.features.payments,
+          checkout: {
+            ...checkout,
+            pspList: pot.someLoading([])
+          }
+        }
+      }
+    });
+    const { getByTestId } = renderPspScreen(store);
+    expect(getByTestId("wallet-psp-list-skeleton")).toBeDefined();
+  });
+
+  it("should render the screen with the continue button disabled", () => {
+    const store: ReturnType<typeof mockStore> = mockStore(state);
+    const { getByTestId, queryByText } = renderPspScreen(store);
+    expect(getByTestId("wallet-payment-pick-psp-screen")).toBeDefined();
+    expect(queryByText("wallet-payment-pick-psp-continue-button")).toBeNull();
+  });
+
+  it("should render the screen with the continue button enabled", () => {
+    const store: ReturnType<typeof mockStore> = mockStore({
+      ...state,
+      features: {
+        ...state.features,
+        payments: {
+          ...state.features.payments,
+          checkout: {
+            ...checkout,
+            selectedPsp: O.some({
+              id: "test"
+            })
+          }
+        }
+      }
+    });
+    const { getByTestId } = renderPspScreen(store);
+    expect(getByTestId("wallet-payment-pick-psp-screen")).toBeDefined();
+    expect(
+      getByTestId("wallet-payment-pick-psp-continue-button")
+    ).toBeDefined();
+  });
+
+  it("should show bottom sheet", () => {
+    const store: ReturnType<typeof mockStore> = mockStore(state);
+    const { getByText } = renderPspScreen(store);
+    fireEvent.press(getByText(I18n.t("wallet.payment.psp.pspTitle")));
+    expect(
+      getByText(I18n.t("wallet.payment.psp.sortBottomSheet.default"))
+    ).toBeDefined();
+  });
+
+  it("should sort by amount", () => {
+    const store: ReturnType<typeof mockStore> = mockStore(state);
+    const { getByText } = renderPspScreen(store);
+    fireEvent.press(getByText(I18n.t("wallet.payment.psp.pspTitle")));
+    fireEvent.press(
+      getByText(I18n.t("wallet.payment.psp.sortBottomSheet.amount"))
+    );
+    expect(
+      getByText(I18n.t("wallet.payment.psp.sortBottomSheet.amount"))
+    ).toBeDefined();
+  });
+
+  it("should sort by name", () => {
+    const store: ReturnType<typeof mockStore> = mockStore(state);
+    const { getByText } = renderPspScreen(store);
+    fireEvent.press(getByText(I18n.t("wallet.payment.psp.pspTitle")));
+    fireEvent.press(
+      getByText(I18n.t("wallet.payment.psp.sortBottomSheet.name"))
+    );
+    expect(
+      getByText(I18n.t("wallet.payment.psp.sortBottomSheet.name"))
+    ).toBeDefined();
+  });
+
+  it("should select a PSP", () => {
+    const store: ReturnType<typeof mockStore> = mockStore({
+      ...state,
+      features: {
+        ...state.features,
+        payments: {
+          ...state.features.payments,
+          checkout: {
+            ...checkout,
+            pspList: pot.some([
+              {
+                idBundle: "test",
+                pspBusinessName: "Test PSP",
+                taxPayerFee: 100
+              }
+            ])
+          }
+        }
+      }
+    });
+    const { getByText } = renderPspScreen(store);
+    fireEvent.press(getByText("Test PSP"));
+    expect(store.getActions()).toContainEqual(
+      selectPaymentPspAction({
+        idBundle: "test",
+        pspBusinessName: "Test PSP",
+        taxPayerFee: 100
+      })
+    );
+  });
+});
diff --git a/ts/features/payments/checkout/store/__tests__/reducer.test.ts b/ts/features/payments/checkout/store/__tests__/reducer.test.ts
new file mode 100644
index 00000000000..db1e47a861d
--- /dev/null
+++ b/ts/features/payments/checkout/store/__tests__/reducer.test.ts
@@ -0,0 +1,563 @@
+import * as pot from "@pagopa/ts-commons/lib/pot";
+import * as O from "fp-ts/lib/Option";
+import { createStore } from "redux";
+import { AmountEuroCents } from "../../../../../../definitions/pagopa/ecommerce/AmountEuroCents";
+import { PaymentMethodStatusEnum } from "../../../../../../definitions/pagopa/ecommerce/PaymentMethodStatus";
+import { TransactionStatusEnum } from "../../../../../../definitions/pagopa/ecommerce/TransactionStatus";
+import { applicationChangeState } from "../../../../../store/actions/application";
+import { appReducer } from "../../../../../store/reducers";
+import { getTimeoutError } from "../../../../../utils/errors";
+import { WalletPaymentStepEnum } from "../../types";
+import {
+  paymentsCalculatePaymentFeesAction,
+  paymentsCreateTransactionAction,
+  paymentsDeleteTransactionAction,
+  paymentsGetPaymentDetailsAction,
+  paymentsGetPaymentMethodsAction,
+  paymentsGetPaymentTransactionInfoAction,
+  paymentsGetPaymentUserMethodsAction,
+  paymentsGetRecentPaymentMethodUsedAction,
+  paymentsStartPaymentAuthorizationAction
+} from "../actions/networking";
+import {
+  initPaymentStateAction,
+  selectPaymentPspAction,
+  walletPaymentSetCurrentStep
+} from "../actions/orchestration";
+import { PaymentsCheckoutState } from "../reducers";
+import { RptId } from "../../../../../../definitions/pagopa/ecommerce/RptId";
+import { GuestMethodLastUsageTypeEnum } from "../../../../../../definitions/pagopa/ecommerce/GuestMethodLastUsageType";
+
+const INITIAL_STATE: PaymentsCheckoutState = {
+  currentStep: WalletPaymentStepEnum.NONE,
+  paymentDetails: pot.none,
+  userWallets: pot.none,
+  recentUsedPaymentMethod: pot.none,
+  allPaymentMethods: pot.none,
+  pspList: pot.none,
+  selectedWallet: O.none,
+  selectedPaymentMethod: O.none,
+  selectedPsp: O.none,
+  transaction: pot.none,
+  authorizationUrl: pot.none
+};
+
+const networkError = getTimeoutError();
+
+describe("payment checkout reducers", () => {
+  it("should match initial state", () => {
+    const globalState = appReducer(undefined, applicationChangeState("active"));
+    expect(globalState.features.payments.checkout).toStrictEqual(INITIAL_STATE);
+  });
+
+  describe("initPaymentStateAction", () => {
+    it("should handle initPaymentStateAction", () => {
+      const globalState = appReducer(
+        undefined,
+        applicationChangeState("active")
+      );
+      const store = createStore(appReducer, globalState as any);
+      store.dispatch(initPaymentStateAction({ onSuccess: "showHome" }));
+      expect(
+        store.getState().features.payments.checkout.onSuccess
+      ).toStrictEqual("showHome");
+    });
+  });
+
+  describe("walletPaymentSetCurrentStep", () => {
+    it("should handle walletPaymentSetCurrentStep", () => {
+      const globalState = appReducer(
+        undefined,
+        applicationChangeState("active")
+      );
+      const store = createStore(appReducer, globalState as any);
+      store.dispatch(
+        walletPaymentSetCurrentStep(WalletPaymentStepEnum.PICK_PSP)
+      );
+      expect(
+        store.getState().features.payments.checkout.currentStep
+      ).toStrictEqual(WalletPaymentStepEnum.PICK_PSP);
+    });
+  });
+
+  describe("selectPaymentPspAction", () => {
+    it("should handle selectPaymentPspAction", () => {
+      const globalState = appReducer(
+        undefined,
+        applicationChangeState("active")
+      );
+      const store = createStore(appReducer, globalState as any);
+      store.dispatch(
+        walletPaymentSetCurrentStep(WalletPaymentStepEnum.PICK_PSP)
+      );
+      store.dispatch(
+        selectPaymentPspAction({
+          abi: "1",
+          bundleDescription: "desc"
+        })
+      );
+      expect(
+        store.getState().features.payments.checkout.selectedPsp
+      ).toStrictEqual(O.some({ abi: "1", bundleDescription: "desc" }));
+    });
+  });
+
+  describe("paymentsCalculatePaymentFeesAction", () => {
+    it("should handle paymentsCalculatePaymentFeesAction request", () => {
+      const globalState = appReducer(
+        undefined,
+        applicationChangeState("active")
+      );
+      const store = createStore(appReducer, globalState as any);
+      store.dispatch(
+        paymentsCalculatePaymentFeesAction.request({
+          paymentAmount: 100,
+          paymentMethodId: "123"
+        })
+      );
+      expect(store.getState().features.payments.checkout.pspList).toStrictEqual(
+        pot.noneLoading
+      );
+    });
+
+    it("should handle paymentsCalculatePaymentFeesAction success", () => {
+      const globalState = appReducer(
+        undefined,
+        applicationChangeState("active")
+      );
+      const store = createStore(appReducer, globalState as any);
+      store.dispatch(
+        paymentsCalculatePaymentFeesAction.success({
+          asset: "EUR",
+          bundles: [
+            {
+              pspBusinessName: "name",
+              bundleDescription: "desc",
+              bundleName: "name"
+            }
+          ],
+          paymentMethodDescription: "desc",
+          paymentMethodName: "name",
+          paymentMethodStatus: PaymentMethodStatusEnum.ENABLED
+        })
+      );
+      expect(store.getState().features.payments.checkout.pspList).toStrictEqual(
+        pot.some([
+          {
+            pspBusinessName: "name",
+            bundleDescription: "desc",
+            bundleName: "name"
+          }
+        ])
+      );
+    });
+
+    it("should handle paymentsCalculatePaymentFeesAction failure", () => {
+      const globalState = appReducer(
+        undefined,
+        applicationChangeState("active")
+      );
+      const store = createStore(appReducer, globalState as any);
+      store.dispatch(paymentsCalculatePaymentFeesAction.failure(networkError));
+      expect(store.getState().features.payments.checkout.pspList).toStrictEqual(
+        pot.noneError(networkError)
+      );
+    });
+  });
+
+  describe("paymentsCreateTransactionAction", () => {
+    it("should handle paymentsCreateTransactionAction request", () => {
+      const globalState = appReducer(
+        undefined,
+        applicationChangeState("active")
+      );
+      const store = createStore(appReducer, globalState as any);
+      store.dispatch(
+        paymentsCreateTransactionAction.request({
+          data: {
+            paymentNotices: []
+          }
+        })
+      );
+      expect(
+        store.getState().features.payments.checkout.transaction
+      ).toStrictEqual(pot.toLoading(INITIAL_STATE.transaction));
+    });
+
+    it("should handle paymentsCreateTransactionAction success", () => {
+      const globalState = appReducer(
+        undefined,
+        applicationChangeState("active")
+      );
+      const store = createStore(appReducer, globalState as any);
+
+      const data = {
+        payments: [],
+        transactionId: "123",
+        status: TransactionStatusEnum.ACTIVATED,
+        authorizationCode: "123"
+      };
+
+      store.dispatch(paymentsCreateTransactionAction.success(data));
+      expect(
+        store.getState().features.payments.checkout.transaction
+      ).toStrictEqual(pot.some(data));
+    });
+
+    it("should handle paymentsCreateTransactionAction failure", () => {
+      const globalState = appReducer(
+        undefined,
+        applicationChangeState("active")
+      );
+      const store = createStore(appReducer, globalState as any);
+      store.dispatch(paymentsCreateTransactionAction.failure(networkError));
+      expect(
+        store.getState().features.payments.checkout.transaction
+      ).toStrictEqual(pot.noneError(networkError));
+    });
+  });
+
+  describe("paymentsDeleteTransactionAction", () => {
+    it("should handle paymentsDeleteTransactionAction request", () => {
+      const globalState = appReducer(
+        undefined,
+        applicationChangeState("active")
+      );
+      const store = createStore(appReducer, globalState as any);
+      store.dispatch(paymentsDeleteTransactionAction.request("123"));
+      expect(
+        store.getState().features.payments.checkout.transaction
+      ).toStrictEqual(pot.toLoading(INITIAL_STATE.transaction));
+    });
+
+    it("should handle paymentsDeleteTransactionAction success", () => {
+      const globalState = appReducer(
+        undefined,
+        applicationChangeState("active")
+      );
+      const store = createStore(appReducer, globalState as any);
+      store.dispatch(paymentsDeleteTransactionAction.success());
+      expect(
+        store.getState().features.payments.checkout.transaction
+      ).toStrictEqual(pot.none);
+    });
+
+    it("should handle paymentsDeleteTransactionAction failure", () => {
+      const globalState = appReducer(
+        undefined,
+        applicationChangeState("active")
+      );
+      const store = createStore(appReducer, globalState as any);
+      store.dispatch(paymentsDeleteTransactionAction.failure(networkError));
+      expect(
+        store.getState().features.payments.checkout.transaction
+      ).toStrictEqual(pot.noneError(networkError));
+    });
+  });
+
+  describe("paymentsGetPaymentDetailsAction", () => {
+    it("should handle paymentsGetPaymentDetailsAction request", () => {
+      const globalState = appReducer(
+        undefined,
+        applicationChangeState("active")
+      );
+      const store = createStore(appReducer, globalState as any);
+      store.dispatch(
+        paymentsGetPaymentDetailsAction.request("abc123" as RptId)
+      );
+      expect(
+        store.getState().features.payments.checkout.paymentDetails
+      ).toStrictEqual(pot.toLoading(INITIAL_STATE.paymentDetails));
+    });
+
+    it("should handle paymentsGetPaymentDetailsAction success", () => {
+      const globalState = appReducer(
+        undefined,
+        applicationChangeState("active")
+      );
+      const store = createStore(appReducer, globalState as any);
+      store.dispatch(
+        paymentsGetPaymentDetailsAction.success({
+          amount: 100 as AmountEuroCents
+        })
+      );
+      expect(
+        store.getState().features.payments.checkout.paymentDetails
+      ).toStrictEqual(
+        pot.some({
+          amount: 100 as AmountEuroCents
+        })
+      );
+    });
+
+    it("should handle paymentsGetPaymentDetailsAction failure", () => {
+      const globalState = appReducer(
+        undefined,
+        applicationChangeState("active")
+      );
+      const store = createStore(appReducer, globalState as any);
+      store.dispatch(paymentsGetPaymentDetailsAction.failure(networkError));
+      expect(
+        store.getState().features.payments.checkout.paymentDetails
+      ).toStrictEqual(pot.noneError(networkError));
+    });
+  });
+
+  describe("paymentsGetPaymentMethodsAction", () => {
+    it("should handle paymentsGetPaymentMethodsAction request", () => {
+      const globalState = appReducer(
+        undefined,
+        applicationChangeState("active")
+      );
+      const store = createStore(appReducer, globalState as any);
+      store.dispatch(
+        paymentsGetPaymentMethodsAction.request({
+          amount: 100
+        })
+      );
+      expect(
+        store.getState().features.payments.checkout.allPaymentMethods
+      ).toStrictEqual(pot.noneLoading);
+    });
+
+    it("should handle paymentsGetPaymentMethodsAction success", () => {
+      const globalState = appReducer(
+        undefined,
+        applicationChangeState("active")
+      );
+      const store = createStore(appReducer, globalState as any);
+      store.dispatch(
+        paymentsGetPaymentMethodsAction.success({
+          paymentMethods: []
+        })
+      );
+      expect(
+        store.getState().features.payments.checkout.allPaymentMethods
+      ).toStrictEqual(
+        pot.some({
+          paymentMethods: []
+        })
+      );
+    });
+
+    it("should handle paymentsGetPaymentMethodsAction failure", () => {
+      const globalState = appReducer(
+        undefined,
+        applicationChangeState("active")
+      );
+      const store = createStore(appReducer, globalState as any);
+      store.dispatch(paymentsGetPaymentMethodsAction.failure(networkError));
+      expect(
+        store.getState().features.payments.checkout.allPaymentMethods
+      ).toStrictEqual(
+        pot.toError(INITIAL_STATE.allPaymentMethods, networkError)
+      );
+    });
+  });
+
+  describe("paymentsGetPaymentTransactionInfoAction", () => {
+    it("should handle paymentsGetPaymentTransactionInfoAction request", () => {
+      const globalState = appReducer(
+        undefined,
+        applicationChangeState("active")
+      );
+      const store = createStore(appReducer, globalState as any);
+      store.dispatch(
+        paymentsGetPaymentTransactionInfoAction.request({
+          transactionId: "123"
+        })
+      );
+      expect(
+        store.getState().features.payments.checkout.transaction
+      ).toStrictEqual(pot.toLoading(INITIAL_STATE.transaction));
+    });
+
+    it("should handle paymentsGetPaymentTransactionInfoAction success", () => {
+      const globalState = appReducer(
+        undefined,
+        applicationChangeState("active")
+      );
+      const store = createStore(appReducer, globalState as any);
+      store.dispatch(
+        paymentsGetPaymentTransactionInfoAction.success({
+          payments: [],
+          transactionId: "123",
+          status: TransactionStatusEnum.ACTIVATED
+        })
+      );
+      expect(
+        store.getState().features.payments.checkout.transaction
+      ).toStrictEqual(
+        pot.some({
+          payments: [],
+          transactionId: "123",
+          status: TransactionStatusEnum.ACTIVATED
+        })
+      );
+    });
+
+    it("should handle paymentsGetPaymentTransactionInfoAction failure", () => {
+      const globalState = appReducer(
+        undefined,
+        applicationChangeState("active")
+      );
+      const store = createStore(appReducer, globalState as any);
+      store.dispatch(
+        paymentsGetPaymentTransactionInfoAction.failure(networkError)
+      );
+      expect(
+        store.getState().features.payments.checkout.transaction
+      ).toStrictEqual(pot.toError(INITIAL_STATE.transaction, networkError));
+    });
+  });
+
+  describe("paymentsGetPaymentUserMethodsAction", () => {
+    it("should handle paymentsGetPaymentUserMethodsAction request", () => {
+      const globalState = appReducer(
+        undefined,
+        applicationChangeState("active")
+      );
+      const store = createStore(appReducer, globalState as any);
+      store.dispatch(paymentsGetPaymentUserMethodsAction.request({}));
+      expect(
+        store.getState().features.payments.checkout.userWallets
+      ).toStrictEqual(pot.noneLoading);
+    });
+
+    it("should handle paymentsGetPaymentUserMethodsAction success", () => {
+      const globalState = appReducer(
+        undefined,
+        applicationChangeState("active")
+      );
+      const store = createStore(appReducer, globalState as any);
+      store.dispatch(paymentsGetPaymentUserMethodsAction.success({}));
+      expect(
+        store.getState().features.payments.checkout.userWallets
+      ).toStrictEqual(pot.some({}));
+    });
+
+    it("should handle paymentsGetPaymentUserMethodsAction failure", () => {
+      const globalState = appReducer(
+        undefined,
+        applicationChangeState("active")
+      );
+      const store = createStore(appReducer, globalState as any);
+      store.dispatch(paymentsGetPaymentUserMethodsAction.failure(networkError));
+      expect(
+        store.getState().features.payments.checkout.userWallets
+      ).toStrictEqual(pot.toError(INITIAL_STATE.userWallets, networkError));
+    });
+  });
+
+  describe("paymentsGetRecentPaymentMethodUsedAction", () => {
+    it("should handle paymentsGetRecentPaymentMethodUsedAction request", () => {
+      const globalState = appReducer(
+        undefined,
+        applicationChangeState("active")
+      );
+      const store = createStore(appReducer, globalState as any);
+      store.dispatch(paymentsGetRecentPaymentMethodUsedAction.request());
+      expect(
+        store.getState().features.payments.checkout.recentUsedPaymentMethod
+      ).toStrictEqual(pot.noneLoading);
+    });
+
+    it("should handle paymentsGetRecentPaymentMethodUsedAction success", () => {
+      const globalState = appReducer(
+        undefined,
+        applicationChangeState("active")
+      );
+      const store = createStore(appReducer, globalState as any);
+      store.dispatch(
+        paymentsGetRecentPaymentMethodUsedAction.success({
+          date: new Date("2020-01-01"),
+          paymentMethodId: "123",
+          type: GuestMethodLastUsageTypeEnum.guest
+        })
+      );
+      expect(
+        store.getState().features.payments.checkout.recentUsedPaymentMethod
+      ).toStrictEqual(
+        pot.some({
+          date: new Date("2020-01-01"),
+          paymentMethodId: "123",
+          type: GuestMethodLastUsageTypeEnum.guest
+        })
+      );
+    });
+
+    it("should handle paymentsGetRecentPaymentMethodUsedAction failure", () => {
+      const globalState = appReducer(
+        undefined,
+        applicationChangeState("active")
+      );
+      const store = createStore(appReducer, globalState as any);
+      store.dispatch(
+        paymentsGetRecentPaymentMethodUsedAction.failure(networkError)
+      );
+      expect(
+        store.getState().features.payments.checkout.recentUsedPaymentMethod
+      ).toStrictEqual(
+        pot.toError(INITIAL_STATE.recentUsedPaymentMethod, networkError)
+      );
+    });
+  });
+
+  describe("paymentsStartPaymentAuthorizationAction", () => {
+    it("should handle paymentsStartPaymentAuthorizationAction request", () => {
+      const globalState = appReducer(
+        undefined,
+        applicationChangeState("active")
+      );
+      const store = createStore(appReducer, globalState as any);
+
+      const data = {
+        isAllCCP: false,
+        paymentAmount: 100 as AmountEuroCents,
+        paymentMethodId: "123",
+        transactionId: "123",
+        walletId: "123",
+        pspId: "123",
+        paymentFees: 100 as AmountEuroCents
+      };
+
+      store.dispatch(paymentsStartPaymentAuthorizationAction.request(data));
+      expect(store.getState().features.payments.checkout).toStrictEqual({
+        ...INITIAL_STATE,
+        authorizationUrl: pot.toLoading(INITIAL_STATE.authorizationUrl)
+      });
+    });
+
+    it("should handle paymentsStartPaymentAuthorizationAction success", () => {
+      const globalState = appReducer(
+        undefined,
+        applicationChangeState("active")
+      );
+      const store = createStore(appReducer, globalState as any);
+      store.dispatch(
+        paymentsStartPaymentAuthorizationAction.success({
+          authorizationRequestId: "123",
+          authorizationUrl: "http://example.com"
+        })
+      );
+      expect(store.getState().features.payments.checkout).toStrictEqual({
+        ...INITIAL_STATE,
+        authorizationUrl: pot.some("http://example.com")
+      });
+    });
+
+    it("should handle paymentsStartPaymentAuthorizationAction failure", () => {
+      const globalState = appReducer(
+        undefined,
+        applicationChangeState("active")
+      );
+      const store = createStore(appReducer, globalState as any);
+      store.dispatch(
+        paymentsStartPaymentAuthorizationAction.failure(networkError)
+      );
+      expect(
+        store.getState().features.payments.checkout.authorizationUrl
+      ).toStrictEqual(pot.noneError(networkError));
+    });
+  });
+});
diff --git a/ts/features/payments/checkout/store/reducers/index.ts b/ts/features/payments/checkout/store/reducers/index.ts
index 61f742e1daf..82af481dbd5 100644
--- a/ts/features/payments/checkout/store/reducers/index.ts
+++ b/ts/features/payments/checkout/store/reducers/index.ts
@@ -14,7 +14,6 @@ import { WalletInfo } from "../../../../../../definitions/pagopa/ecommerce/Walle
 import { Wallets } from "../../../../../../definitions/pagopa/ecommerce/Wallets";
 import { Action } from "../../../../../store/actions/types";
 import { NetworkError } from "../../../../../utils/errors";
-import { getSortedPspList } from "../../../common/utils";
 import { WalletPaymentStepEnum } from "../../types";
 import { FaultCodeCategoryEnum as PaymentMethodNotAvailableEnum } from "../../types/PspPaymentMethodNotAvailableProblemJson";
 import { WalletPaymentFailure } from "../../types/WalletPaymentFailure";
@@ -36,6 +35,7 @@ import {
   selectPaymentPspAction,
   walletPaymentSetCurrentStep
 } from "../actions/orchestration";
+import { getSortedPspList } from "../../../common/utils";
 export const WALLET_PAYMENT_STEP_MAX = 4;
 
 export type PaymentsCheckoutState = {
@@ -180,9 +180,10 @@ const reducer = (
         ...state,
         pspList: pot.toLoading(state.pspList)
       };
-    case getType(paymentsCalculatePaymentFeesAction.success):
-      const bundles = action.payload.bundles;
-      // We choose the next step based on the PSP list lenght
+    case getType(paymentsCalculatePaymentFeesAction.success): {
+      const bundles = getSortedPspList(action.payload.bundles, "default");
+
+      // We choose the next step based on the PSP list length
       // If only 1 PSP we do not have the need to selected one
       const currentStep =
         bundles.length > 1
@@ -190,12 +191,11 @@ const reducer = (
           : WalletPaymentStepEnum.CONFIRM_TRANSACTION;
 
       // Bundles are stored sorted by default sort rule
-      const sortedBundles = getSortedPspList(bundles, "default");
 
       // Automatically select PSP if only 1 received or with `onUs` property
       const preselectedPsp =
-        sortedBundles.length === 1 || sortedBundles[0]?.onUs
-          ? O.some(sortedBundles[0])
+        bundles.length === 1 || bundles[0]?.onUs
+          ? O.some(bundles[0])
           : state.selectedPsp;
 
       // Use the preselected PSP only if there isn't any already selected PSP
@@ -206,10 +206,11 @@ const reducer = (
 
       return {
         ...state,
-        pspList: pot.some(sortedBundles),
+        pspList: pot.some(bundles),
         currentStep,
         selectedPsp
       };
+    }
     case getType(paymentsCalculatePaymentFeesAction.cancel):
       return {
         ...state,
diff --git a/ts/features/payments/common/utils/__test__/index.test.ts b/ts/features/payments/common/utils/__test__/index.test.ts
index 8368aff74dd..a0ac8dfa235 100644
--- a/ts/features/payments/common/utils/__test__/index.test.ts
+++ b/ts/features/payments/common/utils/__test__/index.test.ts
@@ -1,4 +1,27 @@
-import { formatPaymentNoticeNumber } from "..";
+import * as pot from "@pagopa/ts-commons/lib/pot";
+import * as O from "fp-ts/lib/Option";
+import {
+  formatPaymentNoticeNumber,
+  getAlertVariant,
+  getBadgePropsByTransactionStatus,
+  getPaymentLogoFromWalletDetails,
+  getSortedPspList,
+  getTransactionLogo,
+  hasApplicationEnabled,
+  hasPaymentFeature,
+  isPaymentMethodExpired,
+  isPaymentSupported,
+  mapWalletIdToCardKey
+} from "..";
+import { LevelEnum } from "../../../../../../definitions/content/SectionStatus";
+import { NoticeListItem } from "../../../../../../definitions/pagopa/biz-events/NoticeListItem";
+import { Bundle } from "../../../../../../definitions/pagopa/ecommerce/Bundle";
+import { WalletStatusEnum } from "../../../../../../definitions/pagopa/ecommerce/WalletStatus";
+import { WalletApplicationStatusEnum } from "../../../../../../definitions/pagopa/walletv3/WalletApplicationStatus";
+import { WalletInfo } from "../../../../../../definitions/pagopa/walletv3/WalletInfo";
+import I18n from "../../../../../i18n";
+import { UIWalletInfoDetails } from "../../types/UIWalletInfoDetails";
+import { ListItemTransactionStatus } from "../types";
 
 describe("formatPaymentNoticeNumber", () => {
   it("should properly format a standard notice number", () => {
@@ -27,3 +50,253 @@ describe("formatPaymentNoticeNumber", () => {
     expect(formattedNoticeNumber).toBe(nonGroupableNoticeNumber);
   });
 });
+
+describe("getAlertVariant", () => {
+  it("should return 'error' for LevelEnum.critical", () => {
+    expect(getAlertVariant(LevelEnum.critical)).toBe("error");
+  });
+  it("should return 'info' for LevelEnum.normal", () => {
+    expect(getAlertVariant(LevelEnum.normal)).toBe("info");
+  });
+  it("should return 'warning' for LevelEnum.warning", () => {
+    expect(getAlertVariant(LevelEnum.warning)).toBe("warning");
+  });
+  it("should return 'info' for any other value", () => {
+    expect(getAlertVariant("random" as LevelEnum)).toBe("info");
+  });
+});
+
+describe("getBadgeTextByTransactionStatus", () => {
+  it("should return the correct badge text for 'failure'", () => {
+    expect(getBadgePropsByTransactionStatus("failure")).toStrictEqual({
+      text: I18n.t("global.badges.failed"),
+      variant: "error"
+    });
+  });
+  it("should return the correct badge text for 'cancelled'", () => {
+    expect(getBadgePropsByTransactionStatus("cancelled")).toStrictEqual({
+      text: I18n.t("global.badges.cancelled"),
+      variant: "error"
+    });
+  });
+  it("should return the correct badge text for 'reversal'", () => {
+    expect(getBadgePropsByTransactionStatus("reversal")).toStrictEqual({
+      text: I18n.t("global.badges.reversal"),
+      variant: "lightBlue"
+    });
+  });
+  it("should return the correct badge text for 'pending'", () => {
+    expect(getBadgePropsByTransactionStatus("pending")).toStrictEqual({
+      text: I18n.t("global.badges.onGoing"),
+      variant: "info"
+    });
+  });
+  it("should return an empty string for an unknown status", () => {
+    expect(
+      getBadgePropsByTransactionStatus("unknown" as ListItemTransactionStatus)
+    ).toStrictEqual({ text: "", variant: "default" });
+  });
+});
+
+describe("getSortedPspList", () => {
+  const pspList: ReadonlyArray<Bundle> = [
+    { pspBusinessName: "B", taxPayerFee: 2 },
+    { pspBusinessName: "A", taxPayerFee: 1 },
+    { pspBusinessName: "C", taxPayerFee: 3 }
+  ] as ReadonlyArray<Bundle>;
+
+  it("should sort by name", () => {
+    const sortedList = getSortedPspList(pspList, "name");
+    expect(sortedList[0].pspBusinessName).toBe("A");
+    expect(sortedList[1].pspBusinessName).toBe("B");
+    expect(sortedList[2].pspBusinessName).toBe("C");
+  });
+
+  it("should sort by amount", () => {
+    const sortedList = getSortedPspList(pspList, "amount");
+    expect(sortedList[0].taxPayerFee).toBe(1);
+    expect(sortedList[1].taxPayerFee).toBe(2);
+    expect(sortedList[2].taxPayerFee).toBe(3);
+  });
+
+  it("should return the default order", () => {
+    const sortedList = getSortedPspList(pspList, "default");
+    expect(sortedList[0].pspBusinessName).toBe("B");
+    expect(sortedList[1].pspBusinessName).toBe("A");
+    expect(sortedList[2].pspBusinessName).toBe("C");
+  });
+});
+
+describe("getPaymentLogoFromWalletDetails", () => {
+  it("should return 'payPal' if maskedEmail is provided", () => {
+    const details: UIWalletInfoDetails = { maskedEmail: "test@example.com" };
+    expect(getPaymentLogoFromWalletDetails(details)).toBe("payPal");
+  });
+  it("should return 'bancomatPay' if maskedNumber is provided", () => {
+    const details: UIWalletInfoDetails = { maskedNumber: "1234567890" };
+    expect(getPaymentLogoFromWalletDetails(details)).toBe("bancomatPay");
+  });
+  it("should return the correct logo based on brand", () => {
+    const details: UIWalletInfoDetails = { brand: "VISA" };
+    expect(getPaymentLogoFromWalletDetails(details)).toBe("visa");
+  });
+  it("should return undefined if no details are provided", () => {
+    const details: UIWalletInfoDetails = {};
+    expect(getPaymentLogoFromWalletDetails(details)).toBeUndefined();
+  });
+});
+
+describe("getTransactionLogo", () => {
+  it("should return the correct transaction logo URL", () => {
+    const transaction = { payeeTaxCode: "00012345678" } as NoticeListItem;
+    const logoUrl = getTransactionLogo(transaction);
+    expect(O.isSome(logoUrl)).toBe(true);
+    expect(pot.some(logoUrl).value).not.toBeUndefined();
+  });
+  it("should return none if payeeTaxCode is not provided", () => {
+    const transaction = {} as NoticeListItem;
+    const logoUrl = getTransactionLogo(transaction);
+    expect(O.isNone(logoUrl)).toBe(true);
+  });
+});
+
+describe("mapWalletIdToCardKey", () => {
+  it("should return the correct card key", () => {
+    const walletId = "wallet123";
+    expect(mapWalletIdToCardKey(walletId)).toBe("method_wallet123");
+  });
+});
+
+describe("isPaymentMethodExpired", () => {
+  it("should return true if the payment method is expired", () => {
+    const details: UIWalletInfoDetails = {
+      expiryDate: "10001"
+    };
+    expect(isPaymentMethodExpired(details)).toBe(true);
+  });
+  it("should return false if the payment method is not expired", () => {
+    const details: UIWalletInfoDetails = { expiryDate: "30001" };
+    expect(isPaymentMethodExpired(details)).toBe(false);
+  });
+  it("should return false if expiry date is not provided", () => {
+    const details: UIWalletInfoDetails = {};
+    expect(isPaymentMethodExpired(details)).toBe(false);
+  });
+});
+
+describe("hasApplicationEnabled", () => {
+  const walletApplication = "PAGOPA";
+
+  const walletObject: WalletInfo = {
+    paymentMethodId: "pm_12345",
+    status: WalletStatusEnum.VALIDATED,
+    walletId: "wallet_12345",
+    creationDate: new Date(),
+    updateDate: new Date(),
+    applications: [
+      {
+        name: "PAGOPA",
+        status: WalletApplicationStatusEnum.ENABLED
+      }
+    ],
+    clients: {},
+    paymentMethodAsset: ""
+  };
+
+  it("should return true if the application is enabled", () => {
+    expect(hasApplicationEnabled(walletObject, walletApplication)).toBe(true);
+  });
+
+  it("should return false if the application is disabled", () => {
+    expect(
+      hasApplicationEnabled(
+        {
+          ...walletObject,
+          applications: [
+            {
+              name: "PAGOPA",
+              status: WalletApplicationStatusEnum.DISABLED
+            }
+          ]
+        },
+        walletApplication
+      )
+    ).toBe(false);
+  });
+
+  it("should return false if payment method is undefined", () => {
+    expect(hasApplicationEnabled(undefined, walletApplication)).toBe(false);
+  });
+});
+
+describe("hasPaymentFeature", () => {
+  const walletObject: WalletInfo = {
+    paymentMethodId: "pm_12345",
+    status: WalletStatusEnum.VALIDATED,
+    walletId: "wallet_12345",
+    creationDate: new Date(),
+    updateDate: new Date(),
+    applications: [
+      {
+        name: "PAGOPA",
+        status: WalletApplicationStatusEnum.ENABLED
+      }
+    ],
+    clients: {},
+    paymentMethodAsset: ""
+  };
+
+  it("should return true if the payment method has the payment feature", () => {
+    expect(hasPaymentFeature(walletObject)).toBe(true);
+  });
+
+  it("should return false if the payment method does not have the payment feature", () => {
+    expect(
+      hasPaymentFeature({
+        ...walletObject,
+        applications: [
+          {
+            name: "OTHER",
+            status: WalletApplicationStatusEnum.ENABLED
+          }
+        ]
+      })
+    ).toBe(false);
+  });
+});
+
+describe("isPaymentSupported", () => {
+  const walletObject: WalletInfo = {
+    paymentMethodId: "pm_12345",
+    status: WalletStatusEnum.VALIDATED,
+    walletId: "wallet_12345",
+    creationDate: new Date(),
+    updateDate: new Date(),
+    applications: [
+      {
+        name: "PAGOPA",
+        status: WalletApplicationStatusEnum.ENABLED
+      }
+    ],
+    clients: {},
+    paymentMethodAsset: ""
+  };
+
+  it("should return 'available' if the payment method has the payment feature", () => {
+    expect(isPaymentSupported(walletObject)).toBe("available");
+  });
+
+  it("should return 'notAvailable' if the payment method does not have the payment feature", () => {
+    expect(
+      isPaymentSupported({
+        ...walletObject,
+        applications: [
+          {
+            name: "OTHER",
+            status: WalletApplicationStatusEnum.ENABLED
+          }
+        ]
+      })
+    ).toBe("notAvailable");
+  });
+});
diff --git a/ts/features/payments/common/utils/index.ts b/ts/features/payments/common/utils/index.ts
index a2b1a36fe6c..c3c823719af 100644
--- a/ts/features/payments/common/utils/index.ts
+++ b/ts/features/payments/common/utils/index.ts
@@ -141,7 +141,11 @@ export const getSortedPspList = (
 ) => {
   switch (sortType) {
     case "name":
-      return _.orderBy(pspList, psp => psp.pspBusinessName);
+      return _.orderBy(
+        pspList,
+        ["pspBusinessName", "taxPayerFee"],
+        ["asc", "asc"]
+      );
     case "amount":
       return _.orderBy(
         pspList,
@@ -150,11 +154,7 @@ export const getSortedPspList = (
       );
     case "default":
     default:
-      return _.orderBy(
-        pspList,
-        ["onUs", "taxPayerFee", "pspBusinessName"],
-        ["desc", "asc", "asc"]
-      );
+      return [...pspList];
   }
 };