activemerchant 1.133.0 → 1.138.0

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

@@ -1,5 +1,5 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     # For more information on the Iridium Gateway please download the
     # documentation from their Merchant Management System.
     #
@@ -376,22 +376,32 @@ module ActiveMerchant #:nodoc:
 
       def commit(request, options)
         requires!(options, :action)
-        response = parse(ssl_post(test? ? self.test_url : self.live_url, request,
-          { 'SOAPAction' => 'https://www.thepaymentgateway.net/' + options[:action],
-           'Content-Type' => 'text/xml; charset=utf-8' }))
+        response = parse(
+          ssl_post(
+            test? ? self.test_url : self.live_url, request,
+            {
+              'SOAPAction' => 'https://www.thepaymentgateway.net/' + options[:action],
+              'Content-Type' => 'text/xml; charset=utf-8'
+            }
+          )
+        )
 
         success = response[:transaction_result][:status_code] == '0'
         message = response[:transaction_result][:message]
         authorization = success ? [options[:order_id], response[:transaction_output_data][:cross_reference], response[:transaction_output_data][:auth_code]].compact.join(';') : nil
 
-        Response.new(success, message, response,
+        Response.new(
+          success,
+          message,
+          response,
           test: test?,
-          authorization: authorization,
+          authorization:,
           avs_result: {
             street_match: AVS_CODE[ response[:transaction_output_data][:address_numeric_check_result] ],
             postal_match: AVS_CODE[ response[:transaction_output_data][:post_code_check_result] ]
           },
-          cvv_result: CVV_CODE[ response[:transaction_output_data][:cv2_check_result] ])
+          cvv_result: CVV_CODE[ response[:transaction_output_data][:cv2_check_result] ]
+        )
       end
 
       def parse(xml)

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

@@ -1,7 +1,7 @@
 require 'nokogiri'
 
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     # iTransact, Inc. is an authorized reseller of the PaymentClearing gateway. If your merchant service provider uses PaymentClearing.com to process payments, you can use this module.
     #
     #
@@ -387,11 +387,15 @@ module ActiveMerchant #:nodoc:
         # the Base64 encoded payload signature!
         response = parse(ssl_post(self.live_url, post_data(payload), 'Content-Type' => 'text/xml'))
 
-        Response.new(successful?(response), response[:error_message], response,
+        Response.new(
+          successful?(response),
+          response[:error_message],
+          response,
           test: test?,
           authorization: response[:xid],
           avs_result: { code: response[:avs_response] },
-          cvv_result: response[:cvv_response])
+          cvv_result: response[:cvv_response]
+        )
       end
 
       def post_data(payload)

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

@@ -1,9 +1,11 @@
 require 'nokogiri'
 
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class IveriGateway < Gateway
       class_attribute :iveri_url
+      # Define the API version using the Versionable module
+      version '2.0'
 
       self.live_url = self.test_url = 'https://portal.nedsecure.co.za/iVeriWebService/Service.asmx'
       self.iveri_url = 'https://portal.host.iveri.com/iVeriWebService/Service.asmx'
@@ -55,7 +57,8 @@ module ActiveMerchant #:nodoc:
       end
 
       def void(authorization, options = {})
-        post = build_vxml_request('Void', options) do |xml|
+        txn_type = options[:reference_type] == :authorize ? 'AuthorisationReversal' : 'Void'
+        post = build_vxml_request(txn_type, options) do |xml|
           add_authorization(xml, authorization, options)
         end
 
@@ -65,7 +68,7 @@ module ActiveMerchant #:nodoc:
       def verify(credit_card, options = {})
         MultiResponse.run(:use_first_response) do |r|
           r.process { authorize(100, credit_card, options) }
-          r.process(:ignore_result) { void(r.authorization, options) }
+          r.process(:ignore_result) { void(r.authorization, options.merge(reference_type: :authorize)) }
         end
       end
 
