feat(connector): [FISERV] Added PayPal Redirect Payment Method (#8669)

Co-authored-by: Sayak Bhattacharya <sayak.b@Sayak-Bhattacharya-G092THXJ34.local>

config/config.example.toml

@@ -884,6 +884,7 @@ apple_pay = { country = "EG, MA, ZA, AU, HK, JP, MO, MY, MN, NZ, SG, KR, TW, VN,
 [pm_filters.fiserv]
 credit = {country = "AU,NZ,CN,HK,IN,LK,KR,MY,SG,GB,BE,FR,DE,IT,ME,NL,PL,ES,ZA,AR,BR,CO,MX,PA,UY,US,CA", currency = "AFN,ALL,DZD,AOA,ARS,AMD,AWG,AUD,AZN,BSD,BHD,BDT,BBD,BYN,BZD,BMD,BTN,BOB,VES,BAM,BWP,BRL,BND,BGN,BIF,KHR,CAD,CVE,KYD,XAF,CLP,CNY,COP,KMF,CDF,CRC,HRK,CUP,CZK,DKK,DJF,DOP,XCD,EGP,ERN,ETB,EUR,FKP,FJD,XPF,GMD,GEL,GHS,GIP,GTQ,GNF,GYD,HTG,HNL,HKD,HUF,ISK,INR,IDR,IRR,IQD,ILS,JMD,JPY,JOD,KZT,KES,KGS,KWD,LAK,LBP,LSL,LRD,LYD,MOP,MKD,MGA,MWK,MYR,MVR,MRU,MUR,MXN,MDL,MNT,MAD,MZN,MMK,NAD,NPR,ANG,NZD,NIO,NGN,VUV,KPW,NOK,OMR,PKR,PAB,PGK,PYG,PEN,PHP,PLN,GBP,QAR,RON,RUB,RWF,SHP,SVC,WST,STN,SAR,RSD,SCR,SLL,SGD,SBD,SOS,ZAR,KRW,SSP,LKR,SDG,SRD,SZL,SEK,CHF,SYP,TWD,TJS,TZS,THB,TOP,TTD,TND,TRY,TMT,UGX,UAH,AED,USD,UYU,UZS,VND,XOF,YER,ZMW,ZWL"}
 debit = {country = "AU,NZ,CN,HK,IN,LK,KR,MY,SG,GB,BE,FR,DE,IT,ME,NL,PL,ES,ZA,AR,BR,CO,MX,PA,UY,US,CA", currency = "AFN,ALL,DZD,AOA,ARS,AMD,AWG,AUD,AZN,BSD,BHD,BDT,BBD,BYN,BZD,BMD,BTN,BOB,VES,BAM,BWP,BRL,BND,BGN,BIF,KHR,CAD,CVE,KYD,XAF,CLP,CNY,COP,KMF,CDF,CRC,HRK,CUP,CZK,DKK,DJF,DOP,XCD,EGP,ERN,ETB,EUR,FKP,FJD,XPF,GMD,GEL,GHS,GIP,GTQ,GNF,GYD,HTG,HNL,HKD,HUF,ISK,INR,IDR,IRR,IQD,ILS,JMD,JPY,JOD,KZT,KES,KGS,KWD,LAK,LBP,LSL,LRD,LYD,MOP,MKD,MGA,MWK,MYR,MVR,MRU,MUR,MXN,MDL,MNT,MAD,MZN,MMK,NAD,NPR,ANG,NZD,NIO,NGN,VUV,KPW,NOK,OMR,PKR,PAB,PGK,PYG,PEN,PHP,PLN,GBP,QAR,RON,RUB,RWF,SHP,SVC,WST,STN,SAR,RSD,SCR,SLL,SGD,SBD,SOS,ZAR,KRW,SSP,LKR,SDG,SRD,SZL,SEK,CHF,SYP,TWD,TJS,TZS,THB,TOP,TTD,TND,TRY,TMT,UGX,UAH,AED,USD,UYU,UZS,VND,XOF,YER,ZMW,ZWL"}
+paypal = { currency = "AUD,EUR,BRL,CAD,CNY,EUR,EUR,EUR,GBP,HKD,INR,EUR,JPY,MYR,EUR,NZD,PHP,PLN,SGD,USD", country = "AU, BE, BR, CA, CN, DE, ES, FR, GB, HK, IN, IT, JP, MY, NL, NZ, PH, PL, SG, US" }
 google_pay = { country = "AU,AT,BE,BR,CA,CN,HK,MY,NZ,SG,US", currency = "AUD,EUR,EUR,BRL,CAD,CNY,HKD,MYR,NZD,SGD,USD" }
 
 [pm_filters.santander]

config/deployments/integration_test.toml

@@ -744,6 +744,7 @@ apple_pay = { country = "EG, MA, ZA, AU, HK, JP, MO, MY, MN, NZ, SG, KR, TW, VN,
 [pm_filters.fiserv]
 credit = {country = "AU,NZ,CN,HK,IN,LK,KR,MY,SG,GB,BE,FR,DE,IT,ME,NL,PL,ES,ZA,AR,BR,CO,MX,PA,UY,US,CA", currency = "AFN,ALL,DZD,AOA,ARS,AMD,AWG,AUD,AZN,BSD,BHD,BDT,BBD,BYN,BZD,BMD,BTN,BOB,VES,BAM,BWP,BRL,BND,BGN,BIF,KHR,CAD,CVE,KYD,XAF,CLP,CNY,COP,KMF,CDF,CRC,HRK,CUP,CZK,DKK,DJF,DOP,XCD,EGP,ERN,ETB,EUR,FKP,FJD,XPF,GMD,GEL,GHS,GIP,GTQ,GNF,GYD,HTG,HNL,HKD,HUF,ISK,INR,IDR,IRR,IQD,ILS,JMD,JPY,JOD,KZT,KES,KGS,KWD,LAK,LBP,LSL,LRD,LYD,MOP,MKD,MGA,MWK,MYR,MVR,MRU,MUR,MXN,MDL,MNT,MAD,MZN,MMK,NAD,NPR,ANG,NZD,NIO,NGN,VUV,KPW,NOK,OMR,PKR,PAB,PGK,PYG,PEN,PHP,PLN,GBP,QAR,RON,RUB,RWF,SHP,SVC,WST,STN,SAR,RSD,SCR,SLL,SGD,SBD,SOS,ZAR,KRW,SSP,LKR,SDG,SRD,SZL,SEK,CHF,SYP,TWD,TJS,TZS,THB,TOP,TTD,TND,TRY,TMT,UGX,UAH,AED,USD,UYU,UZS,VND,XOF,YER,ZMW,ZWL"}
 debit = {country = "AU,NZ,CN,HK,IN,LK,KR,MY,SG,GB,BE,FR,DE,IT,ME,NL,PL,ES,ZA,AR,BR,CO,MX,PA,UY,US,CA", currency = "AFN,ALL,DZD,AOA,ARS,AMD,AWG,AUD,AZN,BSD,BHD,BDT,BBD,BYN,BZD,BMD,BTN,BOB,VES,BAM,BWP,BRL,BND,BGN,BIF,KHR,CAD,CVE,KYD,XAF,CLP,CNY,COP,KMF,CDF,CRC,HRK,CUP,CZK,DKK,DJF,DOP,XCD,EGP,ERN,ETB,EUR,FKP,FJD,XPF,GMD,GEL,GHS,GIP,GTQ,GNF,GYD,HTG,HNL,HKD,HUF,ISK,INR,IDR,IRR,IQD,ILS,JMD,JPY,JOD,KZT,KES,KGS,KWD,LAK,LBP,LSL,LRD,LYD,MOP,MKD,MGA,MWK,MYR,MVR,MRU,MUR,MXN,MDL,MNT,MAD,MZN,MMK,NAD,NPR,ANG,NZD,NIO,NGN,VUV,KPW,NOK,OMR,PKR,PAB,PGK,PYG,PEN,PHP,PLN,GBP,QAR,RON,RUB,RWF,SHP,SVC,WST,STN,SAR,RSD,SCR,SLL,SGD,SBD,SOS,ZAR,KRW,SSP,LKR,SDG,SRD,SZL,SEK,CHF,SYP,TWD,TJS,TZS,THB,TOP,TTD,TND,TRY,TMT,UGX,UAH,AED,USD,UYU,UZS,VND,XOF,YER,ZMW,ZWL"}
+paypal = { currency = "AUD,EUR,BRL,CAD,CNY,EUR,EUR,EUR,GBP,HKD,INR,EUR,JPY,MYR,EUR,NZD,PHP,PLN,SGD,USD", country = "AU, BE, BR, CA, CN, DE, ES, FR, GB, HK, IN, IT, JP, MY, NL, NZ, PH, PL, SG, US" }
 google_pay = { country = "AU,AT,BE,BR,CA,CN,HK,MY,NZ,SG,US", currency = "AUD,EUR,EUR,BRL,CAD,CNY,HKD,MYR,NZD,SGD,USD" }
 
 [pm_filters.coingate]

config/deployments/production.toml

@@ -728,6 +728,7 @@ sepa = { country = "ES", currency = "EUR"}
 [pm_filters.fiserv]
 credit = {country = "AU,NZ,CN,HK,IN,LK,KR,MY,SG,GB,BE,FR,DE,IT,ME,NL,PL,ES,ZA,AR,BR,CO,MX,PA,UY,US,CA", currency = "AFN,ALL,DZD,AOA,ARS,AMD,AWG,AUD,AZN,BSD,BHD,BDT,BBD,BYN,BZD,BMD,BTN,BOB,VES,BAM,BWP,BRL,BND,BGN,BIF,KHR,CAD,CVE,KYD,XAF,CLP,CNY,COP,KMF,CDF,CRC,HRK,CUP,CZK,DKK,DJF,DOP,XCD,EGP,ERN,ETB,EUR,FKP,FJD,XPF,GMD,GEL,GHS,GIP,GTQ,GNF,GYD,HTG,HNL,HKD,HUF,ISK,INR,IDR,IRR,IQD,ILS,JMD,JPY,JOD,KZT,KES,KGS,KWD,LAK,LBP,LSL,LRD,LYD,MOP,MKD,MGA,MWK,MYR,MVR,MRU,MUR,MXN,MDL,MNT,MAD,MZN,MMK,NAD,NPR,ANG,NZD,NIO,NGN,VUV,KPW,NOK,OMR,PKR,PAB,PGK,PYG,PEN,PHP,PLN,GBP,QAR,RON,RUB,RWF,SHP,SVC,WST,STN,SAR,RSD,SCR,SLL,SGD,SBD,SOS,ZAR,KRW,SSP,LKR,SDG,SRD,SZL,SEK,CHF,SYP,TWD,TJS,TZS,THB,TOP,TTD,TND,TRY,TMT,UGX,UAH,AED,USD,UYU,UZS,VND,XOF,YER,ZMW,ZWL"}
 debit = {country = "AU,NZ,CN,HK,IN,LK,KR,MY,SG,GB,BE,FR,DE,IT,ME,NL,PL,ES,ZA,AR,BR,CO,MX,PA,UY,US,CA", currency = "AFN,ALL,DZD,AOA,ARS,AMD,AWG,AUD,AZN,BSD,BHD,BDT,BBD,BYN,BZD,BMD,BTN,BOB,VES,BAM,BWP,BRL,BND,BGN,BIF,KHR,CAD,CVE,KYD,XAF,CLP,CNY,COP,KMF,CDF,CRC,HRK,CUP,CZK,DKK,DJF,DOP,XCD,EGP,ERN,ETB,EUR,FKP,FJD,XPF,GMD,GEL,GHS,GIP,GTQ,GNF,GYD,HTG,HNL,HKD,HUF,ISK,INR,IDR,IRR,IQD,ILS,JMD,JPY,JOD,KZT,KES,KGS,KWD,LAK,LBP,LSL,LRD,LYD,MOP,MKD,MGA,MWK,MYR,MVR,MRU,MUR,MXN,MDL,MNT,MAD,MZN,MMK,NAD,NPR,ANG,NZD,NIO,NGN,VUV,KPW,NOK,OMR,PKR,PAB,PGK,PYG,PEN,PHP,PLN,GBP,QAR,RON,RUB,RWF,SHP,SVC,WST,STN,SAR,RSD,SCR,SLL,SGD,SBD,SOS,ZAR,KRW,SSP,LKR,SDG,SRD,SZL,SEK,CHF,SYP,TWD,TJS,TZS,THB,TOP,TTD,TND,TRY,TMT,UGX,UAH,AED,USD,UYU,UZS,VND,XOF,YER,ZMW,ZWL"}
+paypal = { currency = "AUD,EUR,BRL,CAD,CNY,EUR,EUR,EUR,GBP,HKD,INR,EUR,JPY,MYR,EUR,NZD,PHP,PLN,SGD,USD", country = "AU, BE, BR, CA, CN, DE, ES, FR, GB, HK, IN, IT, JP, MY, NL, NZ, PH, PL, SG, US" }
 google_pay = { country = "AU,AT,BE,BR,CA,CN,HK,MY,NZ,SG,US", currency = "AUD,EUR,EUR,BRL,CAD,CNY,HKD,MYR,NZD,SGD,USD" }
 
 [pm_filters.placetopay]

config/deployments/sandbox.toml

@@ -692,6 +692,7 @@ sepa = { country = "ES", currency = "EUR"}
 [pm_filters.fiserv]
 credit = {country = "AU,NZ,CN,HK,IN,LK,KR,MY,SG,GB,BE,FR,DE,IT,ME,NL,PL,ES,ZA,AR,BR,CO,MX,PA,UY,US,CA", currency = "AFN,ALL,DZD,AOA,ARS,AMD,AWG,AUD,AZN,BSD,BHD,BDT,BBD,BYN,BZD,BMD,BTN,BOB,VES,BAM,BWP,BRL,BND,BGN,BIF,KHR,CAD,CVE,KYD,XAF,CLP,CNY,COP,KMF,CDF,CRC,HRK,CUP,CZK,DKK,DJF,DOP,XCD,EGP,ERN,ETB,EUR,FKP,FJD,XPF,GMD,GEL,GHS,GIP,GTQ,GNF,GYD,HTG,HNL,HKD,HUF,ISK,INR,IDR,IRR,IQD,ILS,JMD,JPY,JOD,KZT,KES,KGS,KWD,LAK,LBP,LSL,LRD,LYD,MOP,MKD,MGA,MWK,MYR,MVR,MRU,MUR,MXN,MDL,MNT,MAD,MZN,MMK,NAD,NPR,ANG,NZD,NIO,NGN,VUV,KPW,NOK,OMR,PKR,PAB,PGK,PYG,PEN,PHP,PLN,GBP,QAR,RON,RUB,RWF,SHP,SVC,WST,STN,SAR,RSD,SCR,SLL,SGD,SBD,SOS,ZAR,KRW,SSP,LKR,SDG,SRD,SZL,SEK,CHF,SYP,TWD,TJS,TZS,THB,TOP,TTD,TND,TRY,TMT,UGX,UAH,AED,USD,UYU,UZS,VND,XOF,YER,ZMW,ZWL"}
 debit = {country = "AU,NZ,CN,HK,IN,LK,KR,MY,SG,GB,BE,FR,DE,IT,ME,NL,PL,ES,ZA,AR,BR,CO,MX,PA,UY,US,CA", currency = "AFN,ALL,DZD,AOA,ARS,AMD,AWG,AUD,AZN,BSD,BHD,BDT,BBD,BYN,BZD,BMD,BTN,BOB,VES,BAM,BWP,BRL,BND,BGN,BIF,KHR,CAD,CVE,KYD,XAF,CLP,CNY,COP,KMF,CDF,CRC,HRK,CUP,CZK,DKK,DJF,DOP,XCD,EGP,ERN,ETB,EUR,FKP,FJD,XPF,GMD,GEL,GHS,GIP,GTQ,GNF,GYD,HTG,HNL,HKD,HUF,ISK,INR,IDR,IRR,IQD,ILS,JMD,JPY,JOD,KZT,KES,KGS,KWD,LAK,LBP,LSL,LRD,LYD,MOP,MKD,MGA,MWK,MYR,MVR,MRU,MUR,MXN,MDL,MNT,MAD,MZN,MMK,NAD,NPR,ANG,NZD,NIO,NGN,VUV,KPW,NOK,OMR,PKR,PAB,PGK,PYG,PEN,PHP,PLN,GBP,QAR,RON,RUB,RWF,SHP,SVC,WST,STN,SAR,RSD,SCR,SLL,SGD,SBD,SOS,ZAR,KRW,SSP,LKR,SDG,SRD,SZL,SEK,CHF,SYP,TWD,TJS,TZS,THB,TOP,TTD,TND,TRY,TMT,UGX,UAH,AED,USD,UYU,UZS,VND,XOF,YER,ZMW,ZWL"}
+paypal = { currency = "AUD,EUR,BRL,CAD,CNY,EUR,EUR,EUR,GBP,HKD,INR,EUR,JPY,MYR,EUR,NZD,PHP,PLN,SGD,USD", country = "AU, BE, BR, CA, CN, DE, ES, FR, GB, HK, IN, IT, JP, MY, NL, NZ, PH, PL, SG, US" }
 google_pay = { country = "AU,AT,BE,BR,CA,CN,HK,MY,NZ,SG,US", currency = "AUD,EUR,EUR,BRL,CAD,CNY,HKD,MYR,NZD,SGD,USD" }
 
 [payout_method_filters.adyenplatform]

config/development.toml

@@ -862,9 +862,9 @@ apple_pay = { country = "EG, MA, ZA, AU, HK, JP, MO, MY, MN, NZ, SG, KR, TW, VN,
 [pm_filters.fiserv]
 credit = {country = "AU,NZ,CN,HK,IN,LK,KR,MY,SG,GB,BE,FR,DE,IT,ME,NL,PL,ES,ZA,AR,BR,CO,MX,PA,UY,US,CA", currency = "AFN,ALL,DZD,AOA,ARS,AMD,AWG,AUD,AZN,BSD,BHD,BDT,BBD,BYN,BZD,BMD,BTN,BOB,VES,BAM,BWP,BRL,BND,BGN,BIF,KHR,CAD,CVE,KYD,XAF,CLP,CNY,COP,KMF,CDF,CRC,HRK,CUP,CZK,DKK,DJF,DOP,XCD,EGP,ERN,ETB,EUR,FKP,FJD,XPF,GMD,GEL,GHS,GIP,GTQ,GNF,GYD,HTG,HNL,HKD,HUF,ISK,INR,IDR,IRR,IQD,ILS,JMD,JPY,JOD,KZT,KES,KGS,KWD,LAK,LBP,LSL,LRD,LYD,MOP,MKD,MGA,MWK,MYR,MVR,MRU,MUR,MXN,MDL,MNT,MAD,MZN,MMK,NAD,NPR,ANG,NZD,NIO,NGN,VUV,KPW,NOK,OMR,PKR,PAB,PGK,PYG,PEN,PHP,PLN,GBP,QAR,RON,RUB,RWF,SHP,SVC,WST,STN,SAR,RSD,SCR,SLL,SGD,SBD,SOS,ZAR,KRW,SSP,LKR,SDG,SRD,SZL,SEK,CHF,SYP,TWD,TJS,TZS,THB,TOP,TTD,TND,TRY,TMT,UGX,UAH,AED,USD,UYU,UZS,VND,XOF,YER,ZMW,ZWL"}
 debit = {country = "AU,NZ,CN,HK,IN,LK,KR,MY,SG,GB,BE,FR,DE,IT,ME,NL,PL,ES,ZA,AR,BR,CO,MX,PA,UY,US,CA", currency = "AFN,ALL,DZD,AOA,ARS,AMD,AWG,AUD,AZN,BSD,BHD,BDT,BBD,BYN,BZD,BMD,BTN,BOB,VES,BAM,BWP,BRL,BND,BGN,BIF,KHR,CAD,CVE,KYD,XAF,CLP,CNY,COP,KMF,CDF,CRC,HRK,CUP,CZK,DKK,DJF,DOP,XCD,EGP,ERN,ETB,EUR,FKP,FJD,XPF,GMD,GEL,GHS,GIP,GTQ,GNF,GYD,HTG,HNL,HKD,HUF,ISK,INR,IDR,IRR,IQD,ILS,JMD,JPY,JOD,KZT,KES,KGS,KWD,LAK,LBP,LSL,LRD,LYD,MOP,MKD,MGA,MWK,MYR,MVR,MRU,MUR,MXN,MDL,MNT,MAD,MZN,MMK,NAD,NPR,ANG,NZD,NIO,NGN,VUV,KPW,NOK,OMR,PKR,PAB,PGK,PYG,PEN,PHP,PLN,GBP,QAR,RON,RUB,RWF,SHP,SVC,WST,STN,SAR,RSD,SCR,SLL,SGD,SBD,SOS,ZAR,KRW,SSP,LKR,SDG,SRD,SZL,SEK,CHF,SYP,TWD,TJS,TZS,THB,TOP,TTD,TND,TRY,TMT,UGX,UAH,AED,USD,UYU,UZS,VND,XOF,YER,ZMW,ZWL"}
+paypal = { currency = "AUD,EUR,BRL,CAD,CNY,EUR,EUR,EUR,GBP,HKD,INR,EUR,JPY,MYR,EUR,NZD,PHP,PLN,SGD,USD", country = "AU, BE, BR, CA, CN, DE, ES, FR, GB, HK, IN, IT, JP, MY, NL, NZ, PH, PL, SG, US" }
 google_pay = { country = "AU,AT,BE,BR,CA,CN,HK,MY,NZ,SG,US", currency = "AUD,EUR,EUR,BRL,CAD,CNY,HKD,MYR,NZD,SGD,USD" }
 
-
 [pm_filters.rapyd]
 apple_pay = { country = "BR, CA, CL, CO, DO, SV, MX, PE, PT, US, AT, BE, BG, HR, CY, CZ, DO, DK, EE, FI, FR, GE, DE, GR, GL, HU, IS, IE, IL, IT, LV, LI, LT, LU, MT, MD, MC, ME, NL, NO, PL, RO, SM, SK, SI, ZA, ES, SE, CH, GB, VA, AU, HK, JP, MY, NZ, SG, KR, TW, VN", currency = "AMD, AUD, BGN, BRL, BYN, CAD, CHF, CLP, CNY, COP, CRC, CZK, DKK, DOP, EUR, GBP, GEL, GTQ, HUF, ISK, JPY, KRW, MDL, MXN, MYR, NOK, PAB, PEN, PLN, PYG, RON, RSD, SEK, SGD, TWD, UAH, USD, UYU, VND, ZAR" }
 google_pay = { country = "BR, CA, CL, CO, DO, MX, PE, PT, US, AT, BE, BG, HR, CZ, DK, EE, FI, FR, DE, GR, HU, IE, IL, IT, LV, LT, LU, NZ, NO, GB, PL, RO, RU, SK, ZA, ES, SE, CH, TR, AU, HK, IN, ID, JP, MY, PH, SG, TW, TH, VN", currency = "AUD, BGN, BRL, BYN, CAD, CHF, CLP, COP, CZK, DKK, DOP, EUR, GBP, HUF, IDR, JPY, KES, MXN, MYR, NOK, PAB, PEN, PHP, PLN, RON, RUB, SEK, SGD, THB, TRY, TWD, UAH, USD, UYU, VND, ZAR" }

config/docker_compose.toml

@@ -847,6 +847,7 @@ apple_pay = { country = "EG, MA, ZA, AU, HK, JP, MO, MY, MN, NZ, SG, KR, TW, VN,
 [pm_filters.fiserv]
 credit = {country = "AU,NZ,CN,HK,IN,LK,KR,MY,SG,GB,BE,FR,DE,IT,ME,NL,PL,ES,ZA,AR,BR,CO,MX,PA,UY,US,CA", currency = "AFN,ALL,DZD,AOA,ARS,AMD,AWG,AUD,AZN,BSD,BHD,BDT,BBD,BYN,BZD,BMD,BTN,BOB,VES,BAM,BWP,BRL,BND,BGN,BIF,KHR,CAD,CVE,KYD,XAF,CLP,CNY,COP,KMF,CDF,CRC,HRK,CUP,CZK,DKK,DJF,DOP,XCD,EGP,ERN,ETB,EUR,FKP,FJD,XPF,GMD,GEL,GHS,GIP,GTQ,GNF,GYD,HTG,HNL,HKD,HUF,ISK,INR,IDR,IRR,IQD,ILS,JMD,JPY,JOD,KZT,KES,KGS,KWD,LAK,LBP,LSL,LRD,LYD,MOP,MKD,MGA,MWK,MYR,MVR,MRU,MUR,MXN,MDL,MNT,MAD,MZN,MMK,NAD,NPR,ANG,NZD,NIO,NGN,VUV,KPW,NOK,OMR,PKR,PAB,PGK,PYG,PEN,PHP,PLN,GBP,QAR,RON,RUB,RWF,SHP,SVC,WST,STN,SAR,RSD,SCR,SLL,SGD,SBD,SOS,ZAR,KRW,SSP,LKR,SDG,SRD,SZL,SEK,CHF,SYP,TWD,TJS,TZS,THB,TOP,TTD,TND,TRY,TMT,UGX,UAH,AED,USD,UYU,UZS,VND,XOF,YER,ZMW,ZWL"}
 debit = {country = "AU,NZ,CN,HK,IN,LK,KR,MY,SG,GB,BE,FR,DE,IT,ME,NL,PL,ES,ZA,AR,BR,CO,MX,PA,UY,US,CA", currency = "AFN,ALL,DZD,AOA,ARS,AMD,AWG,AUD,AZN,BSD,BHD,BDT,BBD,BYN,BZD,BMD,BTN,BOB,VES,BAM,BWP,BRL,BND,BGN,BIF,KHR,CAD,CVE,KYD,XAF,CLP,CNY,COP,KMF,CDF,CRC,HRK,CUP,CZK,DKK,DJF,DOP,XCD,EGP,ERN,ETB,EUR,FKP,FJD,XPF,GMD,GEL,GHS,GIP,GTQ,GNF,GYD,HTG,HNL,HKD,HUF,ISK,INR,IDR,IRR,IQD,ILS,JMD,JPY,JOD,KZT,KES,KGS,KWD,LAK,LBP,LSL,LRD,LYD,MOP,MKD,MGA,MWK,MYR,MVR,MRU,MUR,MXN,MDL,MNT,MAD,MZN,MMK,NAD,NPR,ANG,NZD,NIO,NGN,VUV,KPW,NOK,OMR,PKR,PAB,PGK,PYG,PEN,PHP,PLN,GBP,QAR,RON,RUB,RWF,SHP,SVC,WST,STN,SAR,RSD,SCR,SLL,SGD,SBD,SOS,ZAR,KRW,SSP,LKR,SDG,SRD,SZL,SEK,CHF,SYP,TWD,TJS,TZS,THB,TOP,TTD,TND,TRY,TMT,UGX,UAH,AED,USD,UYU,UZS,VND,XOF,YER,ZMW,ZWL"}
+paypal = { currency = "AUD,EUR,BRL,CAD,CNY,EUR,EUR,EUR,GBP,HKD,INR,EUR,JPY,MYR,EUR,NZD,PHP,PLN,SGD,USD", country = "AU, BE, BR, CA, CN, DE, ES, FR, GB, HK, IN, IT, JP, MY, NL, NZ, PH, PL, SG, US" }
 google_pay = { country = "AU,AT,BE,BR,CA,CN,HK,MY,NZ,SG,US", currency = "AUD,EUR,EUR,BRL,CAD,CNY,HKD,MYR,NZD,SGD,USD" }
 
 [pm_filters.authorizedotnet]

crates/connector_configs/toml/development.toml

@@ -2082,6 +2082,8 @@ api_key = "Integration Key"
   payment_method_type = "UnionPay"
 [[fiserv.wallet]]
   payment_method_type = "google_pay"
+[[fiserv.wallet]]
+  payment_method_type = "paypal"
 [fiserv.connector_auth.SignatureKey]
 api_key="API Key"
 key1="Merchant ID"

crates/connector_configs/toml/production.toml

@@ -1711,6 +1711,8 @@ payment_method_type = "Discover"
 payment_method_type = "CartesBancaires"
 [[fiserv.debit]]
 payment_method_type = "UnionPay"
+[[fiserv.wallet]]
+payment_method_type = "paypal"
 [[fiserv.wallet]]
   payment_method_type = "google_pay"
 [fiserv.connector_auth.SignatureKey]

crates/connector_configs/toml/sandbox.toml

@@ -2058,6 +2058,8 @@ payment_method_type = "Discover"
 payment_method_type = "CartesBancaires"
 [[fiserv.debit]]
 payment_method_type = "UnionPay"
+[[fiserv.wallet]]
+payment_method_type = "paypal"
 [[fiserv.wallet]]
   payment_method_type = "google_pay"
 [fiserv.connector_auth.SignatureKey]

crates/hyperswitch_connectors/src/connectors/fiserv.rs

@@ -12,6 +12,7 @@ use common_utils::{
 };
 use error_stack::{report, ResultExt};
 use hyperswitch_domain_models::{
+    payment_method_data::{PaymentMethodData, WalletData},
     router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
     router_flow_types::{
         access_token_auth::AccessTokenAuth,
@@ -396,15 +397,21 @@ impl ConnectorIntegration<PSync, PaymentsSyncData, PaymentsResponseData> for Fis
             },
         )?;
 
+        let (approved_amount, currency) = match &p_sync_response {
+            fiserv::FiservPaymentsResponse::Charges(resp) => (
+                &resp.payment_receipt.approved_amount.total,
+                &resp.payment_receipt.approved_amount.currency,
+            ),
+            fiserv::FiservPaymentsResponse::Checkout(resp) => (
+                &resp.payment_receipt.approved_amount.total,
+                &resp.payment_receipt.approved_amount.currency,
+            ),
+        };
+
         let response_integrity_object = connector_utils::get_sync_integrity_object(
             self.amount_converter,
-            p_sync_response.payment_receipt.approved_amount.total,
+            *approved_amount,
-            p_sync_response
+            currency.to_string().clone(),
-                .payment_receipt
-                .approved_amount
-                .currency
-                .to_string()
-                .clone(),
         )?;
 
         event_builder.map(|i| i.set_response_body(&response));
@@ -492,15 +499,22 @@ impl ConnectorIntegration<Capture, PaymentsCaptureData, PaymentsResponseData> fo
             .response
             .parse_struct("Fiserv Payment Response")
             .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+
+        let (approved_amount, currency) = match &response {
+            fiserv::FiservPaymentsResponse::Charges(resp) => (
+                &resp.payment_receipt.approved_amount.total,
+                &resp.payment_receipt.approved_amount.currency,
+            ),
+            fiserv::FiservPaymentsResponse::Checkout(resp) => (
+                &resp.payment_receipt.approved_amount.total,
+                &resp.payment_receipt.approved_amount.currency,
+            ),
+        };
+
         let response_integrity_object = connector_utils::get_capture_integrity_object(
             self.amount_converter,
-            Some(response.payment_receipt.approved_amount.total),
+            Some(*approved_amount),
-            response
+            currency.to_string().clone(),
-                .payment_receipt
-                .approved_amount
-                .currency
-                .to_string()
-                .clone(),
         )?;
         event_builder.map(|i| i.set_response_body(&response));
         router_env::logger::info!(connector_response=?response);
@@ -560,13 +574,17 @@ impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData
 
     fn get_url(
         &self,
-        _req: &PaymentsAuthorizeRouterData,
+        req: &PaymentsAuthorizeRouterData,
         connectors: &Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
-        Ok(format!(
+        let url = match &req.request.payment_method_data {
-            "{}ch/payments/v1/charges",
+            PaymentMethodData::Wallet(WalletData::PaypalRedirect(_)) => {
-            connectors.fiserv.base_url
+                format!("{}ch/checkouts/v1/orders", connectors.fiserv.base_url)
-        ))
+            }
+            _ => format!("{}ch/payments/v1/charges", connectors.fiserv.base_url),
+        };
+
+        Ok(url)
     }
 
     fn get_request_body(
@@ -619,15 +637,21 @@ impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData
             .parse_struct("Fiserv PaymentResponse")
             .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
 
+        let (approved_amount, currency) = match &response {
+            fiserv::FiservPaymentsResponse::Charges(resp) => (
+                &resp.payment_receipt.approved_amount.total,
+                &resp.payment_receipt.approved_amount.currency,
+            ),
+            fiserv::FiservPaymentsResponse::Checkout(resp) => (
+                &resp.payment_receipt.approved_amount.total,
+                &resp.payment_receipt.approved_amount.currency,
+            ),
+        };
+
         let response_integrity_object = connector_utils::get_authorise_integrity_object(
             self.amount_converter,
-            response.payment_receipt.approved_amount.total,
+            *approved_amount,
-            response
+            currency.to_string().clone(),
-                .payment_receipt
-                .approved_amount
-                .currency
-                .to_string()
-                .clone(),
         )?;
 
         event_builder.map(|i| i.set_response_body(&response));
@@ -832,15 +856,21 @@ impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Fiserv {
             },
         )?;
 
+        let (approved_amount, currency) = match &r_sync_response {
+            fiserv::FiservPaymentsResponse::Charges(resp) => (
+                &resp.payment_receipt.approved_amount.total,
+                &resp.payment_receipt.approved_amount.currency,
+            ),
+            fiserv::FiservPaymentsResponse::Checkout(resp) => (
+                &resp.payment_receipt.approved_amount.total,
+                &resp.payment_receipt.approved_amount.currency,
+            ),
+        };
+
         let response_integrity_object = connector_utils::get_refund_integrity_object(
             self.amount_converter,
-            r_sync_response.payment_receipt.approved_amount.total,
+            *approved_amount,
-            r_sync_response
+            currency.to_string().clone(),
-                .payment_receipt
-                .approved_amount
-                .currency
-                .to_string()
-                .clone(),
         )?;
 
         event_builder.map(|i| i.set_response_body(&response));
@@ -959,6 +989,17 @@ static FISERV_SUPPORTED_PAYMENT_METHODS: LazyLock<SupportedPaymentMethods> = Laz
         },
     );
 
+    fiserv_supported_payment_methods.add(
+        enums::PaymentMethod::Wallet,
+        enums::PaymentMethodType::Paypal,
+        PaymentMethodDetails {
+            mandates: enums::FeatureStatus::NotSupported,
+            refunds: enums::FeatureStatus::Supported,
+            supported_capture_methods: supported_capture_methods.clone(),
+            specific_features: None,
+        },
+    );
+
     fiserv_supported_payment_methods
 });
 

crates/hyperswitch_connectors/src/connectors/fiserv/transformers.rs

@@ -1,17 +1,17 @@
 use common_enums::{enums, Currency};
-use common_utils::{ext_traits::ValueExt, pii, types::FloatMajorUnit};
+use common_utils::{ext_traits::ValueExt, pii, request::Method, types::FloatMajorUnit};
 use error_stack::ResultExt;
 use hyperswitch_domain_models::{
-    payment_method_data::PaymentMethodData,
+    payment_method_data::{PaymentMethodData, WalletData},
     router_data::{ConnectorAuthType, RouterData},
     router_flow_types::refunds::{Execute, RSync},
     router_request_types::ResponseId,
-    router_response_types::{PaymentsResponseData, RefundsResponseData},
+    router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
     types,
 };
 use hyperswitch_interfaces::errors;
 use masking::{ExposeInterface, Secret};
-use serde::{Deserialize, Serialize};
+use serde::{ser::Serializer, Deserialize, Serialize};
 
 use crate::{
     types::{RefundsResponseRouterData, ResponseRouterData},
@@ -38,14 +38,116 @@ impl<T> TryFrom<(FloatMajorUnit, T)> for FiservRouterData<T> {
     }
 }
 
+impl Serialize for FiservCheckoutChargesRequest {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            Self::Checkout(inner) => inner.serialize(serializer),
+            Self::Charges(inner) => inner.serialize(serializer),
+        }
+    }
+}
+
 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct FiservPaymentsRequest {
     amount: Amount,
-    source: Source,
-    transaction_details: TransactionDetails,
     merchant_details: MerchantDetails,
+    #[serde(flatten)]
+    checkout_charges_request: FiservCheckoutChargesRequest,
+}
+
+#[derive(Debug)]
+pub enum FiservCheckoutChargesRequest {
+    Checkout(CheckoutPaymentsRequest),
+    Charges(ChargesPaymentRequest),
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CheckoutPaymentsRequest {
+    order: FiservOrder,
+    payment_method: FiservPaymentMethod,
+    interactions: FiservInteractions,
+    transaction_details: TransactionDetails,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "UPPERCASE")]
+pub enum FiservChannel {
+    Web,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "UPPERCASE")]
+pub enum FiservPaymentInitiator {
+    Merchant,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
+pub enum FiservCustomerConfirmation {
+    ReviewAndPay,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FiservInteractions {
+    channel: FiservChannel,
+    customer_confirmation: FiservCustomerConfirmation,
+    payment_initiator: FiservPaymentInitiator,
+    return_urls: FiservReturnUrls,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FiservReturnUrls {
+    success_url: String,
+    cancel_url: String,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FiservPaymentMethod {
+    provider: FiservWallet,
+    #[serde(rename = "type")]
+    wallet_type: FiservWalletType,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FiservOrder {
+    intent: FiservIntent,
+}
+
+#[derive(Debug, Serialize, Clone, Deserialize)]
+#[serde(rename_all = "UPPERCASE")]
+pub enum FiservIntent {
+    Authorize,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ChargesPaymentRequest {
+    source: Source,
     transaction_interaction: Option<TransactionInteraction>,
+    transaction_details: TransactionDetails,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "UPPERCASE")]
+pub enum FiservWallet {
+    ApplePay,
+    GooglePay,
+    PayPal,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
+pub enum FiservWalletType {
+    PaypalWallet,
 }
 
 #[derive(Debug, Serialize)]
@@ -83,22 +185,35 @@ pub struct Amount {
     currency: String,
 }
 
-#[derive(Default, Debug, Serialize)]
+#[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct TransactionDetails {
+    #[serde(skip_serializing_if = "Option::is_none")]
     capture_flag: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     reversal_reason_code: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     merchant_transaction_id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    operation_type: Option<OperationType>,
 }
 
-#[derive(Default, Debug, Serialize)]
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "UPPERCASE")]
+pub enum OperationType {
+    Create,
+    Capture,
+    Authorize,
+}
+
+#[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct MerchantDetails {
     merchant_id: Secret<String>,
     terminal_id: Option<Secret<String>>,
 }
 
-#[derive(Default, Debug, Serialize)]
+#[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct TransactionInteraction {
     origin: TransactionInteractionOrigin,
@@ -210,16 +325,6 @@ impl TryFrom<&FiservRouterData<&types::PaymentsAuthorizeRouterData>> for FiservP
             total: item.amount,
             currency: item.router_data.request.currency.to_string(),
         };
-        let transaction_details = TransactionDetails {
-            capture_flag: Some(matches!(
-                item.router_data.request.capture_method,
-                Some(enums::CaptureMethod::Automatic)
-                    | Some(enums::CaptureMethod::SequentialAutomatic)
-                    | None
-            )),
-            reversal_reason_code: None,
-            merchant_transaction_id: Some(item.router_data.connector_request_reference_id.clone()),
-        };
         let metadata = item.router_data.get_connector_meta()?.clone();
         let session: FiservSessionObject = metadata
             .expose()
@@ -233,48 +338,129 @@ impl TryFrom<&FiservRouterData<&types::PaymentsAuthorizeRouterData>> for FiservP
             terminal_id: Some(session.terminal_id),
         };
 
