activemerchant 1.117.0 → 1.123.0

data/lib/active_merchant/billing/gateways/qvalent.rb

@@ -17,7 +17,7 @@ module ActiveMerchant #:nodoc:
       }
 
       def initialize(options = {})
-        requires!(options, :username, :password, :merchant, :pem, :pem_password)
+        requires!(options, :username, :password, :merchant, :pem)
         super
       end
 
@@ -30,6 +30,7 @@ module ActiveMerchant #:nodoc:
         add_stored_credential_data(post, payment_method, options)
         add_customer_data(post, options)
         add_soft_descriptors(post, options)
+        add_customer_reference(post, options)
 
         commit('capture', post)
       end
@@ -43,6 +44,7 @@ module ActiveMerchant #:nodoc:
         add_stored_credential_data(post, payment_method, options)
         add_customer_data(post, options)
         add_soft_descriptors(post, options)
+        add_customer_reference(post, options)
 
         commit('preauth', post)
       end
@@ -53,6 +55,7 @@ module ActiveMerchant #:nodoc:
         add_reference(post, authorization, options)
         add_customer_data(post, options)
         add_soft_descriptors(post, options)
+        add_customer_reference(post, options)
 
         commit('captureWithoutAuth', post)
       end
@@ -64,6 +67,7 @@ module ActiveMerchant #:nodoc:
         add_customer_data(post, options)
         add_soft_descriptors(post, options)
         post['order.ECI'] = options[:eci] || 'SSL'
+        add_customer_reference(post, options)
 
         commit('refund', post)
       end
@@ -76,6 +80,7 @@ module ActiveMerchant #:nodoc:
         add_payment_method(post, payment_method)
         add_customer_data(post, options)
         add_soft_descriptors(post, options)
+        add_customer_reference(post, options)
 
         commit('refund', post)
       end
@@ -85,6 +90,7 @@ module ActiveMerchant #:nodoc:
         add_reference(post, authorization, options)
         add_customer_data(post, options)
         add_soft_descriptors(post, options)
+        add_customer_reference(post, options)
 
         commit('reversal', post)
       end
@@ -92,7 +98,7 @@ module ActiveMerchant #:nodoc:
       def store(payment_method, options = {})
         post = {}
         add_payment_method(post, payment_method)
-        add_card_reference(post)
+        add_card_reference(post, options)
 
         commit('registerAccount', post)
       end
@@ -149,12 +155,16 @@ module ActiveMerchant #:nodoc:
         return unless payment_method.brand == 'visa'
 
         stored_credential = options[:stored_credential]
-        if stored_credential[:initial_transaction]
-          post['card.storedCredentialUsage'] = 'INITIAL_STORAGE'
-        elsif stored_credential[:reason_type] == ('recurring' || 'installment')
+        if stored_credential[:reason_type] == 'unscheduled'
+          if stored_credential[:initiator] == 'merchant'
+            post['card.storedCredentialUsage'] = 'UNSCHEDULED_MIT'
+          elsif stored_credential[:initiator] == 'customer'
+            post['card.storedCredentialUsage'] = 'UNSCHEDULED_CIT'
+          end
+        elsif stored_credential[:reason_type] == 'recurring'
           post['card.storedCredentialUsage'] = 'RECURRING'
-        elsif stored_credential[:reason_type] == 'unscheduled'
-          post['card.storedCredentialUsage'] = 'UNSCHEDULED'
+        elsif stored_credential[:reason_type] == 'installment'
+          post['card.storedCredentialUsage'] = 'INSTALLMENT'
         end
       end
 
@@ -181,8 +191,12 @@ module ActiveMerchant #:nodoc:
         post['card.CVN'] = payment_method.verification_value
       end
 
-      def add_card_reference(post)
-        post['customer.customerReferenceNumber'] = options[:order_id]
+      def add_card_reference(post, options)
+        post['customer.customerReferenceNumber'] = options[:customer_reference_number] || options[:order_id]
+      end
+
+      def add_customer_reference(post, options)
+        post['customer.customerReferenceNumber'] = options[:customer_reference_number] if options[:customer_reference_number]
       end
 
       def add_reference(post, authorization, options)

data/lib/active_merchant/billing/gateways/redsys.rb

