Bug: [FEATURE] Pre-fill Required fields values in Payment Method List API



### Feature Description

1. The required fields in Payment Method List API needs to be segregated according to mandate/non-mandate payment types and a unified response should be formed for the required fields.
2. The values passed in payments create req should be sent in Payment Method List API response in order for SDK to pre-fill these values.

### Possible Implementation

Will be segregating Required fields into mandate/non-mandate sections, unifying the response later accordingly.
Refactoring the structure of the response to accommodate for the extra fields required.

### Have you spent some time to check if this feature request has been raised before?

- [X] I checked and didn't find similar issue

### Have you read the Contributing Guidelines?

- [X] I have read the [Contributing Guidelines](https://github.com/juspay/hyperswitch/blob/main/docs/CONTRIBUTING.md)

### Are you willing to submit a PR?

Yes I am willing to submit a PR!
diff --git a/crates/api_models/src/payment_methods.rs b/crates/api_models/src/payment_methods.rs
index 749b12f77d2..0d1b3f8f9b6 100644
--- a/crates/api_models/src/payment_methods.rs
+++ b/crates/api_models/src/payment_methods.rs
@@ -1,4 +1,4 @@
-use std::collections::HashSet;
+use std::collections::HashMap;
 
 use cards::CardNumber;
 use common_utils::{crypto::OptionalEncryptableName, pii};
@@ -220,7 +220,7 @@ pub struct ResponsePaymentMethodTypes {
     pub bank_transfers: Option<BankTransferTypes>,
 
     /// Required fields for the payment_method_type.
-    pub required_fields: Option<HashSet<RequiredFieldInfo>>,
+    pub required_fields: Option<HashMap<String, RequiredFieldInfo>>,
 }
 
 /// Required fields info used while listing the payment_method_data
@@ -235,6 +235,8 @@ pub struct RequiredFieldInfo {
     /// Possible field type of required field
     #[schema(value_type = FieldType)]
     pub field_type: api_enums::FieldType,
+
+    pub value: Option<String>,
 }
 
 #[derive(Debug, Clone, serde::Deserialize, serde::Serialize, ToSchema)]
diff --git a/crates/router/src/configs/defaults.rs b/crates/router/src/configs/defaults.rs
index 84b1b40b68b..4ab61aa4fa2 100644
--- a/crates/router/src/configs/defaults.rs
+++ b/crates/router/src/configs/defaults.rs
@@ -2,7 +2,7 @@ use std::collections::{HashMap, HashSet};
 
 use api_models::{enums, payment_methods::RequiredFieldInfo};
 
-use super::settings::{ConnectorFields, PaymentMethodType};
+use super::settings::{ConnectorFields, PaymentMethodType, RequiredFieldFinal};
 
 impl Default for super::settings::Server {
     fn default() -> Self {
@@ -239,328 +239,238 @@ impl Default for super::settings::RequiredFields {
                     ConnectorFields {
                         fields: HashMap::from([
                             (
-                                enums::Connector::Aci,
-                                vec![RequiredFieldInfo {
-                                    required_field: "payment_method_data.card.card_holder_name".to_string(),
-                                    display_name: "card_holder_name".to_string(),
-                                    field_type: enums::FieldType::UserFullName,
-                                }],
-                            ),
-                            (
-                                enums::Connector::Bluesnap,
-                                vec![
-                                    RequiredFieldInfo {
-                                        required_field: "email".to_string(),
-                                        display_name: "email".to_string(),
-                                        field_type: enums::FieldType::UserEmailAddress,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.first_name".to_string(),
-                                        display_name: "first_name".to_string(),
-                                        field_type: enums::FieldType::UserBillingName,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.last_name".to_string(),
-                                        display_name: "last_name".to_string(),
-                                        field_type: enums::FieldType::UserBillingName,
-                                    },
-                                ],
-                            ),
-                            (
-                                enums::Connector::Bambora,
-                                vec![RequiredFieldInfo {
-                                    required_field: "card.card_holder_name".to_string(),
-                                    display_name: "card_holder_name".to_string(),
-                                    field_type: enums::FieldType::UserFullName,
-                                }],
+                                enums::Connector::Stripe,
+                                RequiredFieldFinal {
+                                    mandate: HashMap::from([
+                                        (
+                                            "billing.address.line1".to_string(),
+                                            RequiredFieldInfo {
+                                                required_field: "billing.address.line1".to_string(),
+                                                display_name: "billing_line1".to_string(),
+                                                field_type: enums::FieldType::UserFullName,
+                                                value: None,
+                                            }
+                                        ),
+                                        (
+                                            "billing.address.first_name".to_string(),
+                                            RequiredFieldInfo {
+                                                required_field: "billing.address.first_name".to_string(),
+                                                display_name: "billing_first_name".to_string(),
+                                                field_type: enums::FieldType::UserFullName,
+                                                value: None,
+                                            }
+                                        )
+                                    ]),
+                                    non_mandate: HashMap::new(),
+                                    common:HashMap::from([
+                                        (
+                                            "shipping.address.line1".to_string(),
+                                            RequiredFieldInfo {
+                                                required_field: "shipping.address.line1".to_string(),
+                                                display_name: "shipping_line1".to_string(),
+                                                field_type: enums::FieldType::UserFullName,
+                                                value: None,
+                                            }
+                                        ),
+                                        (
+                                            "shipping.phone.number".to_string(),
+                                            RequiredFieldInfo {
+                                                required_field: "shipping.phone.number".to_string(),
+                                                display_name: "shipping_phone".to_string(),
+                                                field_type: enums::FieldType::UserFullName,
+                                                value: None,
+                                            }
+                                        )
+                                    ]),
+                                }
                             ),
                             (
-                                enums::Connector::Cybersource,
-                                vec![
-                                    RequiredFieldInfo {
-                                        required_field: "email".to_string(),
-                                        display_name: "email".to_string(),
-                                        field_type: enums::FieldType::UserEmailAddress,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "billing.phone.number".to_string(),
-                                        display_name: "phone_number".to_string(),
-                                        field_type: enums::FieldType::UserPhoneNumber,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "billing.phone.country_code".to_string(),
-                                        display_name: "country".to_string(),
-                                        field_type: enums::FieldType::UserCountry {
-                                            options: vec!["US".to_string(), "IN".to_string()],
-                                        },
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.first_name".to_string(),
-                                        display_name: "first_name".to_string(),
-                                        field_type: enums::FieldType::UserBillingName,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.last_name".to_string(),
-                                        display_name: "last_name".to_string(),
-                                        field_type: enums::FieldType::UserBillingName,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.line1".to_string(),
-                                        display_name: "line1".to_string(),
-                                        field_type: enums::FieldType::UserAddressline1,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.city".to_string(),
-                                        display_name: "city".to_string(),
-                                        field_type: enums::FieldType::UserAddressCity,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.state".to_string(),
-                                        display_name: "state".to_string(),
-                                        field_type: enums::FieldType::UserAddressState,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.zip".to_string(),
-                                        display_name: "zip".to_string(),
-                                        field_type: enums::FieldType::UserAddressPincode,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.country".to_string(),
-                                        display_name: "country".to_string(),
-                                        field_type: enums::FieldType::UserCountry {
-                                            options: vec!["US".to_string(), "IN".to_string()],
-                                        },
-                                    },
-                                ],
+                            enums::Connector::Cybersource,
+                            RequiredFieldFinal {
+                                mandate: HashMap::from([
+                                    (
+                                        "billing.address.line1".to_string(),
+                                        RequiredFieldInfo {
+                                            required_field: "billing.address.line1".to_string(),
+                                            display_name: "billing_line1".to_string(),
+                                            field_type: enums::FieldType::UserFullName,
+                                            value: None,
+                                        }
+                                    ),
+                                    (
+                                        "billing.address.first_name".to_string(),
+                                        RequiredFieldInfo {
+                                            required_field: "billing.address.first_name".to_string(),
+                                            display_name: "billing_first_name".to_string(),
+                                            field_type: enums::FieldType::UserFullName,
+                                            value: None,
+                                        }
+                                    )
+                                ]),
+                                non_mandate: HashMap::new(),
+                                common:HashMap::from([
+                                    (
+                                        "shipping.address.line1".to_string(),
+                                        RequiredFieldInfo {
+                                            required_field: "shipping.address.line1".to_string(),
+                                            display_name: "shipping_line1".to_string(),
+                                            field_type: enums::FieldType::UserFullName,
+                                            value: None,
+                                        }
+                                    ),
+                                    (
+                                        "shipping.phone.number".to_string(),
+                                        RequiredFieldInfo {
+                                            required_field: "shipping.phone.number".to_string(),
+                                            display_name: "shipping_phone".to_string(),
+                                            field_type: enums::FieldType::UserFullName,
+                                            value: None,
+                                        }
+                                    )
+                                ]),
+                            }
                             ),
                             (
                                 enums::Connector::Dlocal,
-                                vec![
-                                    RequiredFieldInfo {
-                                        required_field: "card.card_holder_name".to_string(),
-                                        display_name: "card_holder_name".to_string(),
-                                        field_type: enums::FieldType::UserFullName,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "email".to_string(),
-                                        display_name: "email".to_string(),
-                                        field_type: enums::FieldType::UserEmailAddress,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.country".to_string(),
-                                        display_name: "country".to_string(),
-                                        field_type: enums::FieldType::UserCountry {
-                                            options: vec!["US".to_string(), "IN".to_string()],
-                                        },
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.first_name".to_string(),
-                                        display_name: "first_name".to_string(),
-                                        field_type: enums::FieldType::UserBillingName,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.last_name".to_string(),
-                                        display_name: "last_name".to_string(),
-                                        field_type: enums::FieldType::UserBillingName,
-                                    },
-                                ],
+                               RequiredFieldFinal {
+                                mandate: HashMap::from([
+                                    (
+                                        "billing.address.line1".to_string(),
+                                        RequiredFieldInfo {
+                                            required_field: "billing.address.line1".to_string(),
+                                            display_name: "billing_line1".to_string(),
+                                            field_type: enums::FieldType::UserFullName,
+                                            value: None,
+                                        }
+                                    ),
+                                    (
+                                        "billing.address.first_name".to_string(),
+                                        RequiredFieldInfo {
+                                            required_field: "billing.address.first_name".to_string(),
+                                            display_name: "billing_first_name".to_string(),
+                                            field_type: enums::FieldType::UserFullName,
+                                            value: None,
+                                        }
+                                    )
+                                ]),
+                                non_mandate: HashMap::new(),
+                                common:HashMap::from([
+                                    (
+                                        "shipping.address.line1".to_string(),
+                                        RequiredFieldInfo {
+                                            required_field: "shipping.address.line1".to_string(),
+                                            display_name: "shipping_line1".to_string(),
+                                            field_type: enums::FieldType::UserFullName,
+                                            value: None,
+                                        }
+                                    ),
+                                    (
+                                        "shipping.phone.number".to_string(),
+                                        RequiredFieldInfo {
+                                            required_field: "shipping.phone.number".to_string(),
+                                            display_name: "shipping_phone".to_string(),
+                                            field_type: enums::FieldType::UserFullName,
+                                            value: None,
+                                        }
+                                    )
+                                ]),
+                            }
                             ),
                             (
                                 enums::Connector::Forte,
-                                vec![
-                                    RequiredFieldInfo {
-                                        required_field: "card.card_holder_name".to_string(),
-                                        display_name: "card_holder_name".to_string(),
-                                        field_type: enums::FieldType::UserFullName,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.first_name".to_string(),
-                                        display_name: "first_name".to_string(),
-                                        field_type: enums::FieldType::UserBillingName,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.last_name".to_string(),
-                                        display_name: "last_name".to_string(),
-                                        field_type: enums::FieldType::UserBillingName,
-                                    },
-                                ],
+                                RequiredFieldFinal {
+                                    mandate: HashMap::new(),
+                                    non_mandate: HashMap::new(),
+                                    common: HashMap::new(),
+                                }
                             ),
                             (
                                 enums::Connector::Globalpay,
-                                vec![RequiredFieldInfo {
-                                    required_field: "billing.address.country".to_string(),
-                                    display_name: "country".to_string(),
-                                    field_type: enums::FieldType::UserCountry {
-                                        options: vec!["US".to_string(), "IN".to_string()],
-                                    },
-                                }],
+                                RequiredFieldFinal {
+                                    mandate: HashMap::new(),
+                                    non_mandate: HashMap::new(),
+                                    common: HashMap::new(),
+                                }
                             ),
                             (
                                 enums::Connector::Iatapay,
-                                vec![RequiredFieldInfo {
-                                    required_field: "billing.address.country".to_string(),
-                                    display_name: "country".to_string(),
-                                    field_type: enums::FieldType::UserCountry {
-                                        options: vec!["US".to_string(), "IN".to_string()],
-                                    },
-                                }],
+                                RequiredFieldFinal {
+                                    mandate: HashMap::new(),
+                                    non_mandate: HashMap::new(),
+                                    common: HashMap::new(),
+                                }
                             ),
                             (
                                 enums::Connector::Multisafepay,
-                                vec![
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.first_name".to_string(),
-                                        display_name: "first_name".to_string(),
-                                        field_type: enums::FieldType::UserBillingName,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.last_name".to_string(),
-                                        display_name: "last_name".to_string(),
-                                        field_type: enums::FieldType::UserBillingName,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.line1".to_string(),
-                                        display_name: "line1".to_string(),
-                                        field_type: enums::FieldType::UserAddressline1,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.line2".to_string(),
-                                        display_name: "line2".to_string(),
-                                        field_type: enums::FieldType::UserAddressline2,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.city".to_string(),
-                                        display_name: "city".to_string(),
-                                        field_type: enums::FieldType::UserAddressCity,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.zip".to_string(),
-                                        display_name: "zip".to_string(),
-                                        field_type: enums::FieldType::UserAddressPincode,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.country".to_string(),
-                                        display_name: "country".to_string(),
-                                        field_type: enums::FieldType::UserCountry{
-                                            options: vec!["US".to_string(), "IN".to_string()],
-                                        },
-                                    },
-                                ],
+                                RequiredFieldFinal {
+                                    mandate: HashMap::new(),
+                                    non_mandate: HashMap::new(),
+                                    common: HashMap::new(),
+                                }
                             ),
                             (
                                 enums::Connector::Noon,
-                                vec![RequiredFieldInfo {
-                                    required_field: "card.card_holder_name".to_string(),
-                                    display_name: "card_holder_name".to_string(),
-                                    field_type: enums::FieldType::UserFullName,
-                                }],
+                                RequiredFieldFinal {
+                                    mandate: HashMap::new(),
+                                    non_mandate: HashMap::new(),
+                                    common: HashMap::new(),
+                                }
                             ),
                             (
                                 enums::Connector::Opennode,
-                                vec![RequiredFieldInfo {
-                                    required_field: "description".to_string(),
-                                    display_name: "description".to_string(),
-                                    field_type: enums::FieldType::Text,
-                                }],
+                                RequiredFieldFinal {
+                                    mandate: HashMap::new(),
+                                    non_mandate: HashMap::new(),
+                                    common: HashMap::new(),
+                                }
                             ),
                             (
                                 enums::Connector::Payu,
-                                vec![RequiredFieldInfo {
-                                    required_field: "description".to_string(),
-                                    display_name: "description".to_string(),
-                                    field_type: enums::FieldType::Text,
-                                }],
+                                RequiredFieldFinal {
+                                    mandate: HashMap::new(),
+                                    non_mandate: HashMap::new(),
+                                    common: HashMap::new(),
+                                }
                             ),
                             (
                                 enums::Connector::Rapyd,
-                                vec![RequiredFieldInfo {
-                                    required_field: "card.card_holder_name".to_string(),
-                                    display_name: "card_holder_name".to_string(),
-                                    field_type: enums::FieldType::UserFullName,
-                                }],
+                                RequiredFieldFinal {
+                                    mandate: HashMap::new(),
+                                    non_mandate: HashMap::new(),
+                                    common: HashMap::new(),
+                                }
                             ),
                             (
                                 enums::Connector::Shift4,
-                                vec![RequiredFieldInfo {
-                                    required_field: "card.card_holder_name".to_string(),
-                                    display_name: "card_holder_name".to_string(),
-                                    field_type: enums::FieldType::UserFullName,
-                                }],
+                                RequiredFieldFinal {
+                                    mandate: HashMap::new(),
+                                    non_mandate: HashMap::new(),
+                                    common: HashMap::new(),
+                                }
                             ),
                             (
                                 enums::Connector::Trustpay,
-                                vec![
-                                    RequiredFieldInfo {
-                                        required_field: "card.card_holder_name".to_string(),
-                                        display_name: "card_holder_name".to_string(),
-                                        field_type: enums::FieldType::UserFullName,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.line1".to_string(),
-                                        display_name: "line1".to_string(),
-                                        field_type: enums::FieldType::UserAddressline1,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.city".to_string(),
-                                        display_name: "city".to_string(),
-                                        field_type: enums::FieldType::UserAddressCity,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.zip".to_string(),
-                                        display_name: "zip".to_string(),
-                                        field_type: enums::FieldType::UserAddressPincode,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.country".to_string(),
-                                        display_name: "country".to_string(),
-                                        field_type: enums::FieldType::UserCountry {
-                                            options: vec!["US".to_string(), "IN".to_string()],
-                                        },
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "email".to_string(),
-                                        display_name: "email".to_string(),
-                                        field_type: enums::FieldType::UserEmailAddress,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "browser_info".to_string(),
-                                        display_name: "browser_info".to_string(),
-                                        field_type: enums::FieldType::Text,
-                                    },
-                                ],
+                                RequiredFieldFinal {
+                                    mandate: HashMap::new(),
+                                    non_mandate: HashMap::new(),
+                                    common: HashMap::new(),
+                                }
                             ),
                             (
                                 enums::Connector::Worldline,
-                                vec![RequiredFieldInfo {
-                                    required_field: "card.card_holder_name".to_string(),
-                                    display_name: "card_holder_name".to_string(),
-                                    field_type: enums::FieldType::UserFullName,
-                                }],
+                                RequiredFieldFinal {
+                                    mandate: HashMap::new(),
+                                    non_mandate: HashMap::new(),
+                                    common: HashMap::new(),
+                                }
                             ),
                             (
                                 enums::Connector::Zen,
-                                vec![
-                                    RequiredFieldInfo {
-                                        required_field: "email".to_string(),
-                                        display_name: "email".to_string(),
-                                        field_type: enums::FieldType::UserEmailAddress,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "browser_info".to_string(),
-                                        display_name: "browser_info".to_string(),
-                                        field_type: enums::FieldType::Text,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "description".to_string(),
-                                        display_name: "description".to_string(),
-                                        field_type: enums::FieldType::Text,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "metadata.order_details".to_string(),
-                                        display_name: "order_details".to_string(),
-                                        field_type: enums::FieldType::Text,
-                                    },
-                                ],
+                                RequiredFieldFinal {
+                                    mandate: HashMap::new(),
+                                    non_mandate: HashMap::new(),
+                                    common: HashMap::new(),
+                                }
                             ),
                         ]),
                     },
@@ -572,13 +482,14 @@ impl Default for super::settings::RequiredFields {
                     (
                         enums::PaymentMethodType::Przelewy24,
                         ConnectorFields {
-                            fields: HashMap::from([(
+                            fields: HashMap::from([
+                                (
                                 enums::Connector::Stripe,
-                                vec![RequiredFieldInfo {
-                                    required_field: "payment_method_data.bank_redirect.przelewy24.bank_name".to_string(),
-                                    display_name: "bank_name".to_string(),
-                                    field_type: enums::FieldType::UserBank,
-                                }],
+                                RequiredFieldFinal {
+                                    mandate: HashMap::new(),
+                                    non_mandate: HashMap::new(),
+                                    common: HashMap::new(),
+                                }
                             )]),
                         },
                     ),
@@ -588,40 +499,11 @@ impl Default for super::settings::RequiredFields {
                             fields: HashMap::from([
                                 (
                                     enums::Connector::Stripe,
-                                    vec![RequiredFieldInfo {
-                                        required_field: "payment_method_data.bank_redirect.bancontact_card.billing_details.billing_name".to_string(),
-                                        display_name: "billing_name".to_string(),
-                                        field_type: enums::FieldType::UserBillingName,
-                                    }],
-                                ),
-                                (
-                                    enums::Connector::Adyen,
-                                    vec![
-                                        RequiredFieldInfo {
-                                            required_field: "payment_method_data.bank_redirect.bancontact_card.card_number"
-                                                .to_string(),
-                                            display_name: "card_number".to_string(),
-                                            field_type: enums::FieldType::Text,
-                                        },
-                                        RequiredFieldInfo {
-                                            required_field: "payment_method_data.bank_redirect.bancontact_card.card_exp_month"
-                                                .to_string(),
-                                            display_name: "card_exp_month".to_string(),
-                                            field_type: enums::FieldType::Text,
-                                        },
-                                        RequiredFieldInfo {
-                                            required_field: "payment_method_data.bank_redirect.bancontact_card.card_exp_year"
-                                                .to_string(),
-                                            display_name: "card_exp_year".to_string(),
-                                            field_type: enums::FieldType::Text,
-                                        },
-                                        RequiredFieldInfo {
-                                            required_field: "payment_method_data.bank_redirect.bancontact_card.card_holder_name"
-                                                .to_string(),
-                                            display_name: "card_holder_name".to_string(),
-                                            field_type: enums::FieldType::UserFullName,
-                                        },
-                                    ],
+                                    RequiredFieldFinal {
+                                        mandate: HashMap::new(),
+                                        non_mandate: HashMap::new(),
+                                        common: HashMap::new(),
+                                    }
                                 ),
                             ]),
                         },
@@ -631,30 +513,12 @@ impl Default for super::settings::RequiredFields {
                         ConnectorFields {
                             fields: HashMap::from([
                                 (
-                                    enums::Connector::Worldline,
-                                    vec![RequiredFieldInfo {
-                                        required_field: "payment_method_data.bank_redirect.giropay.billing_details.billing_name"
-                                            .to_string(),
-                                        display_name: "billing_name".to_string(),
-                                        field_type: enums::FieldType::UserBillingName,
-                                    }],
-                                ),
-                                (
-                                    enums::Connector::Nuvei,
-                                    vec![
-                                        RequiredFieldInfo {
-                                            required_field: "email".to_string(),
-                                            display_name: "email".to_string(),
-                                            field_type: enums::FieldType::UserEmailAddress,
-                                        },
-                                        RequiredFieldInfo {
-                                            required_field: "billing.address.country".to_string(),
-                                            display_name: "country".to_string(),
-                                            field_type: enums::FieldType::UserCountry {
-                                                options: vec!["US".to_string(), "IN".to_string()],
-                                            },
-                                        },
-                                    ],
+                                    enums::Connector::Stripe,
+                                    RequiredFieldFinal {
+                                        mandate: HashMap::new(),
+                                        non_mandate: HashMap::new(),
+                                        common: HashMap::new(),
+                                    }
                                 ),
                             ]),
                         },
@@ -664,45 +528,12 @@ impl Default for super::settings::RequiredFields {
                         ConnectorFields {
                             fields: HashMap::from([
                                 (
-                                    enums::Connector::Worldline,
-                                    vec![RequiredFieldInfo {
-                                        required_field: "payment_method_data.bank_redirect.ideal.bank_name".to_string(),
-                                        display_name: "bank_name".to_string(),
-                                        field_type: enums::FieldType::UserBank,
-                                    }],
-                                ),
-                                (
-                                    enums::Connector::Nuvei,
-                                    vec![
-                                        RequiredFieldInfo {
-                                            required_field: "payment_method_data.bank_redirect.ideal.bank_name".to_string(),
-                                            display_name: "bank_name".to_string(),
-                                            field_type: enums::FieldType::UserBank,
-                                        },
-                                        RequiredFieldInfo {
-                                            required_field: "billing.address.first_name"
-                                                .to_string(),
-                                            display_name: "first_name".to_string(),
-                                            field_type: enums::FieldType::UserBillingName,
-                                        },
-                                        RequiredFieldInfo {
-                                            required_field: "billing.address.last_name".to_string(),
-                                            display_name: "last_name".to_string(),
-                                            field_type: enums::FieldType::UserBillingName,
-                                        },
-                                        RequiredFieldInfo {
-                                            required_field: "email".to_string(),
-                                            display_name: "email".to_string(),
-                                            field_type: enums::FieldType::UserEmailAddress,
-                                        },
-                                        RequiredFieldInfo {
-                                            required_field: "billing.address.country".to_string(),
-                                            display_name: "country".to_string(),
-                                            field_type: enums::FieldType::UserCountry {
-                                                options: vec!["US".to_string(), "IN".to_string()],
-                                            },
-                                        },
-                                    ],
+                                    enums::Connector::Stripe,
+                                    RequiredFieldFinal {
+                                        mandate: HashMap::new(),
+                                        non_mandate: HashMap::new(),
+                                        common: HashMap::new(),
+                                    }
                                 ),
                             ]),
                         },
@@ -710,65 +541,31 @@ impl Default for super::settings::RequiredFields {
                     (
                         enums::PaymentMethodType::Sofort,
                         ConnectorFields {
-                            fields: HashMap::from([(
-                                enums::Connector::Nuvei,
-                                vec![
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.first_name".to_string(),
-                                        display_name: "first_name".to_string(),
-                                        field_type: enums::FieldType::UserBillingName,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.last_name".to_string(),
-                                        display_name: "last_name".to_string(),
-                                        field_type: enums::FieldType::UserBillingName,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "email".to_string(),
-                                        display_name: "email".to_string(),
-                                        field_type: enums::FieldType::UserEmailAddress,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.country".to_string(),
-                                        display_name: "country".to_string(),
-                                        field_type: enums::FieldType::UserCountry {
-                                            options: vec!["US".to_string(), "IN".to_string()],
-                                        },
-                                    },
-                                ],
-                            )]),
+                            fields: HashMap::from([
+                                (
+                                    enums::Connector::Stripe,
+                                    RequiredFieldFinal {
+                                        mandate: HashMap::new(),
+                                        non_mandate: HashMap::new(),
+                                        common: HashMap::new(),
+                                    }
+                                ),
+                                ]),
                         },
                     ),
                     (
                         enums::PaymentMethodType::Eps,
                         ConnectorFields {
-                            fields: HashMap::from([(
-                                enums::Connector::Nuvei,
-                                vec![
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.first_name".to_string(),
-                                        display_name: "first_name".to_string(),
-                                        field_type: enums::FieldType::UserBillingName,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.last_name".to_string(),
-                                        display_name: "last_name".to_string(),
-                                        field_type: enums::FieldType::UserBillingName,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "email".to_string(),
-                                        display_name: "email".to_string(),
-                                        field_type: enums::FieldType::UserEmailAddress,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.country".to_string(),
-                                        display_name: "country".to_string(),
-                                        field_type: enums::FieldType::UserCountry {
-                                            options: vec!["US".to_string(), "IN".to_string()],
-                                        },
-                                    },
-                                ],
-                            )]),
+                            fields: HashMap::from([
+                                (
+                                    enums::Connector::Stripe,
+                                    RequiredFieldFinal {
+                                        mandate: HashMap::new(),
+                                        non_mandate: HashMap::new(),
+                                        common: HashMap::new(),
+                                    }
+                                )
+                                ]),
                         },
                     ),
                 ])),
@@ -781,100 +578,59 @@ impl Default for super::settings::RequiredFields {
                         ConnectorFields {
                             fields: HashMap::from([
                                 (
-                                    enums::Connector::Bluesnap,
-                                    vec![RequiredFieldInfo {
-                                        required_field: "billing_address".to_string(),
-                                        display_name: "billing_address".to_string(),
-                                        field_type: enums::FieldType::Text,
-                                    }],
-                                ),
-                                (
-                                    enums::Connector::Zen,
-                                    vec![RequiredFieldInfo {
-                                        required_field: "metadata.order_details".to_string(),
-                                        display_name: "order_details".to_string(),
-                                        field_type: enums::FieldType::Text,
-                                    }],
-                                ),
+                                    enums::Connector::Stripe,
+                                    RequiredFieldFinal {
+                                        mandate: HashMap::new(),
+                                        non_mandate: HashMap::new(),
+                                        common: HashMap::new(),
+                                    }
+                                )
                             ]),
                         },
                     ),
                     (
-                        enums::PaymentMethodType::Paypal,
+                        enums::PaymentMethodType::GooglePay,
                         ConnectorFields {
                             fields: HashMap::from([
                                 (
-                                    enums::Connector::Mollie,
-                                    vec![
-                                        RequiredFieldInfo {
-                                            required_field: "billing_address".to_string(),
-                                            display_name: "billing_address".to_string(),
-                                            field_type: enums::FieldType::Text,
-                                        },
-                                        RequiredFieldInfo {
-                                            required_field: "shipping_address".to_string(),
-                                            display_name: "shipping_address".to_string(),
-                                            field_type: enums::FieldType::Text,
-                                        },
-                                    ],
-                                ),
-                                (
-                                    enums::Connector::Nuvei,
-                                    vec![
-                                        RequiredFieldInfo {
-                                            required_field: "email".to_string(),
-                                            display_name: "email".to_string(),
-                                            field_type: enums::FieldType::UserEmailAddress,
-                                        },
-                                        RequiredFieldInfo {
-                                            required_field: "billing.address.country".to_string(),
-                                            display_name: "country".to_string(),
-                                            field_type: enums::FieldType::UserCountry {
-                                                options: vec!["US".to_string(), "IN".to_string()],
-                                            },
-                                        },
-                                    ],
+                                    enums::Connector::Stripe,
+                                    RequiredFieldFinal {
+                                        mandate: HashMap::new(),
+                                        non_mandate: HashMap::new(),
+                                        common: HashMap::new(),
+                                    }
                                 ),
-                            ]),
+                               ]),
                         },
                     ),
                     (
-                        enums::PaymentMethodType::GooglePay,
+                        enums::PaymentMethodType::WeChatPay,
                         ConnectorFields {
-                            fields: HashMap::from([(
-                                enums::Connector::Zen,
-                                vec![RequiredFieldInfo {
-                                    required_field: "metadata.order_details".to_string(),
-                                    display_name: "order_details".to_string(),
-                                    field_type: enums::FieldType::Text,
-                                }],
-                            )]),
+                            fields: HashMap::from([
+                                (
+                                    enums::Connector::Stripe,
+                                    RequiredFieldFinal {
+                                        mandate: HashMap::new(),
+                                        non_mandate: HashMap::new(),
+                                        common: HashMap::new(),
+                                    }
+                                ),
+                            ]),
                         },
                     ),
                     (
                         enums::PaymentMethodType::AliPay,
                         ConnectorFields {
-                            fields: HashMap::from([(
-                                enums::Connector::Globepay,
-                                vec![RequiredFieldInfo {
-                                    required_field: "description".to_string(),
-                                    display_name: "description".to_string(),
-                                    field_type: enums::FieldType::Text,
-                                }],
-                            )]),
-                        },
-                    ),
-                    (
-                        enums::PaymentMethodType::WeChatPay,
-                        ConnectorFields {
-                            fields: HashMap::from([(
-                                enums::Connector::Globepay,
-                                vec![RequiredFieldInfo {
-                                    required_field: "description".to_string(),
-                                    display_name: "description".to_string(),
-                                    field_type: enums::FieldType::Text,
-                                }],
-                            )]),
+                            fields: HashMap::from([
+                                (
+                                    enums::Connector::Stripe,
+                                    RequiredFieldFinal {
+                                        mandate: HashMap::new(),
+                                        non_mandate: HashMap::new(),
+                                        common: HashMap::new(),
+                                    }
+                                ),
+                            ]),
                         },
                     ),
                 ])),