-        let transaction_interaction = Some(TransactionInteraction {
+        let checkout_charges_request = match item.router_data.request.payment_method_data.clone() {
-            //Payment is being made in online mode, card not present
+            PaymentMethodData::Card(ref ccard) => {
-            origin: TransactionInteractionOrigin::Ecom,
+                Ok(FiservCheckoutChargesRequest::Charges(
-            // transaction encryption such as SSL/TLS, but authentication was not performed
+                    ChargesPaymentRequest {
-            eci_indicator: TransactionInteractionEciIndicator::ChannelEncrypted,
+                        source: Source::PaymentCard {
-            //card not present in online transaction
+                            card: CardData {
-            pos_condition_code: TransactionInteractionPosConditionCode::CardNotPresentEcom,
+                                card_data: ccard.card_number.clone(),
-        });
+                                expiration_month: ccard.card_exp_month.clone(),
-        let source = match item.router_data.request.payment_method_data.clone() {
+                                expiration_year: ccard.get_expiry_year_4_digit(),
-            PaymentMethodData::Card(ref ccard) => Ok(Source::PaymentCard {
+                                security_code: Some(ccard.card_cvc.clone()),
-                card: CardData {
+                            },
-                    card_data: ccard.card_number.clone(),
+                        },
-                    expiration_month: ccard.card_exp_month.clone(),
+                        transaction_details: TransactionDetails {
-                    expiration_year: ccard.get_expiry_year_4_digit(),
+                            capture_flag: Some(matches!(
-                    security_code: Some(ccard.card_cvc.clone()),
+                                item.router_data.request.capture_method,
-                },
+                                Some(enums::CaptureMethod::Automatic)
-            }),
+                                    | Some(enums::CaptureMethod::SequentialAutomatic)
+                                    | None
+                            )),
+                            reversal_reason_code: None,
+                            merchant_transaction_id: Some(
+                                item.router_data.connector_request_reference_id.clone(),
+                            ),
+                            operation_type: None,
+                        },
+                        transaction_interaction: Some(TransactionInteraction {
+                            //Payment is being made in online mode, card not present
+                            origin: TransactionInteractionOrigin::Ecom,
+                            // transaction encryption such as SSL/TLS, but authentication was not performed
+                            eci_indicator: TransactionInteractionEciIndicator::ChannelEncrypted,
+                            //card not present in online transaction
+                            pos_condition_code:
+                                TransactionInteractionPosConditionCode::CardNotPresentEcom,
+                        }),
+                    },
+                ))
+            }
             PaymentMethodData::Wallet(wallet_data) => match wallet_data {
-                hyperswitch_domain_models::payment_method_data::WalletData::GooglePay(data) => {
+                WalletData::GooglePay(data) => {
                     let token_string = data.tokenization_data.token.to_owned();
 
                     let parsed = parse_googlepay_token_safely(&token_string);
 
-                    Ok(Source::GooglePay(GooglePayData {
+                    Ok(FiservCheckoutChargesRequest::Charges(
-                        data: Secret::new(parsed.encrypted_message),
+                        ChargesPaymentRequest {
-                        signature: Secret::new(parsed.signature.expose().to_owned()),
+                            source: Source::GooglePay(GooglePayData {
-                        version: parsed.protocol_version,
+                                data: Secret::new(parsed.encrypted_message),
-                        intermediate_signing_key: IntermediateSigningKey {
+                                signature: Secret::new(parsed.signature.expose().to_owned()),
-                            signed_key: Secret::new(
+                                version: parsed.protocol_version,
-                                serde_json::json!({
+                                intermediate_signing_key: IntermediateSigningKey {
-                                    "keyValue": parsed.key_value,
+                                    signed_key: Secret::new(
-                                    "keyExpiration": parsed.key_expiration
+                                        serde_json::json!({
-                                })
+                                            "keyValue": parsed.key_value,
-                                .to_string(),
+                                            "keyExpiration": parsed.key_expiration
-                            ),
+                                        })
-                            signatures: parsed
+                                        .to_string(),
-                                .signatures
+                                    ),
-                                .into_iter()
+                                    signatures: parsed
-                                .map(|s| Secret::new(s.to_owned()))
+                                        .signatures
-                                .collect(),
+                                        .into_iter()
+                                        .map(|s| Secret::new(s.to_owned()))
+                                        .collect(),
+                                },
+                            }),
+                            transaction_details: TransactionDetails {
+                                capture_flag: Some(matches!(
+                                    item.router_data.request.capture_method,
+                                    Some(enums::CaptureMethod::Automatic)
+                                        | Some(enums::CaptureMethod::SequentialAutomatic)
+                                        | None
+                                )),
+                                reversal_reason_code: None,
+                                merchant_transaction_id: Some(
+                                    item.router_data.connector_request_reference_id.clone(),
+                                ),
+                                operation_type: None,
+                            },
+                            transaction_interaction: None,
                         },
-                    }))
+                    ))
+                }
+                WalletData::PaypalRedirect(_) => {
+                    let return_url = item
+                        .router_data
+                        .request
+                        .complete_authorize_url
+                        .clone()
+                        .ok_or(errors::ConnectorError::MissingRequiredField {
+                            field_name: "return_url",
+                        })?;
+                    Ok(FiservCheckoutChargesRequest::Checkout(
+                        CheckoutPaymentsRequest {
+                            payment_method: FiservPaymentMethod {
+                                provider: FiservWallet::PayPal,
+                                wallet_type: FiservWalletType::PaypalWallet,
+                            },
+                            order: FiservOrder {
+                                intent: FiservIntent::Authorize,
+                            },
+                            interactions: FiservInteractions {
+                                channel: FiservChannel::Web,
+                                customer_confirmation: FiservCustomerConfirmation::ReviewAndPay,
+                                payment_initiator: FiservPaymentInitiator::Merchant,
+                                return_urls: FiservReturnUrls {
+                                    success_url: return_url.clone(),
+                                    cancel_url: return_url,
+                                },
+                            },
+                            transaction_details: TransactionDetails {
+                                operation_type: Some(OperationType::Create),
+                                capture_flag: Some(matches!(
+                                    item.router_data.request.capture_method,
+                                    Some(enums::CaptureMethod::Automatic)
+                                        | Some(enums::CaptureMethod::SequentialAutomatic)
+                                        | None
+                                )),
+                                reversal_reason_code: None,
+                                merchant_transaction_id: Some(
+                                    item.router_data.connector_request_reference_id.clone(),
+                                ),
+                            },
+                        },
+                    ))
                 }
                 _ => Err(error_stack::report!(
                     errors::ConnectorError::NotImplemented(
@@ -306,10 +492,8 @@ impl TryFrom<&FiservRouterData<&types::PaymentsAuthorizeRouterData>> for FiservP
         }?;
         Ok(Self {
             amount,
-            source,
+            checkout_charges_request,
-            transaction_details,
             merchant_details,
-            transaction_interaction,
         })
     }
 }
@@ -340,7 +524,7 @@ impl TryFrom<&ConnectorAuthType> for FiservAuthType {
     }
 }
 
-#[derive(Default, Debug, Serialize)]
+#[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct FiservCancelRequest {
     transaction_details: TransactionDetails,
@@ -371,18 +555,19 @@ impl TryFrom<&types::PaymentsCancelRouterData> for FiservCancelRequest {
                 capture_flag: None,
                 reversal_reason_code: Some(item.request.get_cancellation_reason()?),
                 merchant_transaction_id: Some(item.connector_request_reference_id.clone()),
+                operation_type: None,
             },
         })
     }
 }
 
