rest of the code
  enableNewMethod,
}: ISetupPaymentMethodState) => {
  //

 rest of the code

  if (enableNewMethod) {
    availablePaymentMethodList.push(NEW_PAYMENT_METHOD_PLACEHOLDER);
  }
  //

 rest of the code
};

 rest of the code
  newMethod: null,
};

rest of the code
  const enableNewMethod = useFlag(LaunchDarklyFlag.ENABLE_CREDIT_CARD_AT_HOME_PAYCOMET); // new line
  
  
    const initPaymentMethods = useCallback(() => {
      const {
        availablePaymentMethodList,
        validDefaultPaymentMethodId,
        validDefaultReloadPaymentMethodId,
      } = getPaymentMethodsState({
         enableNewMethod, // new line here
      });
    },
    []
  );
});

 rest of the code
    setIsPaycometNewMethodSelected(''); // New line
  };

rest 

of the code
      setIsPaycometNewMethodSelected('');
    }
  }, [setCheckoutPaymentMethodId, checkoutPaymentMethodId]);

rest of the code
        const isPaymentWithVoucher =
          paymentAccount.paymentMethodBrand === PaymentMethodBrand.SODEXO_VOUCHER ||
          paymentAccount.paymentMethodBrand === PaymentMethodBrand.CHEQUE_GOURMET_VOUCHER;
        if (payment.checkoutPaymentMethodId === CASH_ACCOUNT_IDENTIFIER || isPaymentWithVoucher) {
          const paymentDetails: IPayment = {
            cashPayment: true,
            fullName,
            paymentMethodBrand: paymentAccount?.paymentMethodBrand ?? undefined,
          };

          if (payment.isVrPayment) {
            // The GraphQL endpoint for VR Payment expects this object even
            // for Cash orders, otherwise the order creation fails
            paymentDetails.vrPaymentInput = {
              merchantAccount: '',
              pspReference: '',
              storePaymentMethod: true,
            };
          }

          return commitOrder({
            ...commitInput,
            creditType: CASH_ACCOUNT_IDENTIFIER,
            payment: paymentDetails,
          });
        }

 rest of the code
  ADD_NEW_PAYMENT_NEW_METHOD = 'addNewPaymentNewMethod',
}

 rest of the code
  setIsPaycometNewMethodSelected?: Dispatch<SetStateAction<string>>;
  isPaycometNewMethodSelected?: string;
}

 rest of the code
  isPaycometNewMethodSelected?: string;
};

function getCurrentSelectedMethodType({
  //

 rest of the code
  isPaycometNewMethodSelected
}: GetCurrentSelectedMethodTypeParams): CurrentSelectedMethodType {
  let currentSelectedMethodType = CurrentSelectedMethodType.ADD_NEW_PAYMENT_METHOD;
  // 

rest of the code
  if (isPaycometNewMethodSelected === 'card') {
    currentSelectedMethodType = CurrentSelectedMethodType.ADD_NEW_PAYMENT_NEW_METHOD;
  }
  //

 rest of the code
}

 rest of the code
   isPaycometNewMethodSelected, // new line here
  } = useOrderPayment({
    serverOrder,
    onPriceOrder,
    enableOrderTimedFire,
  });

 rest of the code
   isPaycometNewMethodSelected={isPaycometNewMethodSelected}
/>

 rest of the code
  isPaycometNewMethodSelected,
  setIsPaycometNewMethodSelected,
}: IPaymentMethodProps) {
  // 

rest of the code
  
  // pass the new prop in the getCurrentSelectedMethodType
  const currentSelectedMethodType = getCurrentSelectedMethodType({
    isPaycometNewMethodSelected
  });
});

[
    // rest of the code
    

'NEW_METHOD',
  ];
  
 

 // Add 

new 

case 

in switch for our new 

method
  function filterMethodByType(typeOrder: 

string, paymentMethods: IPaymentMethod[]): IPaymentMethod[] {

  switch 

(typeOrder) {
    // rest of the code

case 'NEW_METHOD':
     

 return paymentMethods.filter(
    

p => !p?.transient && p?.newMethod && p.accountIdentifier 

=== typeOrder
      );
   

 //

 rest of the code
  }
}

= serverOrder?.delivery;

  const 

isNotLocalWallet = (method: 

IPaymentMethod) => {
    return !method.blik && !method.ideal;
  };

  const sortedMethodsFilterConditions = (method: IPaymentMethod) => {
    if (method.newMethod && !isDelivery) {
      return false; // remove our item from the list if delivery is not selected
    }

    return isNotLocalWallet(method);
  };
      
      // A suggestion would be the creation of a new function for the filter conditions
      {!enableSortPaymentMethods &&
        unSelectedMethods.filter(sortedMethodsFilterConditions).map(method => {

const {
 

 // rest of 

code
    setIsPaycometNewMethodSelected,

 isPaycometNewMethodSelected,
  } 

= useOrderPayment(

{
    enableOrderTimedFire,
 

 onPriceOrder,
   

 serverOrder,
  });

{showPaymentMethodSelection && (
    

<PaymentMethod
      // rest of the code
    

  setIsPaycometNewMethodSelected={setIsPaycometNewMethodSelected} 

// 

new 

line

     isPaycometNewMethodSelected={isPaycometNewMethodSelected} // 

new line
      

onResult={onPaymentOutcome}
    />
  

)}