@@ -126,6 +126,7 @@ module ActiveMerchant #:nodoc:
         184 => 'Authentication error',
         190 => 'Refusal with no specific reason',
         191 => 'Expiry date incorrect',
+        195 => 'Requires SCA authentication',
 
         201 => 'Card expired',
         202 => 'Card blocked temporarily or under suspicion of fraud',
@@ -202,10 +203,12 @@ module ActiveMerchant #:nodoc:
         add_order(data, options[:order_id])
         add_payment(data, payment)
         add_external_mpi_fields(data, options)
-        add_threeds(data, options) if options[:execute_threed]
+        add_three_ds_data(data, options) if options[:execute_threed]
+        add_stored_credential_options(data, options)
         data[:description] = options[:description]
         data[:store_in_vault] = options[:store]
         data[:sca_exemption] = options[:sca_exemption]
+        data[:sca_exemption_direct_payment_enabled] = options[:sca_exemption_direct_payment_enabled]
 
         commit data, options
       end
@@ -219,10 +222,12 @@ module ActiveMerchant #:nodoc:
         add_order(data, options[:order_id])
         add_payment(data, payment)
         add_external_mpi_fields(data, options)
-        add_threeds(data, options) if options[:execute_threed]
+        add_three_ds_data(data, options) if options[:execute_threed]
+        add_stored_credential_options(data, options)
         data[:description] = options[:description]
         data[:store_in_vault] = options[:store]
         data[:sca_exemption] = options[:sca_exemption]
+        data[:sca_exemption_direct_payment_enabled] = options[:sca_exemption_direct_payment_enabled]
 
         commit data, options
       end
@@ -307,7 +312,7 @@ module ActiveMerchant #:nodoc:
         test? ? test_url : live_url
       end
 
-      def threeds_url
+      def webservice_url
         test? ? 'https://sis-t.redsys.es:25443/sis/services/SerClsWSEntradaV2' : 'https://sis.redsys.es/sis/services/SerClsWSEntradaV2'
       end
 
@@ -331,57 +336,87 @@ module ActiveMerchant #:nodoc:
         return unless options[:three_d_secure]
 
         if options[:three_d_secure][:version] == THREE_DS_V2
-          data[:threeDSServerTransID] = options[:three_d_secure][:xid] if options[:three_d_secure][:xid]
+          data[:threeDSServerTransID] = options[:three_d_secure][:three_ds_server_trans_id] if options[:three_d_secure][:three_ds_server_trans_id]
           data[:dsTransID] = options[:three_d_secure][:ds_transaction_id] if options[:three_d_secure][:ds_transaction_id]
           data[:authenticacionValue] = options[:three_d_secure][:cavv] if options[:three_d_secure][:cavv]
           data[:protocolVersion] = options[:three_d_secure][:version] if options[:three_d_secure][:version]
-
           data[:authenticacionMethod] = options[:authentication_method] if options[:authentication_method]
           data[:authenticacionType] = options[:authentication_type] if options[:authentication_type]
           data[:authenticacionFlow] = options[:authentication_flow] if options[:authentication_flow]
+          data[:eci_v2] = options[:three_d_secure][:eci] if options[:three_d_secure][:eci]
         elsif options[:three_d_secure][:version] == THREE_DS_V1
           data[:txid] = options[:three_d_secure][:xid] if options[:three_d_secure][:xid]
           data[:cavv] = options[:three_d_secure][:cavv] if options[:three_d_secure][:cavv]
-          data[:eci] = options[:three_d_secure][:eci] if options[:three_d_secure][:eci]
+          data[:eci_v1] = options[:three_d_secure][:eci] if options[:three_d_secure][:eci]
+        end
+      end
+
+      def add_stored_credential_options(data, options)
+        return unless options[:stored_credential]
+
+        case options[:stored_credential][:initial_transaction]
+        when true
+          data[:DS_MERCHANT_COF_INI] = 'S'
+        when false
+          data[:DS_MERCHANT_COF_INI] = 'N'
+          data[:DS_MERCHANT_COF_TXNID] = options[:stored_credential][:network_transaction_id] if options[:stored_credential][:network_transaction_id]
         end