-#[derive(Debug, Default, Deserialize, Serialize)]
+#[derive(Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ErrorResponse {
     pub error: Option<Vec<ErrorDetails>>,
 }
 
-#[derive(Debug, Default, Deserialize, Serialize)]
+#[derive(Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ErrorDetails {
     #[serde(rename = "type")]
@@ -393,7 +578,7 @@ pub struct ErrorDetails {
     pub additional_info: Option<String>,
 }
 
-#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
+#[derive(Default, Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "UPPERCASE")]
 pub enum FiservPaymentStatus {
     Succeeded,
@@ -404,6 +589,7 @@ pub enum FiservPaymentStatus {
     Authorized,
     #[default]
     Processing,
+    Created,
 }
 
 impl From<FiservPaymentStatus> for enums::AttemptStatus {
@@ -414,6 +600,7 @@ impl From<FiservPaymentStatus> for enums::AttemptStatus {
             FiservPaymentStatus::Processing => Self::Authorizing,
             FiservPaymentStatus::Voided => Self::Voided,
             FiservPaymentStatus::Authorized => Self::Authorized,
+            FiservPaymentStatus::Created => Self::AuthenticationPending,
         }
     }
 }
@@ -425,12 +612,14 @@ impl From<FiservPaymentStatus> for enums::RefundStatus {
             | FiservPaymentStatus::Authorized
             | FiservPaymentStatus::Captured => Self::Success,
             FiservPaymentStatus::Declined | FiservPaymentStatus::Failed => Self::Failure,
-            FiservPaymentStatus::Voided | FiservPaymentStatus::Processing => Self::Pending,
+            FiservPaymentStatus::Voided
+            | FiservPaymentStatus::Processing
+            | FiservPaymentStatus::Created => Self::Pending,
         }
     }
 }
 