@@ -96,7 +99,7 @@ module ActiveMerchant #:nodoc:
               xml.Execute 'xmlns' => 'http://iveri.com/' do
                 xml.validateRequest('false')
                 xml.protocol 'V_XML'
-                xml.protocolVersion '2.0'
+                xml.protocolVersion fetch_version # Fetch the version dynamically
                 xml.request vxml
               end
             end
@@ -108,7 +111,7 @@ module ActiveMerchant #:nodoc:
 
       def build_vxml_request(action, options)
         builder = Nokogiri::XML::Builder.new do |xml|
-          xml.V_XML('Version' => '2.0', 'CertificateID' => @options[:cert_id], 'Direction' => 'Request') do
+          xml.V_XML('Version' => fetch_version, 'CertificateID' => @options[:cert_id], 'Direction' => 'Request') do
             xml.Transaction('ApplicationID' => @options[:app_id], 'Command' => action, 'Mode' => mode) do
               yield(xml)
             end
@@ -218,10 +221,10 @@ module ActiveMerchant #:nodoc:
           end
         end
 
-        if !node.elements.empty?
-          node.elements.each { |e| parse_element(parsed, e) }
-        else
+        if node.elements.empty?
           parsed[underscore(node.name)] = node.text
+        else
+          node.elements.each { |e| parse_element(parsed, e) }
         end
       end
 

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

@@ -1,7 +1,7 @@
 require 'nokogiri'
 
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class IxopayGateway < Gateway
       self.test_url = 'https://secure.ixopay.com/transaction'
       self.live_url = 'https://secure.ixopay.com/transaction'
@@ -286,8 +286,8 @@ module ActiveMerchant #:nodoc:
         response =
           begin
             parse(ssl_post(url, request, headers(request)))