@@ -888,205 +644,162 @@ impl Default for super::settings::RequiredFields {
                             fields: HashMap::from([
                                 (
                                     enums::Connector::Stripe,
-                                    vec![
-                                        RequiredFieldInfo {
-                                            required_field: "shipping.address.first_name"
-                                                .to_string(),
-                                            display_name: "first_name".to_string(),
-                                            field_type: enums::FieldType::Text,
-                                        },
-                                        RequiredFieldInfo {
-                                            required_field: "shipping.address.line1".to_string(),
-                                            display_name: "line1".to_string(),
-                                            field_type: enums::FieldType::Text,
-                                        },
-                                        RequiredFieldInfo {
-                                            required_field: "shipping.address.country".to_string(),
-                                            display_name: "country".to_string(),
-                                            field_type: enums::FieldType::DropDown {
-                                                options: vec!["US".to_string(), "IN".to_string()],
-                                            },
-                                        },
-                                        RequiredFieldInfo {
-                                            required_field: "shipping.address.zip".to_string(),
-                                            display_name: "zip".to_string(),
-                                            field_type: enums::FieldType::Text,
-                                        },
-                                    ],
-                                ),
-                                (
-                                    enums::Connector::Adyen,
-                                    vec![
-                                        RequiredFieldInfo {
-                                            required_field: "shipping.address.first_name"
-                                                .to_string(),
-                                            display_name: "first_name".to_string(),
-                                            field_type: enums::FieldType::Text,
-                                        },
-                                        RequiredFieldInfo {
-                                            required_field: "shipping.address.line1".to_string(),
-                                            display_name: "line1".to_string(),
-                                            field_type: enums::FieldType::Text,
-                                        },
-                                        RequiredFieldInfo {
-                                            required_field: "shipping.address.country".to_string(),
-                                            display_name: "country".to_string(),
-                                            field_type: enums::FieldType::DropDown {
-                                                options: vec!["US".to_string(), "IN".to_string()],
-                                            },
-                                        },
-                                        RequiredFieldInfo {
-                                            required_field: "shipping.address.zip".to_string(),
-                                            display_name: "zip".to_string(),
-                                            field_type: enums::FieldType::Text,
-                                        },
-                                    ],
-                                ),
-                                (
-                                    enums::Connector::Nuvei,
-                                    vec![
-                                        RequiredFieldInfo {
-                                            required_field: "billing.address.first_name"
-                                                .to_string(),
-                                            display_name: "first_name".to_string(),
-                                            field_type: enums::FieldType::UserBillingName,
-                                        },
-                                        RequiredFieldInfo {
-                                            required_field: "billing.address.last_name".to_string(),
-                                            display_name: "last_name".to_string(),
-                                            field_type: enums::FieldType::UserBillingName,
-                                        },
-                                        RequiredFieldInfo {
-                                            required_field: "email".to_string(),
-                                            display_name: "email".to_string(),
-                                            field_type: enums::FieldType::UserEmailAddress,
-                                        },
-                                        RequiredFieldInfo {
-                                            required_field: "billing.address.country".to_string(),
-                                            display_name: "country".to_string(),
-                                            field_type: enums::FieldType::UserCountry {
-                                                options: vec!["US".to_string(), "IN".to_string()],
-                                            },
-                                        },
-                                    ],
-                                ),
+                                    RequiredFieldFinal {
+                                        mandate : HashMap::new(),
+                                        non_mandate: HashMap::from([
+                                            ( "name".to_string(),
+                                                RequiredFieldInfo {
+                                                required_field: "name".to_string(),
+                                                display_name: "cust_name".to_string(),
+                                                field_type: enums::FieldType::UserFullName,
+                                                value: None,
+                                            }),
+                                            ("payment_method_data.pay_later.afterpay_clearpay_redirect.billing_email".to_string(),
+                                            RequiredFieldInfo {
+                                                required_field: "payment_method_data.pay_later.afterpay_clearpay_redirect.billing_email".to_string(),
+                                                display_name: "billing_email".to_string(),
+                                                field_type: enums::FieldType::UserEmailAddress,
+                                                value: None,
+                                           })
+                                        ]),
+                                        common : HashMap::new(),
+                                    }
+                                )
                             ]),
                         },
                     ),
                     (
                         enums::PaymentMethodType::Klarna,
                         ConnectorFields {
-                            fields: HashMap::from([(
-                                enums::Connector::Nuvei,
-                                vec![
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.first_name".to_string(),
-                                        display_name: "first_name".to_string(),
-                                        field_type: enums::FieldType::UserBillingName,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.last_name".to_string(),
-                                        display_name: "last_name".to_string(),
-                                        field_type: enums::FieldType::UserBillingName,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "email".to_string(),
-                                        display_name: "email".to_string(),
-                                        field_type: enums::FieldType::UserEmailAddress,
-                                    },
-                                    RequiredFieldInfo {
-                                        required_field: "billing.address.country".to_string(),
-                                        display_name: "country".to_string(),
-                                        field_type: enums::FieldType::UserCountry {
-                                            options: vec!["US".to_string(), "IN".to_string()],
-                                        },
-                                    },
-                                ],
-                            )]),
+                            fields: HashMap::from([
+                                (
+                                    enums::Connector::Stripe,
+                                    RequiredFieldFinal {
+                                        mandate : HashMap::new(),
+                                        non_mandate: HashMap::from([
+                                            ( "payment_method_data.pay_later.klarna.billing_country".to_string(),
+                                                RequiredFieldInfo {
+                                                required_field: "payment_method_data.pay_later.klarna.billing_country".to_string(),
+                                                display_name: "billing_name".to_string(),
+                                                field_type: enums::FieldType::UserAddressCountry,
+                                                value: None,
+                                            }),
+                                            ("email".to_string(),
+                                            RequiredFieldInfo {
+                                                required_field: "email".to_string(),
+                                                display_name: "cust_email".to_string(),
+                                                field_type: enums::FieldType::UserEmailAddress,
+                                                value: None,
+                                           })
+                                        ]),
+                                        common : HashMap::new(),
+                                    }
+                                ),
+                                ]),
+                        },
+                    ),
+                    (
+                        enums::PaymentMethodType::Affirm,
+                        ConnectorFields {
+                            fields: HashMap::from([
+                                (
+                                    enums::Connector::Stripe,
+                                    RequiredFieldFinal {
+                                        mandate: HashMap::new(),
+                                        non_mandate: HashMap::new(),
+                                        common: HashMap::new(),
+                                    }
+                                ),
+                            ]),
                         },
                     ),
                 ])),
             ),