-#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ProcessorResponseDetails {
     pub approval_status: Option<String>,
@@ -449,21 +638,21 @@ pub struct ProcessorResponseDetails {
     pub response_indicators: Option<ResponseIndicators>,
 }
 
-#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct AdditionalInfo {
     pub name: Option<String>,
     pub value: Option<String>,
 }
 
-#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct BankAssociationDetails {
     pub association_response_code: Option<String>,
     pub avs_security_code_response: Option<AvsSecurityCodeResponse>,
 }
 
-#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct AvsSecurityCodeResponse {
     pub street_match: Option<String>,
@@ -472,14 +661,14 @@ pub struct AvsSecurityCodeResponse {
     pub association: Option<Association>,
 }
 
-#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Association {
     pub avs_code: Option<String>,
     pub security_code_response: Option<String>,
 }
 
-#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ResponseIndicators {
     pub alternate_route_debit_indicator: Option<bool>,
@@ -487,35 +676,78 @@ pub struct ResponseIndicators {
     pub signature_debit_route_indicator: Option<bool>,
 }
 
-#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct FiservPaymentsResponse {
+pub struct FiservChargesResponse {
     pub gateway_response: GatewayResponse,
     pub payment_receipt: PaymentReceipt,
 }
 
-#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FiservCheckoutResponse {
+    pub gateway_response: GatewayResponse,
+    pub payment_receipt: PaymentReceipt,
+    pub interactions: FiservResponseInteractions,
+    pub order: Option<FiservResponseOrders>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FiservResponseInteractions {
+    actions: FiservResponseActions,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FiservResponseActions {
+    #[serde(rename = "type")]
+    action_type: String,
+    url: url::Url,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FiservResponseOrders {
+    intent: FiservIntent,
+    order_id: String,
+    order_status: FiservOrderStatus,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "UPPERCASE")]
+pub enum FiservOrderStatus {
+    PayerActionRequired,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum FiservPaymentsResponse {
+    Charges(FiservChargesResponse),
+    Checkout(FiservCheckoutResponse),
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct PaymentReceipt {
     pub approved_amount: ApprovedAmount,
     pub processor_response_details: Option<ProcessorResponseDetails>,
 }
 
-#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ApprovedAmount {
     pub total: FloatMajorUnit,
     pub currency: Currency,
 }
 
-#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 #[serde(transparent)]
 pub struct FiservSyncResponse {
     pub sync_responses: Vec<FiservPaymentsResponse>,
 }
 
-#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct GatewayResponse {
     gateway_transaction_id: Option<String>,
@@ -523,7 +755,7 @@ pub struct GatewayResponse {
     transaction_processing_details: TransactionProcessingDetails,
 }
 
-#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct TransactionProcessingDetails {
     order_id: String,
@@ -537,7 +769,20 @@ impl<F, T> TryFrom<ResponseRouterData<F, FiservPaymentsResponse, T, PaymentsResp
     fn try_from(
         item: ResponseRouterData<F, FiservPaymentsResponse, T, PaymentsResponseData>,
     ) -> Result<Self, Self::Error> {
-        let gateway_resp = item.response.gateway_response;
+        let (gateway_resp, redirect_url, order_id) = match &item.response {
+            FiservPaymentsResponse::Charges(res) => (res.gateway_response.clone(), None, None),
+            FiservPaymentsResponse::Checkout(res) => (
+                res.gateway_response.clone(),
+                Some(res.interactions.actions.url.clone()),
+                res.order.as_ref().map(|o| o.order_id.clone()),
+            ),
+        };
+
+        let redirection_data = redirect_url.map(|url| RedirectForm::from((url, Method::Get)));
+
+        let connector_metadata: Option<serde_json::Value> = Some(serde_json::json!({
+            "order_id": order_id,
+        }));
 
         Ok(Self {
             status: enums::AttemptStatus::from(gateway_resp.transaction_state),
@@ -545,9 +790,9 @@ impl<F, T> TryFrom<ResponseRouterData<F, FiservPaymentsResponse, T, PaymentsResp
                 resource_id: ResponseId::ConnectorTransactionId(
                     gateway_resp.transaction_processing_details.transaction_id,
                 ),
-                redirection_data: Box::new(None),
+                redirection_data: Box::new(redirection_data),
                 mandate_reference: Box::new(None),
-                connector_metadata: None,
+                connector_metadata,
                 network_txn_id: None,
                 connector_response_reference_id: Some(
                     gateway_resp.transaction_processing_details.order_id,
@@ -572,29 +817,42 @@ impl<F, T> TryFrom<ResponseRouterData<F, FiservSyncResponse, T, PaymentsResponse
             None => Err(errors::ConnectorError::ResponseHandlingFailed)?,
         };
 
+        let connector_response_reference_id = match gateway_resp {
+            FiservPaymentsResponse::Charges(res) => {
+                &res.gateway_response.transaction_processing_details.order_id
+            }
+            FiservPaymentsResponse::Checkout(res) => {
+                &res.gateway_response.transaction_processing_details.order_id
+            }
+        };
+
+        let transaction_id = match gateway_resp {
+            FiservPaymentsResponse::Charges(res) => {
+                &res.gateway_response
+                    .transaction_processing_details
+                    .transaction_id
+            }
+            FiservPaymentsResponse::Checkout(res) => {
+                &res.gateway_response
+                    .transaction_processing_details
+                    .transaction_id
+            }
+        };
+
+        let transaction_state = match gateway_resp {
+            FiservPaymentsResponse::Charges(res) => &res.gateway_response.transaction_state,
+            FiservPaymentsResponse::Checkout(res) => &res.gateway_response.transaction_state,
+        };
+
         Ok(Self {
-            status: enums::AttemptStatus::from(
+            status: enums::AttemptStatus::from(transaction_state.clone()),
-                gateway_resp.gateway_response.transaction_state.clone(),
-            ),
             response: Ok(PaymentsResponseData::TransactionResponse {
-                resource_id: ResponseId::ConnectorTransactionId(
+                resource_id: ResponseId::ConnectorTransactionId(transaction_id.to_string()),
-                    gateway_resp
-                        .gateway_response
-                        .transaction_processing_details
-                        .transaction_id
-                        .clone(),
-                ),
                 redirection_data: Box::new(None),
                 mandate_reference: Box::new(None),
                 connector_metadata: None,
                 network_txn_id: None,
-                connector_response_reference_id: Some(
+                connector_response_reference_id: Some(connector_response_reference_id.to_string()),
-                    gateway_resp
-                        .gateway_response
-                        .transaction_processing_details
-                        .order_id
-                        .clone(),
-                ),
                 incremental_authorization_allowed: None,
                 charges: None,
             }),
@@ -603,22 +861,30 @@ impl<F, T> TryFrom<ResponseRouterData<F, FiservSyncResponse, T, PaymentsResponse
     }
 }
 
-#[derive(Default, Debug, Serialize)]
+#[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct FiservCaptureRequest {
     amount: Amount,
     transaction_details: TransactionDetails,
     merchant_details: MerchantDetails,
     reference_transaction_details: ReferenceTransactionDetails,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    order: Option<FiservOrderRequest>,
 }
 
-#[derive(Default, Debug, Serialize)]
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FiservOrderRequest {
+    order_id: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ReferenceTransactionDetails {
     reference_transaction_id: String,
 }
 
-#[derive(Debug, Default, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 pub struct FiservSessionObject {
     pub terminal_id: Secret<String>,
 }
@@ -651,17 +917,29 @@ impl TryFrom<&FiservRouterData<&types::PaymentsCaptureRouterData>> for FiservCap
             .change_context(errors::ConnectorError::InvalidConnectorConfig {
                 config: "Merchant connector account metadata",
             })?;
+
+        let order_id = item
+            .router_data
+            .request
+            .connector_meta
+            .as_ref()
+            .and_then(|v| v.get("order_id"))
+            .and_then(|v| v.as_str())
+            .map(|s| s.to_string());
+
         Ok(Self {
             amount: Amount {
                 total: item.amount,
                 currency: item.router_data.request.currency.to_string(),
             },
+            order: Some(FiservOrderRequest { order_id }),
             transaction_details: TransactionDetails {
                 capture_flag: Some(true),
                 reversal_reason_code: None,
                 merchant_transaction_id: Some(
                     item.router_data.connector_request_reference_id.clone(),
                 ),
+                operation_type: Some(OperationType::Capture),
             },
             merchant_details: MerchantDetails {
                 merchant_id: auth.merchant_account,
@@ -678,7 +956,7 @@ impl TryFrom<&FiservRouterData<&types::PaymentsCaptureRouterData>> for FiservCap
     }
 }
 
-#[derive(Default, Debug, Serialize)]
+#[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct FiservSyncRequest {
     merchant_details: MerchantDetails,
@@ -724,7 +1002,7 @@ impl TryFrom<&types::RefundSyncRouterData> for FiservSyncRequest {
     }
 }
 
-#[derive(Default, Debug, Serialize)]
+#[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct FiservRefundRequest {
     amount: Amount,
@@ -769,7 +1047,7 @@ impl<F> TryFrom<&FiservRouterData<&types::RefundsRouterData<F>>> for FiservRefun
     }
 }
 
-#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct RefundResponse {
     pub gateway_response: GatewayResponse,
@@ -811,16 +1089,27 @@ impl TryFrom<RefundsResponseRouterData<RSync, FiservSyncResponse>>
             .sync_responses
             .first()
             .ok_or(errors::ConnectorError::ResponseHandlingFailed)?;
-        Ok(Self {
+        let transaction_id = match gateway_resp {
-            response: Ok(RefundsResponseData {
+            FiservPaymentsResponse::Charges(res) => {
-                connector_refund_id: gateway_resp
+                &res.gateway_response
-                    .gateway_response
                     .transaction_processing_details
                     .transaction_id
-                    .clone(),
+            }
-                refund_status: enums::RefundStatus::from(
+            FiservPaymentsResponse::Checkout(res) => {
-                    gateway_resp.gateway_response.transaction_state.clone(),
+                &res.gateway_response
-                ),
+                    .transaction_processing_details
+                    .transaction_id
+            }
+        };
+
+        let transaction_state = match gateway_resp {
+            FiservPaymentsResponse::Charges(res) => &res.gateway_response.transaction_state,
+            FiservPaymentsResponse::Checkout(res) => &res.gateway_response.transaction_state,
+        };
+        Ok(Self {
+            response: Ok(RefundsResponseData {
+                connector_refund_id: transaction_id.clone(),
+                refund_status: enums::RefundStatus::from(transaction_state.clone()),
             }),
             ..item.data
         })

loadtest/config/development.toml

@@ -553,6 +553,8 @@ sepa = { country = "ES", currency = "EUR" }
 [pm_filters.fiserv]
 credit = { country = "AU,NZ,CN,HK,IN,LK,KR,MY,SG,GB,BE,FR,DE,IT,ME,NL,PL,ES,ZA,AR,BR,CO,MX,PA,UY,US,CA", currency = "AFN,ALL,DZD,AOA,ARS,AMD,AWG,AUD,AZN,BSD,BHD,BDT,BBD,BYN,BZD,BMD,BTN,BOB,VES,BAM,BWP,BRL,BND,BGN,BIF,KHR,CAD,CVE,KYD,XAF,CLP,CNY,COP,KMF,CDF,CRC,HRK,CUP,CZK,DKK,DJF,DOP,XCD,EGP,ERN,ETB,EUR,FKP,FJD,XPF,GMD,GEL,GHS,GIP,GTQ,GNF,GYD,HTG,HNL,HKD,HUF,ISK,INR,IDR,IRR,IQD,ILS,JMD,JPY,JOD,KZT,KES,KGS,KWD,LAK,LBP,LSL,LRD,LYD,MOP,MKD,MGA,MWK,MYR,MVR,MRU,MUR,MXN,MDL,MNT,MAD,MZN,MMK,NAD,NPR,ANG,NZD,NIO,NGN,VUV,KPW,NOK,OMR,PKR,PAB,PGK,PYG,PEN,PHP,PLN,GBP,QAR,RON,RUB,RWF,SHP,SVC,WST,STN,SAR,RSD,SCR,SLL,SGD,SBD,SOS,ZAR,KRW,SSP,LKR,SDG,SRD,SZL,SEK,CHF,SYP,TWD,TJS,TZS,THB,TOP,TTD,TND,TRY,TMT,UGX,UAH,AED,USD,UYU,UZS,VND,XOF,YER,ZMW,ZWL" }
 debit = { country = "AU,NZ,CN,HK,IN,LK,KR,MY,SG,GB,BE,FR,DE,IT,ME,NL,PL,ES,ZA,AR,BR,CO,MX,PA,UY,US,CA", currency = "AFN,ALL,DZD,AOA,ARS,AMD,AWG,AUD,AZN,BSD,BHD,BDT,BBD,BYN,BZD,BMD,BTN,BOB,VES,BAM,BWP,BRL,BND,BGN,BIF,KHR,CAD,CVE,KYD,XAF,CLP,CNY,COP,KMF,CDF,CRC,HRK,CUP,CZK,DKK,DJF,DOP,XCD,EGP,ERN,ETB,EUR,FKP,FJD,XPF,GMD,GEL,GHS,GIP,GTQ,GNF,GYD,HTG,HNL,HKD,HUF,ISK,INR,IDR,IRR,IQD,ILS,JMD,JPY,JOD,KZT,KES,KGS,KWD,LAK,LBP,LSL,LRD,LYD,MOP,MKD,MGA,MWK,MYR,MVR,MRU,MUR,MXN,MDL,MNT,MAD,MZN,MMK,NAD,NPR,ANG,NZD,NIO,NGN,VUV,KPW,NOK,OMR,PKR,PAB,PGK,PYG,PEN,PHP,PLN,GBP,QAR,RON,RUB,RWF,SHP,SVC,WST,STN,SAR,RSD,SCR,SLL,SGD,SBD,SOS,ZAR,KRW,SSP,LKR,SDG,SRD,SZL,SEK,CHF,SYP,TWD,TJS,TZS,THB,TOP,TTD,TND,TRY,TMT,UGX,UAH,AED,USD,UYU,UZS,VND,XOF,YER,ZMW,ZWL" }
+paypal = { currency = "AUD,EUR,BRL,CAD,CNY,EUR,EUR,EUR,GBP,HKD,INR,EUR,JPY,MYR,EUR,NZD,PHP,PLN,SGD,USD", country = "AU, BE, BR, CA, CN, DE, ES, FR, GB, HK, IN, IT, JP, MY, NL, NZ, PH, PL, SG, US" }
+google_pay = { country = "AU,AT,BE,BR,CA,CN,HK,MY,NZ,SG,US", currency = "AUD,EUR,EUR,BRL,CAD,CNY,HKD,MYR,NZD,SGD,USD" }
 
 [pm_filters.stax]
 credit = { country = "US", currency = "USD" }