-          rescue StandardError => error
-            parse(error.response.body)
+          rescue StandardError => e
+            parse(e.response.body)
           end
 
         Response.new(

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

@@ -1,5 +1,5 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class JetpayGateway < Gateway
       class_attribute :live_us_url, :live_ca_url
 
@@ -284,13 +284,15 @@ module ActiveMerchant #:nodoc:
         response = parse(ssl_post(url, request))
 
         success = success?(response)
-        Response.new(success,
+        Response.new(
+          success,
           success ? 'APPROVED' : message_from(response),
           response,
           test: test?,
           authorization: authorization_from(response, money, token),
           avs_result: { code: response[:avs] },
-          cvv_result: response[:cvv2])
+          cvv_result: response[:cvv2]
+        )
       end
 
       def url

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

@@ -1,5 +1,5 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class JetpayV2Gateway < Gateway
       self.test_url = 'https://test1.jetpay.com/jetpay'
       self.live_url = 'https://gateway20.jetpay.com/jetpay'
@@ -12,7 +12,8 @@ module ActiveMerchant #:nodoc:
       self.homepage_url = 'http://www.jetpay.com'
       self.display_name = 'JetPay'
 
-      API_VERSION = '2.2'
+      # Define the API version using the Versionable module
+      version '2.2'
 
       ACTION_CODE_MESSAGES = {
         '000' =>  'Approved.',
@@ -203,7 +204,7 @@ module ActiveMerchant #:nodoc:
 
       def build_xml_request(transaction_type, options = {}, transaction_id = nil, &block)
         xml = Builder::XmlMarkup.new
-        xml.tag! 'JetPay', 'Version' => API_VERSION do
+        xml.tag! 'JetPay', 'Version' => fetch_version do # Use normalized version
           # Basic values needed for any request
           xml.tag! 'TerminalID', @options[:login]
           xml.tag! 'TransactionType', transaction_type
@@ -295,14 +296,16 @@ module ActiveMerchant #:nodoc:
         response = parse(ssl_post(url, request))
 
         success = success?(response)
-        Response.new(success,
+        Response.new(
+          success,
           success ? 'APPROVED' : message_from(response),
           response,
           test: test?,
           authorization: authorization_from(response, money, token),
           avs_result: AVSResult.new(code: response[:avs]),
           cvv_result: CVVResult.new(response[:cvv2]),
-          error_code: success ? nil : error_code_from(response))
+          error_code: success ? nil : error_code_from(response)
+        )
       end
 
       def url

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

@@ -1,7 +1,7 @@
 require 'json'
 
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class KomojuGateway < Gateway
       self.test_url = 'https://komoju.com/api/v1'
       self.live_url = 'https://komoju.com/api/v1'

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

@@ -1,5 +1,5 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class KushkiGateway < Gateway
       self.display_name = 'Kushki'
       self.homepage_url = 'https://www.kushkipagos.com'
@@ -12,6 +12,9 @@ module ActiveMerchant #:nodoc:
       self.money_format = :dollars
       self.supported_cardtypes = %i[visa master american_express discover diners_club alia]
 
+      # Define the API version using the Versionable module
+      version 'v1'
+
       def initialize(options = {})
         requires!(options, :public_merchant_id, :private_merchant_id)
         super
@@ -20,14 +23,14 @@ module ActiveMerchant #:nodoc:
       def purchase(amount, payment_method, options = {})
         MultiResponse.run() do |r|
           r.process { tokenize(amount, payment_method, options) }
-          r.process { charge(amount, r.authorization, options) }
+          r.process { charge(amount, r.authorization, options, payment_method) }
         end
       end
 
       def authorize(amount, payment_method, options = {})
         MultiResponse.run() do |r|
           r.process { tokenize(amount, payment_method, options) }
-          r.process { preauthorize(amount, r.authorization, options) }
+          r.process { preauthorize(amount, r.authorization, options, payment_method) }
         end
       end
 
@@ -48,8 +51,9 @@ module ActiveMerchant #:nodoc:
         post = {}
         post[:ticketNumber] = authorization
         add_full_response(post, options)
+        add_invoice(action, post, amount, options)
 
-        commit(action, post)
+        commit(action, post, options)
       end
 
       def void(authorization, options = {})
@@ -89,7 +93,7 @@ module ActiveMerchant #:nodoc:
         commit(action, post)
       end
 
-      def charge(amount, authorization, options)
+      def charge(amount, authorization, options, payment_method = {})
         action = 'charge'
 
         post = {}
@@ -100,11 +104,13 @@ module ActiveMerchant #:nodoc:
         add_metadata(post, options)
         add_months(post, options)
         add_deferred(post, options)
+        add_three_d_secure(post, payment_method, options)
+        add_product_details(post, options)
 
         commit(action, post)
       end
 
-      def preauthorize(amount, authorization, options)
+      def preauthorize(amount, authorization, options, payment_method = {})
         action = 'preAuthorization'
 
         post = {}
@@ -114,6 +120,7 @@ module ActiveMerchant #:nodoc:
         add_metadata(post, options)
         add_months(post, options)
         add_deferred(post, options)
+        add_three_d_secure(post, payment_method, options)
 
         commit(action, post)
       end
@@ -133,9 +140,9 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_amount_defaults(sum, money, options)
-        sum[:subtotalIva] = amount(money).to_f
+        sum[:subtotalIva] = 0
         sum[:iva] = 0
-        sum[:subtotalIva0] = 0
+        sum[:subtotalIva0] = amount(money).to_f
 
         sum[:ice] = 0 if sum[:currency] != 'COP'
       end
@@ -183,7 +190,8 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_full_response(post, options)
-        post[:fullResponse] = options[:full_response].to_s.casecmp('true').zero? if options[:full_response]
+        # this is the only currently accepted value for this field, previously it was 'true'
+        post[:fullResponse] = 'v2' unless options[:full_response] == 'false' || options[:full_response].blank?
       end
 
       def add_metadata(post, options)
@@ -204,6 +212,59 @@ module ActiveMerchant #:nodoc:
         }
       end
 
+      def add_product_details(post, options)
+        return unless options[:product_details]
+
+        product_items_array = []
+        options[:product_details].each do |item|
+          product_items_obj = {}
+
+          product_items_obj[:id] = item[:id] if item[:id]
+          product_items_obj[:title] = item[:title] if item[:title]
+          product_items_obj[:price] = item[:price].to_i if item[:price]
+          product_items_obj[:sku] = item[:sku] if item[:sku]
+          product_items_obj[:quantity] = item[:quantity].to_i if item[:quantity]
+
+          product_items_array << product_items_obj
+        end
+
+        product_items = {
+          product: product_items_array
+        }
+
+        post[:productDetails] = product_items
+      end
+
+      def add_three_d_secure(post, payment_method, options)
+        three_d_secure = options[:three_d_secure]
+        return unless three_d_secure.present?
+
+        post[:threeDomainSecure] = {
+          eci: three_d_secure[:eci],
+          specificationVersion: three_d_secure[:version]
+        }
+
+        if payment_method.brand == 'master'
+          post[:threeDomainSecure][:acceptRisk] = three_d_secure[:eci] == '00'
+          post[:threeDomainSecure][:ucaf] = three_d_secure[:cavv]
+          post[:threeDomainSecure][:directoryServerTransactionID] = three_d_secure[:ds_transaction_id]
+          case three_d_secure[:eci]
+          when '07'
+            post[:threeDomainSecure][:collectionIndicator] = '0'
+          when '06'
+            post[:threeDomainSecure][:collectionIndicator] = '1'
+          else
+            post[:threeDomainSecure][:collectionIndicator] = '2'
+          end
+        elsif payment_method.brand == 'visa'
+          post[:threeDomainSecure][:acceptRisk] = three_d_secure[:eci] == '07'
+          post[:threeDomainSecure][:cavv] = three_d_secure[:cavv]
+          post[:threeDomainSecure][:xid] = three_d_secure[:xid] if three_d_secure[:xid].present?
+        else
+          raise ArgumentError.new 'Kushki supports 3ds2 authentication for only Visa and Mastercard brands.'
+        end
+      end
+
       ENDPOINT = {
         'tokenize' => 'tokens',
         'charge' => 'charges',
@@ -213,10 +274,10 @@ module ActiveMerchant #:nodoc:
         'capture' => 'capture'
       }
 
-      def commit(action, params)
+      def commit(action, params, options = {})
         response =
           begin
-            parse(ssl_invoke(action, params))
+            parse(ssl_invoke(action, params, options))
           rescue ResponseError => e
             parse(e.response.body)
           end
@@ -233,9 +294,11 @@ module ActiveMerchant #:nodoc:
         )
       end
 