-            (
-                enums::PaymentMethod::Crypto,
-                PaymentMethodType(HashMap::from([(
-                    enums::PaymentMethodType::CryptoCurrency,
-                    ConnectorFields {
-                        fields: HashMap::from([(
-                            enums::Connector::Cryptopay,
-                            vec![RequiredFieldInfo {
-                                required_field: "payment_method_data.crypto.pay_currency".to_string(),
-                                display_name: "currency".to_string(),
-                                field_type: enums::FieldType::DropDown {
-                                    options: vec![
-                                        "BTC".to_string(),
-                                        "LTC".to_string(),
-                                        "ETH".to_string(),
-                                        "XRP".to_string(),
-                                        "XLM".to_string(),
-                                        "BCH".to_string(),
-                                        "ADA".to_string(),
-                                        "SOL".to_string(),
-                                        "SHIB".to_string(),
-                                        "TRX".to_string(),
-                                        "DOGE".to_string(),
-                                        "BNB".to_string(),
-                                        "BUSD".to_string(),
-                                        "USDT".to_string(),
-                                        "USDC".to_string(),
-                                        "DAI".to_string(),
-                                    ],
-                                },
-                            }],
-                        )]),
-                    },
-                )])),
-            ),
             (
                 enums::PaymentMethod::BankDebit,
                 PaymentMethodType(HashMap::from([(
                     enums::PaymentMethodType::Ach,
                     ConnectorFields {
-                        fields: HashMap::from([
-                            (
-                                enums::Connector::Adyen,
-                                vec![RequiredFieldInfo {
-                                    required_field: "card_holder_name".to_string(),
-                                    display_name: "card_holder_name".to_string(),
-                                    field_type: enums::FieldType::UserFullName,
-                                }],
-                            ),
-                        ]),
-                    },
-                ),
+                            fields: HashMap::from([
+                                (
+                                    enums::Connector::Stripe,
+                                    RequiredFieldFinal {
+                                        mandate: HashMap::new(),
+                                        non_mandate: HashMap::new(),
+                                        common: HashMap::new(),
+                                    })]
+                                )}
+                    ),
                 (
                         enums::PaymentMethodType::Sepa,
                         ConnectorFields {
-                            fields: HashMap::from([(
-                                enums::Connector::Adyen,
-                                vec![RequiredFieldInfo {
-                                    required_field: "payment_method_data.bank_debit.sepa_bank_debit.bank_account_holder_name".to_string(),
-                                    display_name: "bank_account_holder_name".to_string(),
-                                    field_type: enums::FieldType::UserFullName,
-                                }],
-                            )]),
+                            fields: HashMap::from([
+                                (
+                                    enums::Connector::Stripe,
+                                    RequiredFieldFinal {
+                                        mandate: HashMap::new(),
+                                        non_mandate: HashMap::new(),
+                                        common: HashMap::new(),
+                                    }
+                                ),
+                               ]),
                         },
                     ),
                     (
                         enums::PaymentMethodType::Bacs,
                         ConnectorFields {
-                            fields: HashMap::from([(
-                                enums::Connector::Adyen,
-                                vec![RequiredFieldInfo {
-                                    required_field: "payment_method_data.bank_debit.bacs_bank_debit.bank_account_holder_name".to_string(),
-                                    display_name: "bank_account_holder_name".to_string(),
-                                    field_type: enums::FieldType::UserFullName,
-                                }],
-                            )]),
+                            fields: HashMap::from([
+                                (
+                                    enums::Connector::Stripe,
+                                    RequiredFieldFinal {
+                                        mandate: HashMap::new(),
+                                        non_mandate: HashMap::new(),
+                                        common: HashMap::new(),
+                                    }
+                                ),
+                                ]),
                         },
-                    ),
-                ])),
-            ),
+                    )]))),
+                    (
+                        enums::PaymentMethod::BankTransfer,
+                        PaymentMethodType(HashMap::from([(
+                            enums::PaymentMethodType::Multibanco,
+                            ConnectorFields {
+                                fields: HashMap::from([
+                                    (
+                                        enums::Connector::Stripe,
+                                        RequiredFieldFinal {
+                                            mandate: HashMap::new(),
+                                            non_mandate: HashMap::new(),
+                                            common: HashMap::new(),
+                                        }
+                                    ),
+                                ])}),
+                                (enums::PaymentMethodType::Multibanco,
+                            ConnectorFields {
+                                fields: HashMap::from([
+                                    (
+                                        enums::Connector::Stripe,
+                                        RequiredFieldFinal {
+                                            mandate: HashMap::new(),
+                                            non_mandate: HashMap::new(),
+                                            common: HashMap::new(),
+                                        }
+                                    ),
+                                ])}),
+                                (enums::PaymentMethodType::Ach,
+                            ConnectorFields {
+                                fields: HashMap::from([
+                                    (
+                                        enums::Connector::Stripe,
+                                        RequiredFieldFinal {
+                                            mandate: HashMap::new(),
+                                            non_mandate: HashMap::new(),
+                                            common: HashMap::new(),
+                                        }
+                                    ),
+                                ])}),
+                                ])))
         ]))
     }
 }