+
+        case options[:stored_credential][:reason_type]
+        when 'recurring'
+          data[:DS_MERCHANT_COF_TYPE] = 'R'
+        when 'installment'
+          data[:DS_MERCHANT_COF_TYPE] = 'I'
+        when 'unscheduled'
+          return
+        end
+      end
+
+      def add_three_ds_data(data, options)
+        data[:three_ds_data] = { threeDSInfo: 'CardData' } if options[:execute_threed] == true
       end
 
-      def add_threeds(data, options)
-        data[:threeds] = { threeDSInfo: 'CardData' } if options[:execute_threed] == true
+      def determine_peticion_type(data)
+        three_ds_info = data.dig(:three_ds_data, :threeDSInfo)
+        return 'iniciaPeticion' if three_ds_info == 'CardData'
+        return 'trataPeticion' if three_ds_info == 'AuthenticationData' ||
+                                  three_ds_info == 'ChallengeResponse' ||
+                                  data[:sca_exemption] == 'MIT'
       end
 
-      def determine_3ds_action(threeds_hash)
-        return 'iniciaPeticion' if threeds_hash[:threeDSInfo] == 'CardData'
-        return 'trataPeticion' if threeds_hash[:threeDSInfo] == 'AuthenticationData' ||
-                                  threeds_hash[:threeDSInfo] == 'ChallengeResponse'
+      def use_webservice_endpoint?(data, options)
+        options[:use_webservice_endpoint].to_s == 'true' || data[:three_ds_data] || data[:sca_exemption] == 'MIT'
       end
 
       def commit(data, options = {})
-        if data[:threeds]
-          action = determine_3ds_action(data[:threeds])
+        xmlreq = xml_request_from(data, options)
+
+        if use_webservice_endpoint?(data, options)
+          peticion_type = determine_peticion_type(data)
+
           request = <<-REQUEST
             <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:apachesoap="http://xml.apache.org/xml-soap" xmlns:impl="http://webservice.sis.sermepa.es" xmlns:intf="http://webservice.sis.sermepa.es" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:wsdlsoap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" >
             <soapenv:Header/>
             <soapenv:Body>
-              <intf:#{action} xmlns:intf="http://webservice.sis.sermepa.es">
+              <intf:#{peticion_type} xmlns:intf="http://webservice.sis.sermepa.es">
                 <intf:datoEntrada>
