activemerchant 1.130.0 → 1.137.0

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

@@ -17,15 +17,7 @@ module ActiveMerchant #:nodoc:
       TEST_ACCESS_TOKEN_URL = 'https://access.sandbox.checkout.com/connect/token'
 
       def initialize(options = {})
-        @options = options
-        @access_token = nil
-
-        if options.has_key?(:secret_key)
-          requires!(options, :secret_key)
-        else
-          requires!(options, :client_id, :client_secret)
-          @access_token = setup_access_token
-        end
+        options.has_key?(:secret_key) ? requires!(options, :secret_key) : requires!(options, :client_id, :client_secret)
 
         super
       end
@@ -41,6 +33,7 @@ module ActiveMerchant #:nodoc:
         post = {}
         post[:capture] = false
         build_auth_or_purchase(post, amount, payment_method, options)
+
         options[:incremental_authorization] ? commit(:incremental_authorize, post, options, options[:incremental_authorization]) : commit(:authorize, post, options)
       end
 
@@ -57,12 +50,13 @@ module ActiveMerchant #:nodoc:
 
       def credit(amount, payment, options = {})
         post = {}
-        post[:instruction] = {}
-        post[:instruction][:funds_transfer_type] = options[:funds_transfer_type] || 'FD'
         add_processing_channel(post, options)
         add_invoice(post, amount, options)
         add_payment_method(post, payment, options, :destination)
         add_source(post, options)
+        add_instruction_data(post, options)
+        add_payout_sender_data(post, options)
+        add_payout_destination_data(post, options)
 
         commit(:credit, post, options)
       end
@@ -87,7 +81,7 @@ module ActiveMerchant #:nodoc:
         authorize(0, credit_card, options)
       end
 
-      def verify_payment(authorization, option = {})
+      def verify_payment(authorization, options = {})
         commit(:verify_payment, nil, options, authorization, :get)
       end
 