diff --git a/crates/router/src/configs/settings.rs b/crates/router/src/configs/settings.rs
index cffbfe562d9..564650b871f 100644
--- a/crates/router/src/configs/settings.rs
+++ b/crates/router/src/configs/settings.rs
@@ -276,7 +276,14 @@ pub struct PaymentMethodType(pub HashMap<enums::PaymentMethodType, ConnectorFiel
 
 #[derive(Debug, Deserialize, Clone)]
 pub struct ConnectorFields {
-    pub fields: HashMap<enums::Connector, Vec<RequiredFieldInfo>>,
+    pub fields: HashMap<enums::Connector, RequiredFieldFinal>,
+}
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct RequiredFieldFinal {
+    pub mandate: HashMap<String, RequiredFieldInfo>,
+    pub non_mandate: HashMap<String, RequiredFieldInfo>,
+    pub common: HashMap<String, RequiredFieldInfo>,
 }
 
 fn string_set_deser<'a, D>(
diff --git a/crates/router/src/core/payment_methods/cards.rs b/crates/router/src/core/payment_methods/cards.rs
index 00a647ed5c9..8b7db2d6c88 100644
--- a/crates/router/src/core/payment_methods/cards.rs
+++ b/crates/router/src/core/payment_methods/cards.rs
@@ -48,7 +48,7 @@ use crate::{
         api::{self, PaymentMethodCreateExt},
         domain::{self, types::decrypt},
         storage::{self, enums},
-        transformers::ForeignInto,
+        transformers::{ForeignFrom, ForeignInto},
     },
     utils::{self, ConnectorResponseExt, OptionExt},
 };