-      def ssl_invoke(action, params)
+      def ssl_invoke(action, params, options)
         if %w[void refund].include?(action)
-          ssl_request(:delete, url(action, params), nil, headers(action))
+          # removes ticketNumber from request for partial refunds because gateway will reject if included in request body
+          data = options[:partial_refund] == true ? post_data(params.except(:ticketNumber)) : nil
+          ssl_request(:delete, url(action, params), data, headers(action))
         else
           ssl_post(url(action, params), post_data(params), headers(action))
         end
@@ -257,9 +320,9 @@ module ActiveMerchant #:nodoc:
         base_url = test? ? test_url : live_url
 
         if %w[void refund].include?(action)
-          base_url + 'v1/' + ENDPOINT[action] + '/' + params[:ticketNumber].to_s
+          base_url + "#{fetch_version}/" + ENDPOINT[action] + '/' + params[:ticketNumber].to_s
         else
-          base_url + 'card/v1/' + ENDPOINT[action]
+          base_url + "card/#{fetch_version}/" + ENDPOINT[action]
         end
       end
 

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

@@ -1,5 +1,5 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class Latitude19Gateway < Gateway
       self.display_name = 'Latitude19 Gateway'
       self.homepage_url = 'http://www.l19tech.com'

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

@@ -1,7 +1,7 @@
 require 'rexml/document'
 
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     # Initialization Options
     # :login                Your store number
     # :pem                  The text of your linkpoint PEM file. Note
