activemerchant 1.133.0 → 1.137.0

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

@@ -161,11 +161,13 @@ module ActiveMerchant #:nodoc:
                    'Content-Type' => 'text/xml; charset=utf-8' }
         response_string = ssl_post(test? ? self.test_url : self.live_url, soap, headers)
         response = parse(response_string, soap_action)
-        return Response.new(response['errorcode'] == '000',
+        return Response.new(
+          response['errorcode'] == '000',
           response['errormessage'],
           response,
           test: test?,
-          authorization: response['transaction_id'])
+          authorization: response['transaction_id']
+        )
       end
 
       def build_soap(request)

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

@@ -271,11 +271,9 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def build_xml_request(root)
+      def build_xml_request(root, &block)
         builder = Nokogiri::XML::Builder.new
-        builder.__send__(root) do |doc|
-          yield(doc)
-        end
+        builder.__send__(root, &block)
         builder.to_xml
       end
 

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

@@ -7,14 +7,16 @@ module ActiveMerchant #:nodoc:
     class StripeGateway < Gateway
       self.live_url = 'https://api.stripe.com/v1/'
 
+      # Docs on AVS codes: https://en.wikipedia.org/w/index.php?title=Address_verification_service&_ga=2.97570079.1027215965.1655989706-2008268124.1655989706#AVS_response_codes
+      # possible response values: https://stripe.com/docs/api/payment_methods/object#payment_method_object-card-checks
       AVS_CODE_TRANSLATOR = {
-        'line1: pass, zip: pass' => 'Y',
         'line1: pass, zip: fail' => 'A',
         'line1: pass, zip: unchecked' => 'B',
-        'line1: fail, zip: pass' => 'Z',
+        'line1: unchecked, zip: unchecked' => 'I',
         'line1: fail, zip: fail' => 'N',
         'line1: unchecked, zip: pass' => 'P',
-        'line1: unchecked, zip: unchecked' => 'I'
+        'line1: pass, zip: pass' => 'Y',
+        'line1: fail, zip: pass' => 'Z'
       }
 
       CVC_CODE_TRANSLATOR = {
@@ -292,7 +294,9 @@ module ActiveMerchant #:nodoc:
           gsub(%r(((\[card\]|card)\[number\]=)\d+), '\1[FILTERED]').
           gsub(%r(((\[card\]|card)\[swipe_data\]=)[^&]+(&?)), '\1[FILTERED]\3').
           gsub(%r(((\[bank_account\]|bank_account)\[account_number\]=)\d+), '\1[FILTERED]').
-          gsub(%r(((\[payment_method_data\]|payment_method_data)\[card\]\[token\]=)[^&]+(&?)), '\1[FILTERED]\3')
+          gsub(%r(((\[payment_method_data\]|payment_method_data)\[card\]\[token\]=)[^&]+(&?)), '\1[FILTERED]\3').
+          gsub(%r(((\[payment_method_data\]|payment_method_data)\[card\]\[network_token\]\[number\]=)\d+), '\1[FILTERED]').
+          gsub(%r(((\[payment_method_options\]|payment_method_options)\[card\]\[network_token\]\[cryptogram\]=)[^&]+(&?)), '\1[FILTERED]')
       end
 
       def supports_network_tokenization?
@@ -577,7 +581,7 @@ module ActiveMerchant #:nodoc:
 
       def add_source_owner(post, creditcard, options)
         post[:owner] = {}
-        post[:owner][:name] = creditcard.name if creditcard.name
+        post[:owner][:name] = creditcard.name if creditcard.respond_to?(:name) && creditcard.name
         post[:owner][:email] = options[:email] if options[:email]
 
         if address = options[:billing_address] || options[:address]
@@ -613,8 +617,21 @@ module ActiveMerchant #:nodoc:
         post[:radar_options] = radar_options unless radar_options.empty?
       end
 
+      def add_header_fields(response)
+        return unless @response_headers.present?
+
+        headers = {}
+        headers['response_headers'] = {}
+        headers['response_headers']['idempotent_replayed'] = @response_headers['idempotent-replayed'] if @response_headers['idempotent-replayed']
+        headers['response_headers']['stripe_should_retry'] = @response_headers['stripe-should-retry'] if @response_headers['stripe-should-retry']
+
+        response.merge!(headers)
+      end
+
       def parse(body)
-        JSON.parse(body)
+        response = JSON.parse(body)
+        add_header_fields(response)
+        response
       end
 
       def post_data(params)
@@ -695,46 +712,46 @@ module ActiveMerchant #:nodoc:
 
       def commit(method, url, parameters = nil, options = {})
         add_expand_parameters(parameters, options) if parameters
-
         return Response.new(false, 'Invalid API Key provided') unless key_valid?(options)
 
         response = api_request(method, url, parameters, options)
         response['webhook_id'] = options[:webhook_id] if options[:webhook_id]
         success = success_from(response, options)
 
-        card = card_from_response(response)
-        avs_code = AVS_CODE_TRANSLATOR["line1: #{card['address_line1_check']}, zip: #{card['address_zip_check']}"]
-        cvc_code = CVC_CODE_TRANSLATOR[card['cvc_check']]
-        Response.new(success,
+        card_checks = card_from_response(response)
+        avs_code = AVS_CODE_TRANSLATOR["line1: #{card_checks['address_line1_check']}, zip: #{card_checks['address_zip_check'] || card_checks['address_postal_code_check']}"]
+        cvc_code = CVC_CODE_TRANSLATOR[card_checks['cvc_check']]
+        Response.new(
+          success,
           message_from(success, response),
           response,
           test: response_is_test?(response),
-          authorization: authorization_from(success, url, method, response),
+          authorization: authorization_from(success, url, method, response, options),
           avs_result: { code: avs_code },
           cvv_result: cvc_code,
           emv_authorization: emv_authorization_from_response(response),
-          error_code: success ? nil : error_code_from(response))
+          error_code: success ? nil : error_code_from(response)
+        )
       end
 
       def key_valid?(options)
         return true unless test?
 
         %w(sk rk).each do |k|
-          if key(options).start_with?(k)
-            return false unless key(options).start_with?("#{k}_test")
-          end
+          return false if key(options).start_with?(k) && !key(options).start_with?("#{k}_test")
         end
 
         true
       end
 
-      def authorization_from(success, url, method, response)
-        return response.fetch('error', {})['charge'] unless success
+      def authorization_from(success, url, method, response, options)
+        return response.dig('error', 'charge') || response.dig('error', 'setup_intent', 'id') || response['id'] unless success
 
         if url == 'customers'
           [response['id'], response.dig('sources', 'data').first&.dig('id')].join('|')
-        elsif method == :post && (url.match(/customers\/.*\/cards/) || url.match(/payment_methods\/.*\/attach/))
-          [response['customer'], response['id']].join('|')
+        elsif method == :post && (url.match(/customers\/.*\/cards/) || url.match(/payment_methods\/.*\/attach/) || options[:action] == :store)
+          response_id = options[:action] == :store ? response['payment_method'] : response['id']
+          [response['customer'], response_id].join('|')
         else
           response['id']
         end
@@ -748,6 +765,18 @@ module ActiveMerchant #:nodoc:
         !response.key?('error') && response['status'] != 'failed'
       end
 
+      # Override the regular handle response so we can access the headers
+      # set header fields and values so we can add them to the response body
+      def handle_response(response)
+        @response_headers = response.each_header.to_h if response.respond_to?(:header)
+        case response.code.to_i
+        when 200...300
+          response.body
+        else
+          raise ResponseError.new(response)
+        end
+      end
+
       def response_error(raw_response)
         parse(raw_response)
       rescue JSON::ParserError
@@ -783,7 +812,10 @@ module ActiveMerchant #:nodoc:
       end
 
       def card_from_response(response)
-        response['card'] || response['active_card'] || response['source'] || {}
+        # StripePI puts the AVS and CVC check significantly deeper into the response object
+        response['card'] || response['active_card'] || response['source'] ||
+          response.dig('charges', 'data', 0, 'payment_method_details', 'card', 'checks') ||
+          response.dig('latest_attempt', 'payment_method_details', 'card', 'checks') || {}
       end
 
       def emv_authorization_from_response(response)

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

@@ -11,10 +11,15 @@ module ActiveMerchant #:nodoc:
       CONFIRM_INTENT_ATTRIBUTES = %i[receipt_email return_url save_payment_method setup_future_usage off_session]
       UPDATE_INTENT_ATTRIBUTES = %i[description statement_descriptor_suffix statement_descriptor receipt_email setup_future_usage]
       DEFAULT_API_VERSION = '2020-08-27'
+      DIGITAL_WALLETS = {
+        apple_pay: 'apple_pay',
+        google_pay: 'google_pay_dpan',
+        untokenized_google_pay: 'google_pay_ecommerce_token'
+      }
 
       def create_intent(money, payment_method, options = {})
         MultiResponse.run do |r|
-          if payment_method.is_a?(NetworkTokenizationCreditCard)
+          if payment_method.is_a?(NetworkTokenizationCreditCard) && digital_wallet_payment_method?(payment_method) && options[:new_ap_gp_route] != true
             r.process { tokenize_apple_google(payment_method, options) }
             payment_method = (r.params['token']['id']) if r.success?
           end
@@ -25,9 +30,15 @@ module ActiveMerchant #:nodoc:
             add_confirmation_method(post, options)
             add_customer(post, options)
 
-            result = add_payment_method_token(post, payment_method, options)
-            return result if result.is_a?(ActiveMerchant::Billing::Response)
+            if new_apple_google_pay_flow(payment_method, options)
+              add_digital_wallet(post, payment_method, options)
+              add_billing_address(post, payment_method, options)
+            else
+              result = add_payment_method_token(post, payment_method, options)
+              return result if result.is_a?(ActiveMerchant::Billing::Response)
+            end
 
+            add_network_token_cryptogram_and_eci(post, payment_method)
             add_external_three_d_secure_auth_data(post, options)
             add_metadata(post, options)
             add_return_url(post, options)
@@ -43,6 +54,8 @@ module ActiveMerchant #:nodoc:
             add_fulfillment_date(post, options)
             request_three_d_secure(post, options)
             add_level_three(post, options)
+            add_card_brand(post, options)
+            post[:expand] = ['charges.data.balance_transaction']
 
             CREATE_INTENT_ATTRIBUTES.each do |attribute|
               add_whitelisted_attribute(post, options, attribute)
@@ -63,8 +76,12 @@ module ActiveMerchant #:nodoc:
 
       def confirm_intent(intent_id, payment_method, options = {})
         post = {}
-        result = add_payment_method_token(post, payment_method, options)
-        return result if result.is_a?(ActiveMerchant::Billing::Response)
+        if new_apple_google_pay_flow(payment_method, options)
+          add_digital_wallet(post, payment_method, options)
+        else
+          result = add_payment_method_token(post, payment_method, options)
+          return result if result.is_a?(ActiveMerchant::Billing::Response)
+        end
 
         add_payment_method_types(post, options)
         CONFIRM_INTENT_ATTRIBUTES.each do |attribute|
@@ -80,22 +97,28 @@ module ActiveMerchant #:nodoc:
         commit(:post, 'payment_methods', post_data, options)
       end
 
+      def new_apple_google_pay_flow(payment_method, options)
+        return false unless options[:new_ap_gp_route]
+
+        payment_method.is_a?(NetworkTokenizationCreditCard) && digital_wallet_payment_method?(payment_method)
+      end
+
       def add_payment_method_data(payment_method, options = {})
         post = {
           type: 'card',
           card: {
-            number: payment_method.number,
             exp_month: payment_method.month,
             exp_year: payment_method.year
           }
         }
-
+        post[:card][:number] = payment_method.number unless adding_network_token_card_data?(payment_method)
         post[:card][:cvc] = payment_method.verification_value if payment_method.verification_value
         if billing = options[:billing_address] || options[:address]
           post[:billing_details] = add_address(billing, options)
         end
 
         add_name_only(post, payment_method) if post[:billing_details].nil?
+        add_network_token_data(post, payment_method, options)
         post
       end
 
@@ -110,8 +133,12 @@ module ActiveMerchant #:nodoc:
         post = {}
         add_amount(post, money, options)
 
-        result = add_payment_method_token(post, payment_method, options)
-        return result if result.is_a?(ActiveMerchant::Billing::Response)
+        if new_apple_google_pay_flow(payment_method, options)
+          add_digital_wallet(post, payment_method, options)
+        else
+          result = add_payment_method_token(post, payment_method, options)
+          return result if result.is_a?(ActiveMerchant::Billing::Response)
+        end
 
         add_payment_method_types(post, options)
         add_customer(post, options)
@@ -131,16 +158,25 @@ module ActiveMerchant #:nodoc:
           r.process do
             post = {}
             add_customer(post, options)
-            result = add_payment_method_token(post, payment_method, options, r)
-            return result if result.is_a?(ActiveMerchant::Billing::Response)
+
+            if new_apple_google_pay_flow(payment_method, options)
+              add_digital_wallet(post, payment_method, options)
+              add_billing_address(post, payment_method, options)
+            else
+              result = add_payment_method_token(post, payment_method, options, r)
+              return result if result.is_a?(ActiveMerchant::Billing::Response)
+            end
 
             add_metadata(post, options)
             add_return_url(post, options)
             add_fulfillment_date(post, options)
             request_three_d_secure(post, options)
+            add_card_brand(post, options)
+            add_exemption(post, options)
             post[:on_behalf_of] = options[:on_behalf_of] if options[:on_behalf_of]
             post[:usage] = options[:usage] if %w(on_session off_session).include?(options[:usage])
             post[:description] = options[:description] if options[:description]
+            post[:expand] = ['latest_attempt']
 
             commit(:post, 'setup_intents', post, options)
           end
@@ -210,14 +246,16 @@ module ActiveMerchant #:nodoc:
       # All other types will default to legacy Stripe store
       def store(payment_method, options = {})
         params = {}
-        post = {}
         # If customer option is provided, create a payment method and attach to customer id
         # Otherwise, create a customer, then attach
-        if payment_method.is_a?(StripePaymentToken) || payment_method.is_a?(ActiveMerchant::Billing::CreditCard)
+        if new_apple_google_pay_flow(payment_method, options)
+          options[:customer] = customer(payment_method, options).params['id'] unless options[:customer]
+          verify(payment_method, options.merge!(action: :store))
+        elsif payment_method.is_a?(StripePaymentToken) || payment_method.is_a?(ActiveMerchant::Billing::CreditCard)
           result = add_payment_method_token(params, payment_method, options)
           return result if result.is_a?(ActiveMerchant::Billing::Response)
 
-          customer_id = options[:customer] || customer(post, payment_method, options).params['id']
+          customer_id = options[:customer] || customer(payment_method, options).params['id']
           options = format_idempotency_key(options, 'attach')
           attach_parameters = { customer: customer_id }
           attach_parameters[:validate] = options[:validate] unless options[:validate].nil?
@@ -227,7 +265,8 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def customer(post, payment, options)
+      def customer(payment, options)
+        post = {}
         post[:description] = options[:description] if options[:description]
         post[:expand] = [:sources]
         post[:email] = options[:email]
@@ -267,8 +306,22 @@ module ActiveMerchant #:nodoc:
         commit(:post, 'payment_intents', post, options)
       end
 
+      def supports_network_tokenization?
+        true
+      end
+
       private
 
+      def digital_wallet_payment_method?(payment_method)
+        payment_method.source == :google_pay || payment_method.source == :apple_pay
+      end
+
+      def adding_network_token_card_data?(payment_method)
+        return true if payment_method.is_a?(ActiveMerchant::Billing::NetworkTokenizationCreditCard) && payment_method.source == :network_token
+
+        false
+      end
+
       def off_session_request?(options = {})
         (options[:off_session] || options[:setup_future_usage]) && options[:confirm] == true
       end
@@ -307,6 +360,14 @@ module ActiveMerchant #:nodoc:
         post[:metadata][:event_type] = options[:event_type] if options[:event_type]
       end
 
+      def add_card_brand(post, options)
+        return unless options[:card_brand]
+
+        post[:payment_method_options] ||= {}
+        post[:payment_method_options][:card] ||= {}
+        post[:payment_method_options][:card][:network] = options[:card_brand] if options[:card_brand]
+      end
+
       def add_level_three(post, options = {})
         level_three = {}
 
@@ -343,6 +404,72 @@ module ActiveMerchant #:nodoc:
           return create_payment_method_and_extract_token(post, payment_method, options, responses) if options[:verify]
 
           get_payment_method_data_from_card(post, payment_method, options, responses)
+        when ActiveMerchant::Billing::NetworkTokenizationCreditCard
+          get_payment_method_data_from_card(post, payment_method, options, responses)
+        end
+      end
+
+      def add_network_token_data(post_data, payment_method, options)
+        return unless adding_network_token_card_data?(payment_method)
+
+        post_data[:card] ||= {}
+        post_data[:card][:last4] = options[:last_4]
+        post_data[:card][:network_token] = {}
+        post_data[:card][:network_token][:number] = payment_method.number
+        post_data[:card][:network_token][:exp_month] = payment_method.month
+        post_data[:card][:network_token][:exp_year] = payment_method.year
+        post_data[:card][:network_token][:payment_account_reference] = options[:payment_account_reference] if options[:payment_account_reference]
+
+        post_data
+      end
+
+      def add_network_token_cryptogram_and_eci(post, payment_method)
+        return unless adding_network_token_card_data?(payment_method)
+
+        post[:payment_method_options] ||= {}
+        post[:payment_method_options][:card] ||= {}
+        post[:payment_method_options][:card][:network_token] ||= {}
+        post[:payment_method_options][:card][:network_token][:cryptogram] = payment_method.payment_cryptogram if payment_method.payment_cryptogram
+        post[:payment_method_options][:card][:network_token][:electronic_commerce_indicator] = payment_method.eci if payment_method.eci
+      end
+
+      def add_digital_wallet(post, payment_method, options)
+        post[:payment_method_data] = {
+          type: 'card',
+          card: {
+            last4: options[:last_4] || payment_method.number[-4..],
+            exp_month: payment_method.month,
+            exp_year: payment_method.year,
+            network_token: {
+              number: payment_method.number,
+              exp_month: payment_method.month,
+              exp_year: payment_method.year
+            }
+          }
+        }
+
+        add_cryptogram_and_eci(post, payment_method, options) unless options[:wallet_type]
+        source = payment_method.respond_to?(:source) ? payment_method.source : options[:wallet_type]
+        post[:payment_method_data][:card][:network_token][:tokenization_method] = DIGITAL_WALLETS[source]
+      end
+
+      def add_cryptogram_and_eci(post, payment_method, options)
+        post[:payment_method_options] ||= {}
+        post[:payment_method_options][:card] ||= {}
+        post[:payment_method_options][:card][:network_token] ||= {}
+        post[:payment_method_options][:card][:network_token] = {
+          cryptogram: payment_method.respond_to?(:payment_cryptogram) ? payment_method.payment_cryptogram : options[:cryptogram],
+          electronic_commerce_indicator: format_eci(payment_method, options)
+        }.compact
+      end
+
+      def format_eci(payment_method, options)
+        eci_value = payment_method.respond_to?(:eci) ? payment_method.eci : options[:eci]
+
+        if eci_value&.length == 1
+          "0#{eci_value}"
+        else
+          eci_value
         end
       end
 
@@ -384,7 +511,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def get_payment_method_data_from_card(post, payment_method, options, responses)
-        return create_payment_method_and_extract_token(post, payment_method, options, responses) unless off_session_request?(options)
+        return create_payment_method_and_extract_token(post, payment_method, options, responses) unless off_session_request?(options) || adding_network_token_card_data?(payment_method)
 
         post[:payment_method_data] = add_payment_method_data(payment_method, options)
       end
@@ -405,7 +532,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_exemption(post, options = {})
-        return unless options[:confirm]
+        return unless options[:confirm] && options[:moto]
 
         post[:payment_method_options] ||= {}
         post[:payment_method_options][:card] ||= {}
@@ -418,63 +545,71 @@ module ActiveMerchant #:nodoc:
       # the existing logic by default. To be able to utilize this field, you must reach out to Stripe.
 
       def add_stored_credentials(post, options = {})
-        return unless options[:stored_credential] && !options[:stored_credential].values.all?(&:nil?)
+        stored_credential = options[:stored_credential]
+        return unless stored_credential && !stored_credential.values.all?(&:nil?)
 
         post[:payment_method_options] ||= {}
         post[:payment_method_options][:card] ||= {}
-        add_stored_credential_transaction_type(post, options) if options[:stored_credential_transaction_type]
 
-        stored_credential = options[:stored_credential]
-        post[:payment_method_options][:card][:mit_exemption] = {}
+        card_options = post[:payment_method_options][:card]
+        card_options[: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]
+        card_options[:mit_exemption][:ds_transaction_id] = stored_credential[:ds_transaction_id] if stored_credential[:ds_transaction_id]
+        card_options[:mit_exemption][:network_transaction_id] = stored_credential[:network_transaction_id] if !(options[:setup_future_usage] == 'off_session') && (stored_credential[:network_transaction_id])
+
+        add_stored_credential_transaction_type(post, options)
       end
 
       def add_stored_credential_transaction_type(post, options = {})
+        return unless options[:stored_credential_transaction_type]
+
         stored_credential = options[:stored_credential]
         # Do not add anything unless these are present.
         return unless stored_credential[:reason_type] && stored_credential[:initiator]
 
         # Not compatible with off_session parameter.
         options.delete(:off_session)
-        if stored_credential[:initial_transaction]
-          # Initial transactions must by CIT
-          return unless stored_credential[:initiator] == 'cardholder'
 
-          initial_transaction_stored_credential(post, stored_credential[:reason_type])
-        else
-          # Subsequent transaction
-          subsequent_transaction_stored_credential(post, stored_credential[:initiator], stored_credential[:reason_type])
-        end
+        stored_credential_type = if stored_credential[:initial_transaction]
+                                   return unless stored_credential[:initiator] == 'cardholder'
+
+                                   initial_transaction_stored_credential(post, stored_credential)
+                                 else
+                                   subsequent_transaction_stored_credential(post, stored_credential)
+                                 end
+
+        card_options = post[:payment_method_options][:card]
+        card_options[:stored_credential_transaction_type] = stored_credential_type
+        card_options[:mit_exemption].delete(:network_transaction_id) if stored_credential_type == 'setup_on_session'
       end
 
-      def initial_transaction_stored_credential(post, reason_type)
-        if reason_type == 'unscheduled'
+      def initial_transaction_stored_credential(post, stored_credential)
+        case stored_credential[:reason_type]
+        when 'unscheduled'
           # Charge on-session and store card for future one-off payment use
-          post[:payment_method_options][:card][:stored_credential_transaction_type] = 'setup_off_session_unscheduled'
-        elsif reason_type == 'recurring'
+          'setup_off_session_unscheduled'
+        when 'recurring'
           # Charge on-session and store card for future recurring payment use
-          post[:payment_method_options][:card][:stored_credential_transaction_type] = 'setup_off_session_recurring'
+          'setup_off_session_recurring'
         else
           # Charge on-session and store card for future on-session payment use.
-          post[:payment_method_options][:card][:stored_credential_transaction_type] = 'setup_on_session'
+          'setup_on_session'
         end
       end
 
-      def subsequent_transaction_stored_credential(post, initiator, reason_type)
-        if initiator == 'cardholder'
+      def subsequent_transaction_stored_credential(post, stored_credential)
+        if stored_credential[:initiator] == 'cardholder'
           # Charge on-session customer using previously stored card.
-          post[:payment_method_options][:card][:stored_credential_transaction_type] = 'stored_on_session'
-        elsif reason_type == 'recurring'
+          'stored_on_session'
+        elsif stored_credential[:reason_type] == 'recurring'
           # Charge off-session customer using previously stored card for recurring transaction
-          post[:payment_method_options][:card][:stored_credential_transaction_type] = 'stored_off_session_recurring'
+          'stored_off_session_recurring'
         else
           # Charge off-session customer using previously stored card for one-off transaction
-          post[:payment_method_options][:card][:stored_credential_transaction_type] = 'stored_off_session_unscheduled'
+          'stored_off_session_unscheduled'
         end
       end
 
@@ -485,7 +620,7 @@ module ActiveMerchant #:nodoc:
         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]