@@ -727,6 +727,13 @@ pub fn get_banks(
     }
 }
 
+fn get_val(str: String, val: &serde_json::Value) -> Option<String> {
+    str.split('.')
+        .fold(Some(val), |acc, x| acc.and_then(|v| v.get(x)))
+        .and_then(|v| v.as_str())
+        .map(|s| s.to_string())
+}
+
 pub async fn list_payment_methods(
     state: &routes::AppState,
     merchant_account: domain::MerchantAccount,
@@ -743,7 +750,7 @@ pub async fn list_payment_methods(
     )
     .await?;
 
-    let address = payment_intent
+    let shipping_address = payment_intent
         .as_ref()
         .async_map(|pi| async {
             helpers::get_address_by_id(db, pi.shipping_address_id.clone(), &key_store).await
@@ -752,6 +759,34 @@ pub async fn list_payment_methods(
         .transpose()?
         .flatten();
 
+    let billing_address = payment_intent
+        .as_ref()
+        .async_map(|pi| async {
+            helpers::get_address_by_id(db, pi.billing_address_id.clone(), &key_store).await
+        })
+        .await
+        .transpose()?
+        .flatten();
+
+    let customer = payment_intent
+        .as_ref()
+        .async_and_then(|pi| async {
+            pi.customer_id
+                .as_ref()
+                .async_and_then(|cust| async {
+                    db.find_customer_by_customer_id_merchant_id(
+                        cust.as_str(),
+                        &pi.merchant_id,
+                        &key_store,
+                    )
+                    .await
+                    .to_not_found_response(errors::ApiErrorResponse::CustomerNotFound)
+                    .ok()
+                })
+                .await
+        })
+        .await;
+
     let payment_attempt = payment_intent
         .as_ref()
         .async_map(|pi| async {
@@ -795,7 +830,7 @@ pub async fn list_payment_methods(
             &mut response,
             payment_intent.as_ref(),
             payment_attempt.as_ref(),
-            address.as_ref(),
+            shipping_address.as_ref(),
             mca.connector_name,
             pm_config_mapping,
             &state.conf.mandates.supported_payment_methods,
@@ -803,6 +838,13 @@ pub async fn list_payment_methods(
         .await?;
     }
 
+    let req = api_models::payments::PaymentsRequest::foreign_from((
+        payment_attempt.as_ref(),
+        shipping_address.as_ref(),
+        billing_address.as_ref(),
+        customer.as_ref(),
+    ));
+    let req_val = serde_json::to_value(req).ok();
     logger::debug!(filtered_payment_methods=?response);
 
     let mut payment_experiences_consolidated_hm: HashMap<
@@ -826,7 +868,7 @@ pub async fn list_payment_methods(
 
     let mut required_fields_hm = HashMap::<
         api_enums::PaymentMethod,
-        HashMap<api_enums::PaymentMethodType, HashSet<RequiredFieldInfo>>,
+        HashMap<api_enums::PaymentMethodType, HashMap<String, RequiredFieldInfo>>,
     >::new();
 
     for element in response.clone() {
@@ -853,15 +895,34 @@ pub async fn list_payment_methods(
                         required_fields_hm_for_each_connector
                             .fields
                             .get(&connector_variant)
-                            .map(|required_fields_vec| {
-                                // If payment_method_type already exist in required_fields_hm, extend the required_fields hs to existing hs.
-                                let required_fields_hs =
-                                    HashSet::from_iter(required_fields_vec.iter().cloned());
+                            .map(|required_fields_final| {
+                                let mut required_fields_hs = required_fields_final.common.clone();
+                                if let Some(pa) = payment_attempt.as_ref() {
+                                    if let Some(_mandate) = &pa.mandate_details {
+                                        required_fields_hs
+                                            .extend(required_fields_final.mandate.clone());
+                                    } else {
+                                        required_fields_hs
+                                            .extend(required_fields_final.non_mandate.clone());
+                                    }
+                                }
+
+                                {
+                                    for (key, val) in &mut required_fields_hs {
+                                        let temp = req_val
+                                            .as_ref()
+                                            .and_then(|r| get_val(key.to_owned(), r));
+                                        if let Some(s) = temp {
+                                            val.value = Some(s)
+                                        };
+                                    }
+                                }
 
                                 let existing_req_fields_hs = required_fields_hm
                                     .get_mut(&payment_method)
                                     .and_then(|inner_hm| inner_hm.get_mut(&payment_method_type));
 
+                                // If payment_method_type already exist in required_fields_hm, extend the required_fields hs to existing hs.
                                 if let Some(inner_hs) = existing_req_fields_hs {
                                     inner_hs.extend(required_fields_hs);
                                 } else {
diff --git a/crates/router/src/types/transformers.rs b/crates/router/src/types/transformers.rs
index 16025e1bc26..b4d0b1298b9 100644
--- a/crates/router/src/types/transformers.rs
+++ b/crates/router/src/types/transformers.rs
@@ -1,5 +1,5 @@
 use api_models::enums as api_enums;
-use common_utils::{crypto::Encryptable, ext_traits::ValueExt};
+use common_utils::{crypto::Encryptable, ext_traits::ValueExt, pii};
 use diesel_models::enums as storage_enums;
 use error_stack::ResultExt;
 use masking::{ExposeInterface, PeekInterface};
@@ -573,3 +573,34 @@ impl ForeignFrom<api_models::enums::PayoutType> for api_enums::PaymentMethod {
         }
     }
 }
+
+impl
+    ForeignFrom<(
+        Option<&storage::PaymentAttempt>,
+        Option<&domain::Address>,
+        Option<&domain::Address>,
+        Option<&domain::Customer>,
+    )> for api_models::payments::PaymentsRequest
+{
+    fn foreign_from(
+        value: (
+            Option<&storage::PaymentAttempt>,
+            Option<&domain::Address>,
+            Option<&domain::Address>,
+            Option<&domain::Customer>,
+        ),
+    ) -> Self {
+        let (payment_attempt, shipping, billing, customer) = value;
+        Self {
+            currency: payment_attempt.map(|pa| pa.currency.unwrap_or_default()),
+            shipping: shipping.map(api_types::Address::from),
+            billing: billing.map(api_types::Address::from),
+            amount: payment_attempt.map(|pa| api_types::Amount::from(pa.amount)),
+            email: customer
+                .and_then(|cust| cust.email.as_ref().map(|em| pii::Email::from(em.clone()))),
+            phone: customer.and_then(|cust| cust.phone.as_ref().map(|p| p.clone().into_inner())),
+            name: customer.and_then(|cust| cust.name.as_ref().map(|n| n.clone().into_inner())),
+            ..Self::default()
+        }
+    }
+}
diff --git a/openapi/openapi_spec.json b/openapi/openapi_spec.json
index 7c7fe43784b..9249db6246c 100644
--- a/openapi/openapi_spec.json
+++ b/openapi/openapi_spec.json
@@ -9510,6 +9510,10 @@
           },
           "field_type": {
             "$ref": "#/components/schemas/FieldType"
+          },
+          "value": {
+            "type": "string",
+            "nullable": true
           }
         }
       },

## Type of Change
<!-- Put an `x` in the boxes that apply -->

- [ ] Bugfix
- [x] New feature
- [ ] Enhancement
- [ ] Refactoring
- [ ] Dependency updates
- [ ] Documentation
- [ ] CI/CD

## Description
<!-- Describe your changes in detail -->
Refactored Required Fields for PM List API. It is now a HashMap instead of a vector.
Have added backend logic to segregate required fields into mandate/non-mandate fields and unify them later on.
Also, refactored the Required Fields to include the value field which could be used for pre-filling.


### Additional Changes

- [ ] This PR modifies the API contract
- [ ] This PR modifies the database schema
- [ ] This PR modifies application configuration/environment variables

<!--
Provide links to the files with corresponding changes.

Following are the paths where you can find config files:
1. `config`
2. `crates/router/src/configs`
3. `loadtest/config`
-->


## Motivation and Context
<!--
Why is this change required? What problem does it solve?
If it fixes an open issue, please link to the issue here.

If you don't have an issue, we'd recommend starting with one first so the PR
can focus on the implementation (unless its an obvious bug or documentation fix
that will have little conversation).
-->


## How did you test it?
<!--
Did you write an integration/unit/API test to verify the code changes?
Or did you test this change manually (provide relevant screenshots)?
-->
<img width="1512" alt="image" src="https://github.com/juspay/hyperswitch/assets/76486416/82d8c544-ea62-4461-9af7-123baa1cd1ef">
<img width="1512" alt="image" src="https://github.com/juspay/hyperswitch/assets/76486416/2bf8ad22-a37d-496d-a48f-0b7149502aba">



## Checklist
<!-- Put an `x` in the boxes that apply -->

- [x] I formatted the code `cargo +nightly fmt --all`
- [x] I addressed lints thrown by `cargo clippy`
- [x] I reviewed submitted code
- [ ] I added unit tests for my changes where possible
- [ ] I added a [CHANGELOG](/CHANGELOG.md) entry if applicable