@@ -263,11 +263,15 @@ module ActiveMerchant #:nodoc:
       def commit(money, creditcard, options = {})
         response = parse(ssl_post(test? ? self.test_url : self.live_url, post_data(money, creditcard, options)))
 
-        Response.new(successful?(response), response[:message], response,
+        Response.new(
+          successful?(response),
+          response[:message],
+          response,
           test: test?,
           authorization: response[:ordernum],
           avs_result: { code: response[:avs].to_s[2, 1] },
-          cvv_result: response[:avs].to_s[3, 1])
+          cvv_result: response[:avs].to_s[3, 1]
+        )
       end
 
       def successful?(response)

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

@@ -1,9 +1,9 @@
 require 'nokogiri'
 
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class LitleGateway < Gateway
-      SCHEMA_VERSION = '9.14'
+      version '9.14'
 
       class_attribute :postlive_url, :prelive_url
 
@@ -111,14 +111,15 @@ module ActiveMerchant #:nodoc:
         doc.lineItemData do
           level_3_data[:line_items].each do |line_item|
             doc.itemSequenceNumber(line_item[:item_sequence_number]) if line_item[:item_sequence_number]
-            doc.commodityCode(line_item[:commodity_code]) if line_item[:commodity_code]
             doc.itemDescription(line_item[:item_description]) if line_item[:item_description]
             doc.productCode(line_item[:product_code]) if line_item[:product_code]
             doc.quantity(line_item[:quantity]) if line_item[:quantity]
             doc.unitOfMeasure(line_item[:unit_of_measure]) if line_item[:unit_of_measure]
             doc.taxAmount(line_item[:tax_amount]) if line_item[:tax_amount]
-            doc.itemDiscountAmount(line_item[:discount_per_line_item]) unless line_item[:discount_per_line_item] < 0
-            doc.unitCost(line_item[:unit_cost]) unless line_item[:unit_cost] < 0
+            doc.lineItemTotal(line_item[:line_item_total]) if line_item[:line_item_total]
+            doc.itemDiscountAmount(line_item[:discount_per_line_item].to_i) unless line_item[:discount_per_line_item].to_i < 0
+            doc.commodityCode(line_item[:commodity_code]) if line_item[:commodity_code]
+            doc.unitCost(line_item[:unit_cost].to_i) unless line_item[:unit_cost].to_i < 0
             doc.detailTax do
               doc.taxIncludedInTotal(line_item[:tax_included_in_total]) if line_item[:tax_included_in_total]
               doc.taxAmount(line_item[:tax_amount]) if line_item[:tax_amount]
@@ -310,7 +311,15 @@ module ActiveMerchant #:nodoc:
       def add_auth_purchase_params(doc, money, payment_method, options)
         doc.orderId(truncate(options[:order_id], 24))
         doc.amount(money)
-        add_order_source(doc, payment_method, options)
+
+        if options.dig(:stored_credential, :initial_transaction) == false
+          # orderSource needs to be added at the top of doc and
+          # processingType near the end
+          source_for_subsequent_stored_credential_txns(doc, options)
+        else
+          add_order_source(doc, payment_method, options)
+        end
+
         add_billing_address(doc, payment_method, options)
         add_shipping_address(doc, payment_method, options)
         add_payment_method(doc, payment_method, options)
@@ -382,8 +391,9 @@ module ActiveMerchant #:nodoc:
             doc.track(payment_method.track_data)
           end
         elsif check?(payment_method)
+          account_type = payment_method.account_type || payment_method.account_holder_type
           doc.echeck do
-            doc.accType(payment_method.account_type.capitalize)
+            doc.accType(account_type&.capitalize)
             doc.accNum(payment_method.account_number)
             doc.routingNum(payment_method.routing_number)
             doc.checkNum(payment_method.number) if payment_method.number