@@ -102,7 +96,8 @@ module ActiveMerchant #:nodoc:
           gsub(/("cvv\\":\\")\d+/, '\1[FILTERED]').
           gsub(/("cryptogram\\":\\")\w+/, '\1[FILTERED]').
           gsub(/(source\\":\{.*\\"token\\":\\")\d+/, '\1[FILTERED]').
-          gsub(/("token\\":\\")\w+/, '\1[FILTERED]')
+          gsub(/("token\\":\\")\w+/, '\1[FILTERED]').
+          gsub(/("access_token\\?"\s*:\s*\\?")[^"]*\w+/, '\1[FILTERED]')
       end
 
       def store(payment_method, options = {})
@@ -139,6 +134,7 @@ module ActiveMerchant #:nodoc:
         add_authorization_type(post, options)
         add_payment_method(post, payment_method, options)
         add_customer_data(post, options)
+        add_extra_customer_data(post, payment_method, options)
         add_shipping_address(post, options)
         add_stored_credential_options(post, options)
         add_transaction_data(post, options)
@@ -146,6 +142,11 @@ module ActiveMerchant #:nodoc:
         add_metadata(post, options, payment_method)
         add_processing_channel(post, options)
         add_marketplace_data(post, options)
+        add_recipient_data(post, options)
+        add_processing_data(post, options)
+        add_payment_sender_data(post, options)
+        add_risk_data(post, options)
+        truncate_amex_reference_id(post, options, payment_method)
       end
 
       def add_invoice(post, money, options)
@@ -161,6 +162,90 @@ module ActiveMerchant #:nodoc:
         post[:metadata][:udf5] = application_id || 'ActiveMerchant'
       end
 
+      def truncate_amex_reference_id(post, options, payment_method)
+        post[:reference] = truncate(options[:order_id], 30) if payment_method.respond_to?(:brand) && payment_method.brand == 'american_express'
+      end
+
+      def add_recipient_data(post, options)
+        return unless options[:recipient].is_a?(Hash)
+
+        recipient = options[:recipient]
+
+        post[:recipient] = {}
+        post[:recipient][:dob] = recipient[:dob] if recipient[:dob]
+        post[:recipient][:zip] = recipient[:zip] if recipient[:zip]
+        post[:recipient][:account_number] = recipient[:account_number] if recipient[:account_number]
+        post[:recipient][:first_name] = recipient[:first_name] if recipient[:first_name]
+        post[:recipient][:last_name] = recipient[:last_name] if recipient[:last_name]
+
+        if address = recipient[:address]
+          address1 = address[:address1] || address[:address_line1]
+          address2 = address[:address2] || address[:address_line2]
+
+          post[:recipient][:address] = {}
+          post[:recipient][:address][:address_line1] = address1 if address1
+          post[:recipient][:address][:address_line2] = address2 if address2
+          post[:recipient][:address][:city] = address[:city] if address[:city]
+          post[:recipient][:address][:state] = address[:state] if address[:state]
+          post[:recipient][:address][:zip] = address[:zip] if address[:zip]
+          post[:recipient][:address][:country] = address[:country] if address[:country]
+        end
+      end
+
+      def add_processing_data(post, options)
+        return unless options[:processing].is_a?(Hash)
+
+        post[:processing] = options[:processing]
+      end
+
+      def add_risk_data(post, options)
+        return unless options[:risk].is_a?(Hash)
+
+        risk = options[:risk]
+        post[:risk] = {} unless risk.empty?
+
+        if risk[:enabled].to_s == 'true'
+          post[:risk][:enabled] = true
+          post[:risk][:device_session_id] = risk[:device_session_id] if risk[:device_session_id]
+        elsif risk[:enabled].to_s == 'false'
+          post[:risk][:enabled] = false
+        end
+      end
+
+      def add_payment_sender_data(post, options)
+        return unless options[:sender].is_a?(Hash)
+
+        sender = options[:sender]
+
+        post[:sender] = {}
+        post[:sender][:type] = sender[:type] if sender[:type]
+        post[:sender][:first_name] = sender[:first_name] if sender[:first_name]
+        post[:sender][:last_name] = sender[:last_name] if sender[:last_name]
+        post[:sender][:dob] = sender[:dob] if sender[:dob]
+        post[:sender][:reference] = sender[:reference] if sender[:reference]
+        post[:sender][:company_name] = sender[:company_name] if sender[:company_name]
+
+        if address = sender[:address]
+          address1 = address[:address1] || address[:address_line1]
+          address2 = address[:address2] || address[:address_line2]
+
+          post[:sender][:address] = {}
+          post[:sender][:address][:address_line1] = address1 if address1
+          post[:sender][:address][:address_line2] = address2 if address2
+          post[:sender][:address][:city] = address[:city] if address[:city]
+          post[:sender][:address][:state] = address[:state] if address[:state]
+          post[:sender][:address][:zip] = address[:zip] if address[:zip]
+          post[:sender][:address][:country] = address[:country] if address[:country]
+        end
+
+        if identification = sender[:identification]
+          post[:sender][:identification] = {}
+          post[:sender][:identification][:type] = identification[:type] if identification[:type]
+          post[:sender][:identification][:number] = identification[:number] if identification[:number]
+          post[:sender][:identification][:issuing_country] = identification[:issuing_country] if identification[:issuing_country]
+        end
+      end
+
       def add_authorization_type(post, options)
         post[:authorization_type] = options[:authorization_type] if options[:authorization_type]
       end
@@ -172,6 +257,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_payment_method(post, payment_method, options, key = :source)
+        # the key = :destination when this method is called in def credit
         post[key] = {}
         case payment_method
         when NetworkTokenizationCreditCard
@@ -189,13 +275,23 @@ module ActiveMerchant #:nodoc:
           post[key][:type] = 'card'
           post[key][:name] = payment_method.name
           post[key][:number] = payment_method.number
-          post[key][:cvv] = payment_method.verification_value
+          post[key][:cvv] = payment_method.verification_value unless options[:funds_transfer_type]
           post[key][:stored] = 'true' if options[:card_on_file] == true
+
+          # because of the way the key = is implemented in the method signature, some of the destination
+          # data will be added here, some in the destination specific method below.
+          # at first i was going to move this, but since this data is coming from the payment method
+          # i think it makes sense to leave it
           if options[:account_holder_type]
             post[key][:account_holder] = {}
             post[key][:account_holder][:type] = options[:account_holder_type]
-            post[key][:account_holder][:first_name] = payment_method.first_name if payment_method.first_name
-            post[key][:account_holder][:last_name] = payment_method.last_name if payment_method.last_name
+
+            if options[:account_holder_type] == 'corporate' || options[:account_holder_type] == 'government'
+              post[key][:account_holder][:company_name] = payment_method.name if payment_method.respond_to?(:name)
+            else
+              post[key][:account_holder][:first_name] = payment_method.first_name if payment_method.first_name
+              post[key][:account_holder][:last_name] = payment_method.last_name if payment_method.last_name
+            end
           else
             post[key][:first_name] = payment_method.first_name if payment_method.first_name
             post[key][:last_name] = payment_method.last_name if payment_method.last_name
@@ -239,6 +335,15 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      # created a separate method for these fields because they should not be included
+      # in all transaction types that include methods with source and customer fields
+      def add_extra_customer_data(post, payment_method, options)
+        post[:source][:phone] = {}
+        post[:source][:phone][:number] = options[:phone] || options.dig(:billing_address, :phone) || options.dig(:billing_address, :phone_number)
+        post[:source][:phone][:country_code] = options[:phone_country_code] if options[:phone_country_code]
+        post[:customer][:name] = payment_method.name if payment_method.respond_to?(:name)
+      end
+
       def add_shipping_address(post, options)
         if address = options[:shipping_address]
           post[:shipping] = {}
@@ -266,7 +371,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_stored_credentials_using_normalized_fields(post, options)
-        if options[:stored_credential][:initial_transaction] == true
+        if options[:stored_credential][:initiator] == 'cardholder'
           post[:merchant_initiated] = false
         else
           post[:source][:stored] = true
@@ -311,6 +416,82 @@ module ActiveMerchant #:nodoc:
         post[:processing_channel_id] = options[:processing_channel_id] if options[:processing_channel_id]
       end
 
+      def add_instruction_data(post, options)
+        post[:instruction] = {}
+        post[:instruction][:funds_transfer_type] = options[:funds_transfer_type] || 'FD'
+        post[:instruction][:purpose] = options[:instruction_purpose] if options[:instruction_purpose]
+      end
+
+      def add_payout_sender_data(post, options)
+        return unless options[:payout] == true
+
+        post[:sender] = {
+          # options for type are individual, corporate, or government
+          type: options[:sender][:type],
+          # first and last name required if sent by type: individual
+          first_name: options[:sender][:first_name],
+          middle_name: options[:sender][:middle_name],
+          last_name: options[:sender][:last_name],
+          # company name required if sent by type: corporate or government
+          company_name: options[:sender][:company_name],
+          # these are required fields for payout, may not work if address is blank or different than cardholder(option for sender to be a company or government).
+          # may need to still include in GSF hash.
+
+          address: {
+            address_line1: options.dig(:sender, :address, :address1),
+            address_line2: options.dig(:sender, :address, :address2),
+            city: options.dig(:sender, :address, :city),
+            state: options.dig(:sender, :address, :state),
+            country: options.dig(:sender, :address, :country),
+            zip: options.dig(:sender, :address, :zip)
+          }.compact,
+          reference: options[:sender][:reference],
+          reference_type: options[:sender][:reference_type],
+          source_of_funds: options[:sender][:source_of_funds],
+          # identification object is conditional. required when card metadata issuer_country = AR, BR, CO, or PR
+          # checkout docs say PR (Peru), but PR is puerto rico and PE is Peru so yikes
+          identification: {
+            type: options.dig(:sender, :identification, :type),
+            number: options.dig(:sender, :identification, :number),
+            issuing_country: options.dig(:sender, :identification, :issuing_country),
+            date_of_expiry: options.dig(:sender, :identification, :date_of_expiry)
+          }.compact,
+          date_of_birth: options[:sender][:date_of_birth],
+          country_of_birth: options[:sender][:country_of_birth],
+          nationality: options[:sender][:nationality]
+        }.compact
+      end
+
+      def add_payout_destination_data(post, options)
+        return unless options[:payout] == true
+
+        post[:destination] ||= {}
+        post[:destination][:account_holder] ||= {}
+        post[:destination][:account_holder][:email] = options[:destination][:account_holder][:email] if options[:destination][:account_holder][:email]
+        post[:destination][:account_holder][:date_of_birth] = options[:destination][:account_holder][:date_of_birth] if options[:destination][:account_holder][:date_of_birth]
+        post[:destination][:account_holder][:country_of_birth] = options[:destination][:account_holder][:country_of_birth] if options[:destination][:account_holder][:country_of_birth]
+        # below fields only required during a card to card payout
+        post[:destination][:account_holder][:phone] = {}
+        post[:destination][:account_holder][:phone][:country_code] = options.dig(:destination, :account_holder, :phone, :country_code) if options.dig(:destination, :account_holder, :phone, :country_code)
+        post[:destination][:account_holder][:phone][:number] = options.dig(:destination, :account_holder, :phone, :number) if options.dig(:destination, :account_holder, :phone, :number)
+
+        post[:destination][:account_holder][:identification] = {}
+        post[:destination][:account_holder][:identification][:type] = options.dig(:destination, :account_holder, :identification, :type) if options.dig(:destination, :account_holder, :identification, :type)
+        post[:destination][:account_holder][:identification][:number] = options.dig(:destination, :account_holder, :identification, :number) if options.dig(:destination, :account_holder, :identification, :number)
+        post[:destination][:account_holder][:identification][:issuing_country] = options.dig(:destination, :account_holder, :identification, :issuing_country) if options.dig(:destination, :account_holder, :identification, :issuing_country)
+        post[:destination][:account_holder][:identification][:date_of_expiry] = options.dig(:destination, :account_holder, :identification, :date_of_expiry) if options.dig(:destination, :account_holder, :identification, :date_of_expiry)
+
+        if address = options[:billing_address] || options[:address] # destination address will come from the tokenized card billing address
+          post[:destination][:account_holder][:billing_address] = {}
+          post[:destination][:account_holder][:billing_address][:address_line1] = address[:address1] unless address[:address1].blank?
+          post[:destination][:account_holder][:billing_address][:address_line2] = address[:address2] unless address[:address2].blank?
+          post[:destination][:account_holder][:billing_address][:city] = address[:city] unless address[:city].blank?
+          post[:destination][:account_holder][:billing_address][:state] = address[:state] unless address[:state].blank?
+          post[:destination][:account_holder][:billing_address][:country] = address[:country] unless address[:country].blank?
+          post[:destination][:account_holder][:billing_address][:zip] = address[:zip] unless address[:zip].blank?
+        end
+      end
+
       def add_marketplace_data(post, options)
         if options[:marketplace]
           post[:marketplace] = {}
@@ -329,19 +510,43 @@ module ActiveMerchant #:nodoc:
         test? ? TEST_ACCESS_TOKEN_URL : LIVE_ACCESS_TOKEN_URL
       end
 
+      def expires_date_with_extra_range(expires_in)
+        # Two minutes are subtracted from the expires_in time to generate the expires date
+        # in order to prevent any transaction from failing due to using an access_token
+        # that is very close to expiring.
+        # e.g. the access_token has one second left to expire and the lag when the transaction
+        # use an already expired access_token
+        (DateTime.now + (expires_in - 120).seconds).strftime('%Q').to_i
+      end
+
       def setup_access_token
-        request = 'grant_type=client_credentials'
-        response = parse(ssl_post(access_token_url, request, access_token_header))
-        response['access_token']
+        response = parse(ssl_post(access_token_url, 'grant_type=client_credentials', access_token_header))
+        @options[:access_token] = response['access_token']
+        @options[:expires] = expires_date_with_extra_range(response['expires_in']) if response['expires_in'] && response['expires_in'] > 0
+
+        Response.new(
+          access_token_valid?,
+          message_from(access_token_valid?, response, {}),
+          response.merge({ expires: @options[:expires] }),
+          test: test?,
+          error_code: error_code_from(access_token_valid?, response, {})
+        )
+      rescue ResponseError => e
+        raise OAuthResponseError.new(e)
       end
 
-      def commit(action, post, options, authorization = nil, method = :post)
+      def access_token_valid?
+        @options[:access_token].present? && @options[:expires].to_i > DateTime.now.strftime('%Q').to_i
+      end
+
+      def perform_request(action, post, options, authorization = nil, method = :post)
         begin
           raw_response = ssl_request(method, url(action, authorization), post.nil? || post.empty? ? nil : post.to_json, headers(action, options))
           response = parse(raw_response)
           response['id'] = response['_links']['payment']['href'].split('/')[-1] if action == :capture && response.key?('_links')
-          source_id = authorization if action == :unstore
         rescue ResponseError => e
+          @options[:access_token] = '' if e.response.code == '401' && !@options[:secret_key]
+
           raise unless e.response.code.to_s =~ /4\d\d/
 
           response = parse(e.response.body, error: e.response)
@@ -349,29 +554,33 @@ module ActiveMerchant #:nodoc:
 
         succeeded = success_from(action, response)
 
-        response(action, succeeded, response, source_id)
+        response(action, succeeded, response, options)
+      end
+
+      def commit(action, post, options, authorization = nil, method = :post)
+        MultiResponse.run do |r|
+          r.process { setup_access_token } unless @options[:secret_key] || access_token_valid?
+          r.process { perform_request(action, post, options, authorization, method) }
+        end
       end
 
-      def response(action, succeeded, response, source_id = nil)
-        successful_response = succeeded && action == :purchase || action == :authorize
-        avs_result = successful_response ? avs_result(response) : nil
-        cvv_result = successful_response ? cvv_result(response) : nil
+      def response(action, succeeded, response, options = {}, source_id = nil)
         authorization = authorization_from(response) unless action == :unstore
         body = action == :unstore ? { response_code: response.to_s } : response
         Response.new(
           succeeded,
-          message_from(succeeded, response),
+          message_from(succeeded, response, options),
           body,
           authorization: authorization,
-          error_code: error_code_from(succeeded, body),
+          error_code: error_code_from(succeeded, body, options),
           test: test?,
-          avs_result: avs_result,
-          cvv_result: cvv_result
+          avs_result: avs_result(response),
+          cvv_result: cvv_result(response)
         )
       end
 
       def headers(action, options)
-        auth_token = @access_token ? "Bearer #{@access_token}" : @options[:secret_key]
+        auth_token = @options[:access_token] ? "Bearer #{@options[:access_token]}" : @options[:secret_key]
         auth_token = @options[:public_key] if action == :tokens
         headers = {
           'Authorization' => auth_token,
@@ -417,11 +626,11 @@ module ActiveMerchant #:nodoc:
       end
 
       def avs_result(response)
-        response['source'] && response['source']['avs_check'] ? AVSResult.new(code: response['source']['avs_check']) : nil
+        response.respond_to?(:dig) && response.dig('source', 'avs_check') ? AVSResult.new(code: response['source']['avs_check']) : nil
       end
 
       def cvv_result(response)
-        response['source'] && response['source']['cvv_check'] ? CVVResult.new(response['source']['cvv_check']) : nil
+        response.respond_to?(:dig) && response.dig('source', 'cvv_check') ? CVVResult.new(response['source']['cvv_check']) : nil
       end
 
       def parse(body, error: nil)
@@ -441,19 +650,19 @@ module ActiveMerchant #:nodoc:
         return true if action == :unstore && response == 204
 
         store_response = response['token'] || response['id']
-        if store_response
-          return true if (action == :tokens && store_response.match(/tok/)) || (action == :store && store_response.match(/src_/))
-        end
+        return true if store_response && ((action == :tokens && store_response.match(/tok/)) || (action == :store && store_response.match(/src_/)))
+
         response['response_summary'] == 'Approved' || response['approved'] == true || !response.key?('response_summary') && response.key?('action_id')
       end
 
-      def message_from(succeeded, response)
+      def message_from(succeeded, response, options)
         if succeeded
           'Succeeded'
         elsif response['error_type']
           response['error_type'] + ': ' + response['error_codes'].first
         else
-          response['response_summary'] || response['response_code'] || response['status'] || response['message'] || 'Unable to read error message'
+          response_summary = response['response_summary'] || response.dig('actions', 0, 'response_summary')
+          response_summary || response['response_code'] || response['status'] || response['message'] || 'Unable to read error message'
         end
       end
 
@@ -474,7 +683,7 @@ module ActiveMerchant #:nodoc:
         raw['id']
       end
 
-      def error_code_from(succeeded, response)
+      def error_code_from(succeeded, response, options)
         return if succeeded
 
         if response['error_type'] && response['error_codes']
@@ -482,7 +691,9 @@ module ActiveMerchant #:nodoc:
         elsif response['error_type']
           response['error_type']
         else
-          STANDARD_ERROR_CODE_MAPPING[response['response_code']]
+          response_code = response['response_code'] || response.dig('actions', 0, 'response_code')
+
+          STANDARD_ERROR_CODE_MAPPING[response_code]
         end
       end
 

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

@@ -55,6 +55,7 @@ module ActiveMerchant #:nodoc:
         add_invoice(post, money, options)
         add_transaction_details(post, options, 'capture')
         add_reference_transaction_details(post, authorization, options, :capture)
+        add_dynamic_descriptors(post, options)
 
         commit('sale', post, options)
       end
@@ -68,6 +69,15 @@ module ActiveMerchant #:nodoc:
         commit('refund', post, options)
       end
 
+      def credit(money, payment_method, options = {})
+        post = {}
+        add_invoice(post, money, options)
+        add_transaction_interaction(post, options)
+        add_payment(post, payment_method, options)
+
+        commit('refund', post, options)
+      end
+
       def void(authorization, options = {})
         post = {}
         add_transaction_details(post, options)
@@ -102,6 +112,7 @@ module ActiveMerchant #:nodoc:
         transcript.
           gsub(%r((Authorization: )[a-zA-Z0-9+./=]+), '\1[FILTERED]').
           gsub(%r((Api-Key: )\w+), '\1[FILTERED]').
+          gsub(%r(("apiKey\\?":\\?")\w+), '\1[FILTERED]').
           gsub(%r(("cardData\\?":\\?")\d+), '\1[FILTERED]').
           gsub(%r(("securityCode\\?":\\?")\d+), '\1[FILTERED]').
           gsub(%r(("cavv\\?":\\?")\w+), '\1[FILTERED]')
@@ -109,6 +120,23 @@ module ActiveMerchant #:nodoc:
 
       private
 
+      def add_three_d_secure(post, payment, options)
+        return unless three_d_secure = options[:three_d_secure]
+
+        post[:additionalData3DS] = {
+          dsTransactionId: three_d_secure[:ds_transaction_id],
+          authenticationStatus: three_d_secure[:authentication_response_status],
+          serviceProviderTransactionId: three_d_secure[:three_ds_server_trans_id],
+          acsTransactionId: three_d_secure[:acs_transaction_id],
+          mpiData: {
+            cavv: three_d_secure[:cavv],
+            eci: three_d_secure[:eci],
+            xid: three_d_secure[:xid]
+          }.compact,
+          versionData: { recommendedVersion: three_d_secure[:version] }
+        }.compact
+      end
+
       def add_transaction_interaction(post, options)
         post[:transactionInteraction] = {}
         post[:transactionInteraction][:origin] = options[:origin] || 'ECOM'
@@ -120,7 +148,11 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_transaction_details(post, options, action = nil)
-        details = { captureFlag: options[:capture_flag], createToken: options[:create_token] }
+        details = {
+          captureFlag: options[:capture_flag],
+          createToken: options[:create_token],
+          physicalGoodsIndicator: [true, 'true'].include?(options[:physical_goods_indicator])
+        }
 
         if options[:order_id].present? && action == 'sale'
           details[:merchantOrderId] = options[:order_id]
@@ -140,10 +172,7 @@ module ActiveMerchant #:nodoc:
         return unless billing = options[:billing_address]
 
         billing_address = {}
-        if payment.is_a?(CreditCard)
-          billing_address[:firstName] = payment.first_name if payment.first_name
-          billing_address[:lastName] = payment.last_name if payment.last_name
-        end
+        name_from_address(billing_address, billing) || name_from_payment(billing_address, payment)
         address = {}
         address[:street] = billing[:address1] if billing[:address1]
         address[:houseNumberOrName] = billing[:address2] if billing[:address2]
@@ -161,6 +190,22 @@ module ActiveMerchant #:nodoc:
         post[:billingAddress] = billing_address
       end
 
+      def name_from_payment(billing_address, payment)
+        return unless payment.respond_to?(:first_name) && payment.respond_to?(:last_name)
+
+        billing_address[:firstName] = payment.first_name if payment.first_name
+        billing_address[:lastName] = payment.last_name if payment.last_name
+      end
+
+      def name_from_address(billing_address, billing)
+        return unless address = billing
+
+        first_name, last_name = split_names(address[:name]) if address[:name]
+
+        billing_address[:firstName] = first_name if first_name
+        billing_address[:lastName] = last_name if last_name
+      end
+
       def add_shipping_address(post, options)
         return unless shipping = options[:shipping_address]
 
@@ -183,12 +228,28 @@ module ActiveMerchant #:nodoc:
       end
 
       def build_purchase_and_auth_request(post, money, payment, options)
+        add_three_d_secure(post, payment, options)
         add_invoice(post, money, options)
         add_payment(post, payment, options)
         add_stored_credentials(post, options)
         add_transaction_interaction(post, options)
         add_billing_address(post, payment, options)
         add_shipping_address(post, options)
+        add_dynamic_descriptors(post, options)
+      end
+
+      def add_dynamic_descriptors(post, options)
+        dynamic_descriptors_fields = %i[mcc merchant_name customer_service_number service_entitlement dynamic_descriptors_address]
+        return unless dynamic_descriptors_fields.any? { |key| options.include?(key) }
+
+        dynamic_descriptors = {}
+        dynamic_descriptors[:mcc] = options[:mcc] if options[:mcc]
+        dynamic_descriptors[:merchantName] = options[:merchant_name] if options[:merchant_name]
+        dynamic_descriptors[:customerServiceNumber] = options[:customer_service_number] if options[:customer_service_number]
+        dynamic_descriptors[:serviceEntitlement] = options[:service_entitlement] if options[:service_entitlement]
+        dynamic_descriptors[:address] = options[:dynamic_descriptors_address] if options[:dynamic_descriptors_address]
+
+        post[:dynamicDescriptors] = dynamic_descriptors
       end
 
       def add_reference_transaction_details(post, authorization, options, action = nil)
@@ -214,7 +275,7 @@ module ActiveMerchant #:nodoc:
         post[:storedCredentials][:sequence] = stored_credential[:initial_transaction] ? 'FIRST' : 'SUBSEQUENT'
         post[:storedCredentials][:initiator] = stored_credential[:initiator] == 'merchant' ? 'MERCHANT' : 'CARD_HOLDER'
         post[:storedCredentials][:scheduled] = SCHEDULED_REASON_TYPES.include?(stored_credential[:reason_type])
-        post[:storedCredentials][:schemeReferenceTransactionId] = stored_credential[:network_transaction_id] if stored_credential[:network_transaction_id]
+        post[:storedCredentials][:schemeReferenceTransactionId] = options[:scheme_reference_transaction_id] || stored_credential[:network_transaction_id]
       end
 
       def add_credit_card(source, payment, options)
@@ -278,7 +339,7 @@ module ActiveMerchant #:nodoc:
         raw_signature = @options[:api_key] + client_request_id.to_s + time + request
         hmac = OpenSSL::HMAC.digest('sha256', @options[:api_secret], raw_signature)
         signature = Base64.strict_encode64(hmac.to_s).to_s
-
+        custom_headers = options.fetch(:headers_identifiers, {})
         {
           'Client-Request-Id' => client_request_id,
           'Api-Key' => @options[:api_key],
@@ -288,7 +349,7 @@ module ActiveMerchant #:nodoc:
           'Content-Type' => 'application/json',
           'Accept' => 'application/json',
           'Authorization' => signature
-        }
+        }.merge!(custom_headers)
       end
 
       def add_merchant_details(post)

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

@@ -254,9 +254,7 @@ module ActiveMerchant #:nodoc:
             normalized_value = normalize(value)
             next if normalized_value.nil?
 
-            if key == :'3ds_homephonecountry'
-              next unless options[:billing_address] && options[:billing_address][:phone]
-            end
+            next if key == :'3ds_homephonecountry' && !(options[:billing_address] && options[:billing_address][:phone])
 
             post[key] = normalized_value unless post[key]
           end
@@ -417,7 +415,7 @@ module ActiveMerchant #:nodoc:
           three_d_secure_options[:eci],
           three_d_secure_options[:cavv]
         )
-        post[:'3ds_version'] = three_d_secure_options[:version]&.start_with?('2') ? '2.0' : three_d_secure_options[:version]
+        post[:'3ds_version'] = three_d_secure_options[:version] == '2' ? '2.0' : three_d_secure_options[:version]
         post[:'3ds_dstrxid'] = three_d_secure_options[:ds_transaction_id]
       end
 
@@ -507,7 +505,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def parse(body)
-        Hash[CGI::parse(body).map { |k, v| [k.upcase, v.first] }]
+        CGI::parse(body).map { |k, v| [k.upcase, v.first] }.to_h
       end
 
       def success_from(response)