-                <![CDATA[#{xml_request_from(data, options)}]]>
+                <![CDATA[#{xmlreq}]]>
                 </intf:datoEntrada>
-              </intf:#{action}>
+              </intf:#{peticion_type}>
             </soapenv:Body>
           </soapenv:Envelope>
           REQUEST
-          parse(ssl_post(threeds_url, request, headers(action)), action)
+          parse(ssl_post(webservice_url, request, headers(peticion_type)), peticion_type)
         else
-          parse(ssl_post(url, "entrada=#{CGI.escape(xml_request_from(data, options))}", headers), action)
+          parse(ssl_post(url, "entrada=#{CGI.escape(xmlreq)}", headers), peticion_type)
         end
       end
 
-      def headers(action = nil)
-        if action
+      def headers(peticion_type = nil)
+        if peticion_type
           {
             'Content-Type' => 'text/xml',
-            'SOAPAction' => action
+            'SOAPAction' => peticion_type
           }
         else
           {
@@ -445,7 +480,7 @@ module ActiveMerchant #:nodoc:
 
       def build_merchant_data(xml, data, options = {})
         # See https://sis-t.redsys.es:25443/sis/services/SerClsWSEntradaV2/wsdl/SerClsWSEntradaV2.wsdl
-        # (which results from calling #threeds_url + '?WSDL', https://sis-t.redsys.es:25443/sis/services/SerClsWSEntradaV2?WSDL)
+        # (which results from calling #webservice_url + '?WSDL', https://sis-t.redsys.es:25443/sis/services/SerClsWSEntradaV2?WSDL)
         xml.DATOSENTRADA do
           # Basic elements
           xml.DS_Version 0.1
@@ -453,7 +488,7 @@ module ActiveMerchant #:nodoc:
           xml.DS_MERCHANT_AMOUNT             data[:amount]
           xml.DS_MERCHANT_ORDER              data[:order_id]
           xml.DS_MERCHANT_TRANSACTIONTYPE    data[:action]
-          if data[:description] && data[:threeds]
+          if data[:description] && use_webservice_endpoint?(data, options)
             xml.DS_MERCHANT_PRODUCTDESCRIPTION CGI.escape(data[:description])
           else
             xml.DS_MERCHANT_PRODUCTDESCRIPTION data[:description]
@@ -461,11 +496,18 @@ module ActiveMerchant #:nodoc:
           xml.DS_MERCHANT_TERMINAL           options[:terminal] || @options[:terminal]
           xml.DS_MERCHANT_MERCHANTCODE       @options[:login]
           xml.DS_MERCHANT_MERCHANTSIGNATURE  build_signature(data) unless sha256_authentication?
-          xml.DS_MERCHANT_EXCEP_SCA          data[:sca_exemption] if data[:sca_exemption]
+
+          peticion_type = determine_peticion_type(data) if data[:three_ds_data]
+          if peticion_type == 'iniciaPeticion' && data[:sca_exemption]
+            xml.DS_MERCHANT_EXCEP_SCA 'Y'
+          else
+            xml.DS_MERCHANT_EXCEP_SCA data[:sca_exemption] if data[:sca_exemption]
+            xml.DS_MERCHANT_DIRECTPAYMENT data[:sca_exemption_direct_payment_enabled] || 'true' if data[:sca_exemption] == 'MIT'
+          end
 
           # Only when card is present
           if data[:card]
-            if data[:card][:name] && data[:threeds]
+            if data[:card][:name] && use_webservice_endpoint?(data, options)
               xml.DS_MERCHANT_TITULAR    CGI.escape(data[:card][:name])
             else
               xml.DS_MERCHANT_TITULAR    data[:card][:name]
@@ -486,7 +528,13 @@ module ActiveMerchant #:nodoc:
           # Requires account configuration to be able to use
           xml.DS_MERCHANT_DIRECTPAYMENT 'moto' if options.dig(:moto) && options.dig(:metadata, :manual_entry)
 
-          xml.DS_MERCHANT_EMV3DS data[:threeds].to_json if data[:threeds]
+          xml.DS_MERCHANT_EMV3DS data[:three_ds_data].to_json if data[:three_ds_data]
+
+          if options[:stored_credential]
+            xml.DS_MERCHANT_COF_INI data[:DS_MERCHANT_COF_INI]
+            xml.DS_MERCHANT_COF_TYPE data[:DS_MERCHANT_COF_TYPE]
+            xml.DS_MERCHANT_COF_TXNID data[:DS_MERCHANT_COF_TXNID] if data[:DS_MERCHANT_COF_TXNID]
+          end
         end
       end
 
@@ -496,13 +544,13 @@ module ActiveMerchant #:nodoc:
         ds_merchant_mpi_external = {}
         ds_merchant_mpi_external[:TXID] = data[:txid] if data[:txid]
         ds_merchant_mpi_external[:CAVV] = data[:cavv] if data[:cavv]
-        ds_merchant_mpi_external[:ECI] = data[:eci] if data[:eci]
+        ds_merchant_mpi_external[:ECI] = data[:eci_v1] if data[:eci_v1]
 
         ds_merchant_mpi_external[:threeDSServerTransID] = data[:threeDSServerTransID] if data[:threeDSServerTransID]
         ds_merchant_mpi_external[:dsTransID] = data[:dsTransID] if data[:dsTransID]
         ds_merchant_mpi_external[:authenticacionValue] = data[:authenticacionValue] if data[:authenticacionValue]
         ds_merchant_mpi_external[:protocolVersion] = data[:protocolVersion] if data[:protocolVersion]
-
+        ds_merchant_mpi_external[:Eci] = data[:eci_v2] if data[:eci_v2]
         ds_merchant_mpi_external[:authenticacionMethod] = data[:authenticacionMethod] if data[:authenticacionMethod]
         ds_merchant_mpi_external[:authenticacionType] = data[:authenticacionType] if data[:authenticacionType]
         ds_merchant_mpi_external[:authenticacionFlow] = data[:authenticacionFlow] if data[:authenticacionFlow]
@@ -593,7 +641,7 @@ module ActiveMerchant #:nodoc:
       def response_text(code)
         code = code.to_i
         code = 0 if code < 100
-        RESPONSE_TEXTS[code] || 'Unkown code, please check in manual'
+        RESPONSE_TEXTS[code] || 'Unknown code, please check in manual'
       end
 
       def response_text_3ds(xml, params)

data/lib/active_merchant/billing/gateways/safe_charge.rb

@@ -143,15 +143,24 @@ module ActiveMerchant #:nodoc:
         post[:sg_Descriptor] = options[:merchant_descriptor] if options[:merchant_descriptor]
         post[:sg_MerchantPhoneNumber] = options[:merchant_phone_number] if options[:merchant_phone_number]
         post[:sg_MerchantName] = options[:merchant_name] if options[:merchant_name]
+        post[:sg_ProductID] = options[:product_id] if options[:product_id]
       end
 
       def add_payment(post, payment, options = {})
-        post[:sg_NameOnCard] = payment.name
-        post[:sg_CardNumber] = payment.number
         post[:sg_ExpMonth] = format(payment.month, :two_digits)
         post[:sg_ExpYear] = format(payment.year, :two_digits)
-        post[:sg_CVV2] = payment.verification_value
-        post[:sg_StoredCredentialMode] = (options[:stored_credential_mode] == true ? 1 : 0)
+        post[:sg_CardNumber] = payment.number
+
+        if payment.is_a?(NetworkTokenizationCreditCard) && payment.source == :network_token
+          post[:sg_CAVV] = payment.payment_cryptogram
+          post[:sg_ECI] = options[:three_d_secure] && options[:three_d_secure][:eci] || '05'
+          post[:sg_IsExternalMPI] = 1
+          post[:sg_ExternalTokenProvider] = 5
+        else
+          post[:sg_CVV2] = payment.verification_value
+          post[:sg_NameOnCard] = payment.name
+          post[:sg_StoredCredentialMode] = (options[:stored_credential_mode] == true ? 1 : 0)
+        end
       end
 
       def add_customer_details(post, payment, options)
@@ -170,12 +179,14 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_external_mpi_data(post, options)
-        post[:sg_eci] = options[:three_d_secure][:eci] if options[:three_d_secure][:eci]
-        post[:sg_cavv] = options[:three_d_secure][:cavv] if options[:three_d_secure][:cavv]
+        post[:sg_ECI] = options[:three_d_secure][:eci] if options[:three_d_secure][:eci]
+        post[:sg_CAVV] = options[:three_d_secure][:cavv] if options[:three_d_secure][:cavv]
         post[:sg_dsTransID] = options[:three_d_secure][:ds_transaction_id] if options[:three_d_secure][:ds_transaction_id]
-        post[:sg_threeDSProtocolVersion] = options[:three_d_secure][:version] || (options[:three_d_secure][:ds_transaction_id] ? '2' : '1')
-        post[:sg_xid] = options[:three_d_secure][:xid]
+        post[:sg_threeDSProtocolVersion] = options[:three_d_secure][:ds_transaction_id] ? '2' : '1'
+        post[:sg_Xid] = options[:three_d_secure][:xid]
         post[:sg_IsExternalMPI] = 1
+        post[:sg_EnablePartialApproval] = options[:is_partial_approval]
+        post[:sg_challengePreference] = options[:three_d_secure][:challenge_preference] if options[:three_d_secure][:challenge_preference]
       end
 
       def parse(xml)

data/lib/active_merchant/billing/gateways/spreedly_core.rb

@@ -254,11 +254,20 @@ module ActiveMerchant #:nodoc:
       end
 
       def childnode_to_response(response, node, childnode)
-        name = "#{node.name.downcase}_#{childnode.name.downcase}"
-        if name == 'payment_method_data' && !childnode.elements.empty?
-          response[name.to_sym] = Hash.from_xml(childnode.to_s).values.first
+        node_name = node.name.downcase
+        childnode_name = childnode.name.downcase
+        composed_name = "#{node_name}_#{childnode_name}"
+
+        childnodes_present = !childnode.elements.empty?
+
+        if childnodes_present && composed_name == 'payment_method_data'
+          response[composed_name.to_sym] = Hash.from_xml(childnode.to_s).values.first
+        elsif childnodes_present && node_name == 'gateway_specific_response_fields'
+          response[node_name.to_sym] = {
+            childnode_name => Hash.from_xml(childnode.to_s).values.first
+          }
         else
-          response[name.to_sym] = childnode.text
+          response[composed_name.to_sym] = childnode.text
         end
       end
 

data/lib/active_merchant/billing/gateways/stripe.rb

@@ -279,14 +279,14 @@ module ActiveMerchant #:nodoc:
         transcript.
           gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
           gsub(%r((&?three_d_secure\[cryptogram\]=)[\w=]*(&?)), '\1[FILTERED]\2').
-          gsub(%r((card\[cryptogram\]=)[^&]+(&?)), '\1[FILTERED]\2').
-          gsub(%r((card\[cvc\]=)\d+), '\1[FILTERED]').
-          gsub(%r((card\[emv_approval_data\]=)[^&]+(&?)), '\1[FILTERED]\2').
-          gsub(%r((card\[emv_auth_data\]=)[^&]+(&?)), '\1[FILTERED]\2').
-          gsub(%r((card\[encrypted_pin\]=)[^&]+(&?)), '\1[FILTERED]\2').
-          gsub(%r((card\[encrypted_pin_key_id\]=)[\w=]+(&?)), '\1[FILTERED]\2').
-          gsub(%r((card\[number\]=)\d+), '\1[FILTERED]').
-          gsub(%r((card\[swipe_data\]=)[^&]+(&?)), '\1[FILTERED]\2')
+          gsub(%r(((\[card\]|card)\[cryptogram\]=)[^&]+(&?)), '\1[FILTERED]\3').
+          gsub(%r(((\[card\]|card)\[cvc\]=)\d+), '\1[FILTERED]').
+          gsub(%r(((\[card\]|card)\[emv_approval_data\]=)[^&]+(&?)), '\1[FILTERED]\3').
+          gsub(%r(((\[card\]|card)\[emv_auth_data\]=)[^&]+(&?)), '\1[FILTERED]\3').
+          gsub(%r(((\[card\]|card)\[encrypted_pin\]=)[^&]+(&?)), '\1[FILTERED]\3').
+          gsub(%r(((\[card\]|card)\[encrypted_pin_key_id\]=)[\w=]+(&?)), '\1[FILTERED]\3').
+          gsub(%r(((\[card\]|card)\[number\]=)\d+), '\1[FILTERED]').
+          gsub(%r(((\[card\]|card)\[swipe_data\]=)[^&]+(&?)), '\1[FILTERED]\3')
       end
 
       def supports_network_tokenization?

data/lib/active_merchant/billing/gateways/stripe_payment_intents.rb

@@ -30,6 +30,9 @@ module ActiveMerchant #:nodoc:
         add_shipping_address(post, options)
         setup_future_usage(post, options)
         add_exemption(post, options)
+        add_stored_credentials(post, options)
+        add_ntid(post, options)
+        add_error_on_requires_action(post, options)
         request_three_d_secure(post, options)
 
         CREATE_INTENT_ATTRIBUTES.each do |attribute|
@@ -55,16 +58,22 @@ module ActiveMerchant #:nodoc:
       end
 
       def create_payment_method(payment_method, options = {})
-        post = {}
-        post[:type] = 'card'
-        post[:card] = {}
-        post[:card][:number] = payment_method.number
-        post[:card][:exp_month] = payment_method.month
-        post[:card][:exp_year] = payment_method.year
-        post[:card][:cvc] = payment_method.verification_value if payment_method.verification_value
-        add_billing_address(post, options)
+        post_data = create_payment_method_data(payment_method, options)
+
         options = format_idempotency_key(options, 'pm')
-        commit(:post, 'payment_methods', post, options)
+        commit(:post, 'payment_methods', post_data, options)
+      end
+
+      def create_payment_method_data(payment_method, options = {})
+        post_data = {}
+        post_data[:type] = 'card'
+        post_data[:card] = {}
+        post_data[:card][:number] = payment_method.number
+        post_data[:card][:exp_month] = payment_method.month
+        post_data[:card][:exp_year] = payment_method.year
+        post_data[:card][:cvc] = payment_method.verification_value if payment_method.verification_value
+        add_billing_address(post_data, options)
+        post_data
       end
 
       def update_intent(money, intent_id, payment_method, options = {})
@@ -101,6 +110,17 @@ module ActiveMerchant #:nodoc:
         commit(:post, 'setup_intents', post, options)
       end
 
+      def retrieve_setup_intent(setup_intent_id)
+        # Retrieving a setup_intent passing 'expand[]=latest_attempt' allows the caller to
+        # check for a network_transaction_id and ds_transaction_id
+        # eg (latest_attempt -> payment_method_details -> card -> network_transaction_id)
+        #
+        # Being able to retrieve these fields enables payment flows that rely on MIT exemptions, e.g: off_session
+        commit(:post, "setup_intents/#{setup_intent_id}", {
+          'expand[]': 'latest_attempt'
+        }, {})
+      end
+
       def authorize(money, payment_method, options = {})
         create_intent(money, payment_method, options.merge!(confirm: true, capture_method: 'manual'))
       end
@@ -164,7 +184,6 @@ module ActiveMerchant #:nodoc:
           if options[:customer]
             customer_id = options[:customer]
           else
-            post[:validate] = options[:validate] unless options[:validate].nil?
             post[:description] = options[:description] if options[:description]
             post[:email] = options[:email] if options[:email]
             options = format_idempotency_key(options, 'customer')
@@ -172,7 +191,9 @@ module ActiveMerchant #:nodoc:
             customer_id = customer.params['id']
           end
           options = format_idempotency_key(options, 'attach')
-          commit(:post, "payment_methods/#{params[:payment_method]}/attach", { customer: customer_id }, options)
+          attach_parameters = { customer: customer_id }
+          attach_parameters[:validate] = options[:validate] unless options[:validate].nil?
+          commit(:post, "payment_methods/#{params[:payment_method]}/attach", attach_parameters, options)
         else
           super(payment_method, options)
         end
@@ -193,6 +214,10 @@ module ActiveMerchant #:nodoc:
 
       private
 
+      def off_session_request?(options = {})
+        (options[:off_session] || options[:setup_future_usage]) && options[:confirm] == true
+      end
+
       def add_connected_account(post, options = {})
         super(post, options)
         post[:application_fee_amount] = options[:application_fee] if options[:application_fee]
@@ -200,25 +225,21 @@ module ActiveMerchant #:nodoc:
 
       def add_whitelisted_attribute(post, options, attribute)
         post[attribute] = options[attribute] if options[attribute]
-        post
       end
 
       def add_capture_method(post, options)
         capture_method = options[:capture_method].to_s
         post[:capture_method] = capture_method if ALLOWED_METHOD_STATES.include?(capture_method)
-        post
       end
 
       def add_confirmation_method(post, options)
         confirmation_method = options[:confirmation_method].to_s
         post[:confirmation_method] = confirmation_method if ALLOWED_METHOD_STATES.include?(confirmation_method)
-        post
       end
 
       def add_customer(post, options)
         customer = options[:customer].to_s
         post[:customer] = customer if customer.start_with?('cus_')
-        post
       end
 
       def add_return_url(post, options)
@@ -226,22 +247,27 @@ module ActiveMerchant #:nodoc:
 
         post[:confirm] = options[:confirm]
         post[:return_url] = options[:return_url] if options[:return_url]
-        post
       end
 
       def add_payment_method_token(post, payment_method, options)
         return if payment_method.nil?
 
         if payment_method.is_a?(ActiveMerchant::Billing::CreditCard)
-          p = create_payment_method(payment_method, options)
-          return p unless p.success?
+          if off_session_request?(options)
+            post[:payment_method_data] = create_payment_method_data(payment_method, options)
+            return
+          else
+            p = create_payment_method(payment_method, options)
+            return p unless p.success?
 
-          payment_method = p.params['id']
+            payment_method = p.params['id']
+          end
         end
 
-        if payment_method.is_a?(StripePaymentToken)
+        case payment_method
+        when StripePaymentToken
           post[:payment_method] = payment_method.payment_data['id']
-        elsif payment_method.is_a?(String)
+        when String
           if payment_method.include?('|')
             customer_id, payment_method_id = payment_method.split('|')
             token = payment_method_id
@@ -251,6 +277,8 @@ module ActiveMerchant #:nodoc:
           end
           post[:payment_method] = token
         end
+
+        post
       end
 
       def add_payment_method_types(post, options)
@@ -258,7 +286,6 @@ module ActiveMerchant #:nodoc:
         return if payment_method_types.nil?
 
         post[:payment_method_types] = Array(payment_method_types)
-        post
       end
 
       def add_exemption(post, options = {})
@@ -269,6 +296,42 @@ module ActiveMerchant #:nodoc:
         post[:payment_method_options][:card][:moto] = true if options[:moto]
       end
 
+      # Stripe Payment Intents does not pass any parameters for cardholder/merchant initiated
+      # it also does not support installments for any country other than Mexico (reason for this is unknown)
+      # The only thing that Stripe PI requires for stored credentials to work currently is the network_transaction_id
+      # network_transaction_id is created when the card is authenticated using the field `setup_for_future_usage` with the value `off_session` see def setup_future_usage below
+
+      def add_stored_credentials(post, options = {})
+        return unless options[:stored_credential] && !options[:stored_credential].values.all?(&:nil?)
+
+        stored_credential = options[:stored_credential]
+        post[:payment_method_options] ||= {}
+        post[:payment_method_options][:card] ||= {}
+        post[:payment_method_options][:card][:mit_exemption] = {}
+
+        # Stripe PI accepts network_transaction_id and ds_transaction_id via mit field under card.
+        # The network_transaction_id can be sent in nested under stored credentials OR as its own field (add_ntid handles when it is sent in on its own)
+        # If it is sent is as its own field AND under stored credentials, the value sent under its own field is what will send.
+        post[:payment_method_options][:card][:mit_exemption][:ds_transaction_id] = stored_credential[:ds_transaction_id] if stored_credential[:ds_transaction_id]
+        post[:payment_method_options][:card][:mit_exemption][:network_transaction_id] = stored_credential[:network_transaction_id] if stored_credential[:network_transaction_id]
+      end
+
+      def add_ntid(post, options = {})
+        return unless options[:network_transaction_id]
+
+        post[:payment_method_options] ||= {}
+        post[:payment_method_options][:card] ||= {}
+        post[:payment_method_options][:card][:mit_exemption] = {}
+
+        post[:payment_method_options][:card][:mit_exemption][:network_transaction_id] = options[:network_transaction_id] if options[:network_transaction_id]
+      end
+
+      def add_error_on_requires_action(post, options = {})
+        return unless options[:confirm]
+
+        post[:error_on_requires_action] = true if options[:error_on_requires_action]
+      end
+
       def request_three_d_secure(post, options = {})
         return unless options[:request_three_d_secure] && %w(any automatic).include?(options[:request_three_d_secure])
 
@@ -292,7 +355,7 @@ module ActiveMerchant #:nodoc:
 
       def setup_future_usage(post, options = {})
         post[:setup_future_usage] = options[:setup_future_usage] if %w(on_session off_session).include?(options[:setup_future_usage])
-        post[:off_session] = options[:off_session] if options[:off_session] && options[:confirm] == true
+        post[:off_session] = options[:off_session] if off_session_request?(options)
         post
       end
 
@@ -310,7 +373,6 @@ module ActiveMerchant #:nodoc:
         post[:billing_details][:email] = billing[:email] if billing[:email]
         post[:billing_details][:name] = billing[:name] if billing[:name]
         post[:billing_details][:phone] = billing[:phone] if billing[:phone]
-        post
       end
 
       def add_shipping_address(post, options = {})
@@ -329,7 +391,6 @@ module ActiveMerchant #:nodoc:
         post[:shipping][:carrier] = shipping[:carrier] if shipping[:carrier]
         post[:shipping][:phone] = shipping[:phone] if shipping[:phone]
         post[:shipping][:tracking_number] = shipping[:tracking_number] if shipping[:tracking_number]
-        post
       end
 
       def format_idempotency_key(options, suffix)