@@ -409,16 +419,17 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_stored_credential_params(doc, options = {})
-        return unless options[:stored_credential]
+        return unless stored_credential = options[:stored_credential]
 
-        if options[:stored_credential][:initial_transaction]
-          add_stored_credential_params_initial(doc, options)
+        if stored_credential[:initial_transaction]
+          add_stored_credential_for_initial_txn(doc, options)
         else
-          add_stored_credential_params_used(doc, options)
+          doc.processingType("#{stored_credential[:initiator]}InitiatedCOF") if stored_credential[:reason_type] == 'unscheduled'
+          doc.originalNetworkTransactionId(stored_credential[:network_transaction_id]) if stored_credential[:initiator] == 'merchant'
         end
       end
 
-      def add_stored_credential_params_initial(doc, options)
+      def add_stored_credential_for_initial_txn(doc, options)
         case options[:stored_credential][:reason_type]
         when 'unscheduled'
           doc.processingType('initialCOF')
@@ -429,15 +440,15 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def add_stored_credential_params_used(doc, options)
-        if options[:stored_credential][:reason_type] == 'unscheduled'
-          if options[:stored_credential][:initiator] == 'merchant'
-            doc.processingType('merchantInitiatedCOF')
-          else
-            doc.processingType('cardholderInitiatedCOF')
-          end
+      def source_for_subsequent_stored_credential_txns(doc, options)
+        case options[:stored_credential][:reason_type]
+        when 'unscheduled'
+          doc.orderSource('ecommerce')
+        when 'installment'
+          doc.orderSource('installment')
+        when 'recurring'
+          doc.orderSource('recurring')
         end
-        doc.originalNetworkTransactionId(options[:stored_credential][:network_transaction_id])
       end
 
       def add_billing_address(doc, payment_method, options)
@@ -479,8 +490,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_order_source(doc, payment_method, options)
-        order_source = order_source(options)
-        if order_source
+        if order_source = options[:order_source]
           doc.orderSource(order_source)
         elsif payment_method.is_a?(NetworkTokenizationCreditCard) && payment_method.source == :apple_pay
           doc.orderSource('applepay')
@@ -493,31 +503,6 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def order_source(options = {})
-        return options[:order_source] unless options[:stored_credential]
-
-        order_source = nil
-
-        case options[:stored_credential][:reason_type]
-        when 'unscheduled'
-          if options[:stored_credential][:initiator] == 'merchant'
-            # For merchant-initiated, we should always set order source to
-            # 'ecommerce'
-            order_source = 'ecommerce'
-          else
-            # For cardholder-initiated, we rely on #add_order_source's
-            # default logic to set orderSource appropriately
-            order_source = options[:order_source]
-          end
-        when 'installment'
-          order_source = 'installment'
-        when 'recurring'
-          order_source = 'recurring'
-        end
-
-        order_source
-      end
-
       def add_pos(doc, payment_method)
         return unless payment_method.respond_to?(:track_data) && payment_method.track_data.present?
 
@@ -576,7 +561,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def success_from(kind, parsed)
-        return %w(000 001 010).any?(parsed[:response]) unless kind == :registerToken
+        return %w(000 001 010 136 470 473).any?(parsed[:response]) unless kind == :registerToken
 
         %w(000 801 802).include?(parsed[:response])
       end
@@ -613,16 +598,14 @@ module ActiveMerchant #:nodoc:
       def root_attributes
         {
           merchantId: @options[:merchant_id],
-          version: SCHEMA_VERSION,
+          version: fetch_version,
           xmlns: 'http://www.litle.com/schema'
         }
       end
 
-      def build_xml_request
+      def build_xml_request(&block)
         builder = Nokogiri::XML::Builder.new
-        builder.__send__('litleOnlineRequest', root_attributes) do |doc|
-          yield(doc)
-        end
+        builder.__send__('litleOnlineRequest', root_attributes, &block)
         builder.doc.root.to_xml
       end