+        post[:payment_method_options][:card][:mit_exemption][:network_transaction_id] = options[:network_transaction_id]
       end
 
       def add_claim_without_transaction_id(post, options = {})
@@ -501,6 +636,16 @@ module ActiveMerchant #:nodoc:
         post[:payment_method_options][:card][:mit_exemption][:claim_without_transaction_id] = options[:claim_without_transaction_id]
       end
 
+      def add_billing_address_for_card_tokenization(post, options = {})
+        return unless (billing = options[:billing_address] || options[:address])
+
+        billing = add_address(billing, options)
+        billing[:address].transform_keys! { |k| k == :postal_code ? :address_zip : k.to_s.prepend('address_').to_sym }
+
+        post[:card][:name] = billing[:name]
+        post[:card].merge!(billing[:address])
+      end
+
       def add_error_on_requires_action(post, options = {})
         return unless options[:confirm]
 
@@ -534,14 +679,18 @@ module ActiveMerchant #:nodoc:
         post
       end
 
-      def add_billing_address_for_card_tokenization(post, options = {})
-        return unless (billing = options[:billing_address] || options[:address])
+      def add_billing_address(post, payment_method, options = {})
+        return if payment_method.nil? || payment_method.is_a?(StripePaymentToken) || payment_method.is_a?(String)
 
-        billing = add_address(billing, options)
-        billing[:address].transform_keys! { |k| k == :postal_code ? :address_zip : k.to_s.prepend('address_').to_sym }
+        post[:payment_method_data] ||= {}
+        if billing = options[:billing_address] || options[:address]
+          post[:payment_method_data][:billing_details] = add_address(billing, options)
+        end
 
-        post[:card][:name] = billing[:name]
-        post[:card].merge!(billing[:address])
+        unless post[:payment_method_data][:billing_details]
+          name = [payment_method.first_name, payment_method.last_name].compact.join(' ')
+          post[:payment_method_data][:billing_details] = { name: name }
+        end
       end
 
       def add_shipping_address(post, options = {})