activemerchant 1.123.0 → 1.126.0

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

@@ -4,7 +4,7 @@ module ActiveMerchant #:nodoc:
       self.test_url = 'https://sandbox.dlocal.com'
       self.live_url = 'https://api.dlocal.com'
 
-      self.supported_countries = %w[AR BR CL CO MX PE UY TR]
+      self.supported_countries = %w[AR BD BO BR CL CM CN CO CR DO EC EG GH IN ID KE MY MX MA NG PA PY PE PH SN ZA TR UY VN]
       self.default_currency = 'USD'
       self.supported_cardtypes = %i[visa master american_express discover jcb diners_club maestro naranja cabal elo alia carnet]
 
@@ -19,6 +19,7 @@ module ActiveMerchant #:nodoc:
       def purchase(money, payment, options = {})
         post = {}
         add_auth_purchase_params(post, money, payment, 'purchase', options)
+        add_three_ds(post, options)
 
         commit('purchase', post, options)
       end
@@ -26,6 +27,8 @@ module ActiveMerchant #:nodoc:
       def authorize(money, payment, options = {})
         post = {}
         add_auth_purchase_params(post, money, payment, 'authorize', options)
+        add_three_ds(post, options)
+        post[:card][:verify] = true if options[:verify].to_s == 'true'
 
         commit('authorize', post, options)
       end
@@ -52,10 +55,7 @@ module ActiveMerchant #:nodoc:
       end
 
       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) }
-        end
+        authorize(0, credit_card, options.merge(verify: 'true'))
       end
 
       def supports_scrubbing?
@@ -78,6 +78,7 @@ module ActiveMerchant #:nodoc:
         add_country(post, card, options)
         add_payer(post, card, options)
         add_card(post, card, action, options)
+        add_additional_data(post, options)
         post[:order_id] = options[:order_id] || generate_unique_id
         post[:description] = options[:description] if options[:description]
       end
@@ -87,6 +88,10 @@ module ActiveMerchant #:nodoc:
         post[:currency] = (options[:currency] || currency(money))
       end
 
+      def add_additional_data(post, options)
+        post[:additional_risk_data] = options[:additional_data]
+      end
+
       def add_country(post, card, options)
         return unless address = options[:billing_address] || options[:address]
 
@@ -109,6 +114,8 @@ module ActiveMerchant #:nodoc:
         post[:payer][:document] = options[:document] if options[:document]
         post[:payer][:document2] = options[:document2] if options[:document2]
         post[:payer][:user_reference] = options[:user_reference] if options[:user_reference]
+        post[:payer][:event_uuid] = options[:device_id] if options[:device_id]
+        post[:payer][:onboarding_ip_address] = options[:ip] if options[:ip]
         post[:payer][:address] = add_address(post, card, options)
       end
 
@@ -149,6 +156,7 @@ module ActiveMerchant #:nodoc:
         post[:card][:capture] = (action == 'purchase')
         post[:card][:installments] = options[:installments] if options[:installments]
         post[:card][:installments_id] = options[:installments_id] if options[:installments_id]
+        post[:card][:force_type] = options[:force_type].to_s.upcase if options[:force_type]
       end
 
       def parse(body)
@@ -156,6 +164,9 @@ module ActiveMerchant #:nodoc:
       end
 
       def commit(action, parameters, options = {})
+        three_ds_errors = validate_three_ds_params(parameters[:three_dsecure]) if parameters[:three_dsecure].present?
+        return three_ds_errors if three_ds_errors
+
         url = url(action, parameters, options)
         post = post_data(action, parameters)
         begin
@@ -184,7 +195,7 @@ module ActiveMerchant #:nodoc:
       def success_from(action, response)
         return false unless response['status_code']
 
-        %w[100 200 400 600].include? response['status_code'].to_s
+        %w[100 200 400 600 700].include? response['status_code'].to_s
       end
 
       def message_from(action, response)
@@ -228,6 +239,7 @@ module ActiveMerchant #:nodoc:
           'X-Date' => timestamp,
           'X-Login' => @options[:login],
           'X-Trans-Key' => @options[:trans_key],
+          'X-Version' => '2.1',
           'Authorization' => signature(post, timestamp)
         }
         headers.merge('X-Idempotency-Key' => options[:idempotency_key]) if options[:idempotency_key]
@@ -243,6 +255,49 @@ module ActiveMerchant #:nodoc:
       def post_data(action, parameters = {})
         parameters.to_json
       end
+
+      def xid_or_ds_trans_id(three_d_secure)
+        if three_d_secure[:version].to_f >= 2
+          { ds_transaction_id: three_d_secure[:ds_transaction_id] }
+        else
+          { xid: three_d_secure[:xid] }
+        end
+      end
+
+      def add_three_ds(post, options)
+        return unless three_d_secure = options[:three_d_secure]
+
+        post[:three_dsecure] = {
+          mpi: true,
+          three_dsecure_version: three_d_secure[:version],
+          cavv: three_d_secure[:cavv],
+          eci: three_d_secure[:eci],
+          enrollment_response: formatted_enrollment(three_d_secure[:enrolled]),
+          authentication_response: three_d_secure[:authentication_response_status]
+        }.merge(xid_or_ds_trans_id(three_d_secure))
+      end
+
+      def validate_three_ds_params(three_ds)
+        errors = {}
+        supported_version = %w{1.0 2.0 2.1.0 2.2.0}.include?(three_ds[:three_dsecure_version])
+        supported_enrollment = ['Y', 'N', 'U', nil].include?(three_ds[:enrollment_response])
+        supported_auth_response = ['Y', 'N', 'U', nil].include?(three_ds[:authentication_response])
+
+        errors[:three_ds_version] = 'ThreeDs version not supported' unless supported_version
+        errors[:enrollment] = 'Enrollment value not supported' unless supported_enrollment
+        errors[:auth_response] = 'Authentication response value not supported' unless supported_auth_response
+        errors.compact!
+
+        errors.present? ? Response.new(false, 'ThreeDs data is invalid', errors) : nil
+      end
+
+      def formatted_enrollment(val)
+        case val
+        when 'Y', 'N', 'U' then val
+        when true, 'true' then 'Y'
+        when false, 'false' then 'N'
+        end
+      end
     end
   end
 end

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

@@ -117,11 +117,11 @@ module ActiveMerchant #:nodoc:
         post[:establishment_name] = options[:establishment_name] if options[:establishment_name]
         post[:fraud_detection] = add_fraud_detection(options[:fraud_detection]) if options[:fraud_detection].present?
         post[:site_id] = options[:site_id] if options[:site_id]
-        post[:sub_payments] = []
 
         add_invoice(post, money, options)
         add_payment(post, credit_card, options)
         add_aggregate_data(post, options) if options[:aggregate_data]
+        add_sub_payments(post, options)
       end
 
       def add_payment_method_id(credit_card, options)
@@ -210,6 +210,22 @@ module ActiveMerchant #:nodoc:
         post[:aggregate_data] = aggregate_data
       end
 
+      def add_sub_payments(post, options)
+        # sub_payments field is required for purchase transactions, even if empty
+        post[:sub_payments] = []
+
+        return unless sub_payments = options[:sub_payments]
+
+        sub_payments.each do |sub_payment|
+          sub_payment_hash = {
+            site_id: sub_payment[:site_id],
+            installments: sub_payment[:installments].to_i,
+            amount: sub_payment[:amount].to_i
+          }
+          post[:sub_payments] << sub_payment_hash
+        end
+      end
+
       def add_fraud_detection(options = {})
         {}.tap do |hsh|
           hsh[:send_to_cs] = options[:send_to_cs] if valid_fraud_detection_option?(options[:send_to_cs]) # true/false

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

@@ -0,0 +1,344 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class DecidirPlusGateway < Gateway
+      self.test_url = 'https://developers.decidir.com/api/v2'
+      self.live_url = 'https://live.decidir.com/api/v2'
+
+      self.supported_countries = ['AR']
+      self.default_currency = 'ARS'
+      self.supported_cardtypes = %i[visa master american_express discover diners_club naranja cabal]
+
+      self.homepage_url = 'http://decidir.com.ar/home'
+      self.display_name = 'Decidir Plus'
+
+      def initialize(options = {})
+        requires!(options, :public_key, :private_key)
+        super
+      end
+
+      def purchase(money, payment, options = {})
+        post = {}
+        build_purchase_authorize_request(post, money, payment, options)
+
+        commit(:post, 'payments', post)
+      end
+
+      def authorize(money, payment, options = {})
+        post = {}
+        build_purchase_authorize_request(post, money, payment, options)
+
+        commit(:post, 'payments', post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+        post[:amount] = money
+
+        commit(:put, "payments/#{add_reference(authorization)}", post)
+      end
+
+      def refund(money, authorization, options = {})
+        post = {}
+        post[:amount] = money
+
+        commit(:post, "payments/#{add_reference(authorization)}/refunds", post)
+      end
+
+      def void(authorization, options = {})
+        commit(:post, "payments/#{add_reference(authorization)}/refunds")
+      end
+
+      def verify(credit_card, options = {})
+        MultiResponse.run(:use_first_response) do |r|
+          r.process { store(credit_card, options) }
+          r.process { authorize(100, r.authorization, options) }
+          r.process(:ignore_result) { void(r.authorization, options) }
+        end
+      end
+
+      def store(payment, options = {})
+        post = {}
+        add_payment(post, payment, options)
+
+        commit(:post, 'tokens', post)
+      end
+
+      def unstore(customer_token)
+        commit(:delete, "cardtokens/#{customer_token}")
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Apikey: )\w+), '\1[FILTERED]').
+          gsub(%r(("card_number\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("security_code\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]')
+      end
+
+      private
+
+      def build_purchase_authorize_request(post, money, payment, options)
+        add_customer_data(post, options)
+        add_payment(post, payment, options)
+        add_purchase_data(post, money, payment, options)
+        add_fraud_detection(post, options)
+      end
+
+      def add_reference(authorization)
+        return unless authorization
+
+        authorization.split('|')[0]
+      end
+
+      def add_payment(post, payment, options = {})
+        if payment.is_a?(String)
+          token, bin = payment.split('|')
+          post[:token] = token
+          post[:bin] = bin
+        else
+          post[:card_number] = payment.number
+          post[:card_expiration_month] = format(payment.month, :two_digits)
+          post[:card_expiration_year] = format(payment.year, :two_digits)
+          post[:security_code] = payment.verification_value.to_s
+          post[:card_holder_name] = payment.name.empty? ? options[:name_override] : payment.name
+          post[:card_holder_identification] = {}
+          post[:card_holder_identification][:type] = options[:card_holder_identification_type] if options[:card_holder_identification_type]
+          post[:card_holder_identification][:number] = options[:card_holder_identification_number] if options[:card_holder_identification_number]
+
+          # additional data used for Visa transactions
+          post[:card_holder_door_number] = options[:card_holder_door_number].to_i if options[:card_holder_door_number]
+          post[:card_holder_birthday] = options[:card_holder_birthday] if options[:card_holder_birthday]
+        end
+      end
+
+      def add_customer_data(post, options = {})
+        return unless customer = options[:customer]
+
+        post[:customer] = {}
+        post[:customer][:id] = customer[:id] if customer[:id]
+        post[:customer][:email] = customer[:email] if customer[:email]
+      end
+
+      def add_purchase_data(post, money, payment, options = {})
+        post[:site_transaction_id] = options[:site_transaction_id] || SecureRandom.hex
+        post[:payment_method_id] = add_payment_method_id(options)
+        post[:amount] = money
+        post[:currency] = options[:currency] || self.default_currency
+        post[:installments] = options[:installments] || 1
+        post[:payment_type] = options[:payment_type] || 'single'
+        post[:establishment_name] = options[:establishment_name] if options[:establishment_name]
+
+        add_aggregate_data(post, options) if options[:aggregate_data]
+        add_sub_payments(post, options)
+      end
+
+      def add_aggregate_data(post, options)
+        aggregate_data = {}
+        data = options[:aggregate_data]
+        aggregate_data[:indicator] = data[:indicator] if data[:indicator]
+        aggregate_data[:identification_number] = data[:identification_number] if data[:identification_number]
+        aggregate_data[:bill_to_pay] = data[:bill_to_pay] if data[:bill_to_pay]
+        aggregate_data[:bill_to_refund] = data[:bill_to_refund] if data[:bill_to_refund]
+        aggregate_data[:merchant_name] = data[:merchant_name] if data[:merchant_name]
+        aggregate_data[:street] = data[:street] if data[:street]
+        aggregate_data[:number] = data[:number] if data[:number]
+        aggregate_data[:postal_code] = data[:postal_code] if data[:postal_code]
+        aggregate_data[:category] = data[:category] if data[:category]
+        aggregate_data[:channel] = data[:channel] if data[:channel]
+        aggregate_data[:geographic_code] = data[:geographic_code] if data[:geographic_code]
+        aggregate_data[:city] = data[:city] if data[:city]
+        aggregate_data[:merchant_id] = data[:merchant_id] if data[:merchant_id]
+        aggregate_data[:province] = data[:province] if data[:province]
+        aggregate_data[:country] = data[:country] if data[:country]
+        aggregate_data[:merchant_email] = data[:merchant_email] if data[:merchant_email]
+        aggregate_data[:merchant_phone] = data[:merchant_phone] if data[:merchant_phone]
+        post[:aggregate_data] = aggregate_data
+      end
+
+      def add_sub_payments(post, options)
+        # sub_payments field is required for purchase transactions, even if empty
+        post[:sub_payments] = []
+
+        return unless sub_payments = options[:sub_payments]
+
+        sub_payments.each do |sub_payment|
+          sub_payment_hash = {
+            site_id: sub_payment[:site_id],
+            installments: sub_payment[:installments].to_i,
+            amount: sub_payment[:amount].to_i
+          }
+          post[:sub_payments] << sub_payment_hash
+        end
+      end
+
+      def add_payment_method_id(options)
+        return options[:payment_method_id].to_i if options[:payment_method_id]
+
+        if options[:debit]
+          case options[:card_brand]
+          when 'visa'
+            31
+          when 'master'
+            105
+          when 'maestro'
+            106
+          when 'cabal'
+            108
+          else
+            31
+          end
+        else
+          case options[:card_brand]
+          when 'visa'
+            1
+          when 'master'
+            104
+          when 'american_express'
+            65
+          when 'american_express_prisma'
+            111
+          when 'cabal'
+            63
+          when 'diners_club'
+            8
+          else
+            1
+          end
+        end
+      end
+
+      def add_fraud_detection(post, options)
+        return unless fraud_detection = options[:fraud_detection]
+
+        {}.tap do |hsh|
+          hsh[:send_to_cs] = fraud_detection[:send_to_cs] == 'true' # true/false
+          hsh[:channel] = fraud_detection[:channel] if fraud_detection[:channel]
+          hsh[:dispatch_method] = fraud_detection[:dispatch_method] if fraud_detection[:dispatch_method]
+          add_csmdds(hsh, fraud_detection)
+
+          post[:fraud_detection] = hsh
+        end
+      end
+
+      def add_csmdds(hsh, fraud_detection)
+        return unless fraud_detection[:csmdds]
+
+        csmdds_arr = []
+        fraud_detection[:csmdds].each do |csmdds|
+          csmdds_hsh = {}
+          csmdds_hsh[:code] = csmdds[:code].to_i
+          csmdds_hsh[:description] = csmdds[:description]
+          csmdds_arr.append(csmdds_hsh)
+        end
+        hsh[:csmdds] = csmdds_arr unless csmdds_arr.empty?
+      end
+
+      def parse(body)
+        return {} if body.nil?
+
+        JSON.parse(body)
+      end
+
+      def commit(method, endpoint, parameters = {}, options = {})
+        begin
+          raw_response = ssl_request(method, url(endpoint), post_data(parameters), headers(endpoint))
+          response = parse(raw_response)
+        rescue ResponseError => e
+          raw_response = e.response.body
+          response = parse(raw_response)
+        end
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response),
+          avs_result: AVSResult.new(code: response['some_avs_response_key']),
+          cvv_result: CVVResult.new(response['some_cvv_response_key']),
+          test: test?,
+          error_code: error_code_from(response)
+        )
+      end
+
+      def headers(endpoint)
+        {
+          'Content-Type' => 'application/json',
+          'apikey' => endpoint == 'tokens' ? @options[:public_key] : @options[:private_key]
+        }
+      end
+
+      def url(action, options = {})
+        base_url = (test? ? test_url : live_url)
+
+        return "#{base_url}/#{action}"
+      end
+
+      def success_from(response)
+        response.dig('status') == 'approved' || response.dig('status') == 'active' || response.dig('status') == 'pre_approved' || response.empty?
+      end
+
+      def message_from(response)
+        return '' if response.empty?
+
+        rejected?(response) ? message_from_status_details(response) : response.dig('status') || error_message(response) || response.dig('message')
+      end
+
+      def authorization_from(response)
+        return nil unless response.dig('id') || response.dig('bin')
+
+        "#{response.dig('id')}|#{response.dig('bin')}"
+      end
+
+      def post_data(parameters = {})
+        parameters.to_json
+      end
+
+      def error_code_from(response)
+        return if success_from(response)
+
+        error_code = nil
+        if error = response.dig('status_details', 'error')
+          error_code = error.dig('reason', 'id') || error['type']
+        elsif response['error_type']
+          error_code = response['error_type']
+        elsif response.dig('error', 'validation_errors')
+          error = response.dig('error')
+          validation_errors = error.dig('validation_errors', 0)
+          code = validation_errors['code'] if validation_errors && validation_errors['code']
+          param = validation_errors['param'] if validation_errors && validation_errors['param']
+          error_code = "#{error['error_type']} | #{code} | #{param}" if error['error_type']
+        elsif error = response.dig('error')
+          error_code = error.dig('reason', 'id')
+        end
+
+        error_code
+      end
+
+      def error_message(response)
+        return error_code_from(response) unless validation_errors = response.dig('validation_errors')
+
+        validation_errors = validation_errors[0]
+
+        "#{validation_errors.dig('code')}: #{validation_errors.dig('param')}"
+      end
+
+      def rejected?(response)
+        return response.dig('status') == 'rejected'
+      end
+
+      def message_from_status_details(response)
+        return unless error = response.dig('status_details', 'error')
+        return message_from_fraud_detection(response) if error.dig('type') == 'cybersource_error'
+
+        "#{error.dig('type')}: #{error.dig('reason', 'description')}"
+      end
+
+      def message_from_fraud_detection(response)
+        return error_message(response.dig('fraud_detection', 'status', 'details'))
+      end
+    end
+  end
+end

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

@@ -42,8 +42,8 @@ module ActiveMerchant #:nodoc:
         'ar' => 100,
         'co' => 100,
         'pe' => 300,
-        'mx' => 300,
-        'cl' => 5000
+        'mx' => 2000,
+        'cl' => 80000
       }
 
       def initialize(options = {})
@@ -183,6 +183,7 @@ module ActiveMerchant #:nodoc:
         post[:payment][:currency_code] = (options[:currency] || currency(money))
         post[:payment][:merchant_payment_code] = Digest::MD5.hexdigest(options[:order_id])
         post[:payment][:instalments] = options[:instalments] || 1
+        post[:payment][:order_number] = options[:order_id][0..39] if options[:order_id]
       end
 
       def add_card_or_token(post, payment)
@@ -214,6 +215,7 @@ module ActiveMerchant #:nodoc:
         post[:metadata] = options[:metadata] if options[:metadata]
         post[:metadata] = {} if post[:metadata].nil?
         post[:metadata][:merchant_payment_code] = options[:order_id] if options[:order_id]
+        post[:processing_type] = options[:processing_type] if options[:processing_type]
       end
 
       def parse(body)
@@ -222,7 +224,8 @@ module ActiveMerchant #:nodoc:
 
       def commit(action, parameters)
         url = url_for((test? ? test_url : live_url), action, parameters)
-        response = parse(ssl_request(HTTP_METHOD[action], url, post_data(action, parameters), { 'x-ebanx-client-user-agent': "ActiveMerchant/#{ActiveMerchant::VERSION}" }))
+
+        response = parse(ssl_request(HTTP_METHOD[action], url, post_data(action, parameters), headers(parameters)))
 
         success = success_from(action, response)
 
@@ -236,6 +239,19 @@ module ActiveMerchant #:nodoc:
         )
       end
 
+      def headers(params)
+        processing_type = params[:processing_type]
+        commit_headers = { 'x-ebanx-client-user-agent': "ActiveMerchant/#{ActiveMerchant::VERSION}" }
+
+        add_processing_type_to_commit_headers(commit_headers, processing_type) if processing_type == 'local'
+
+        commit_headers
+      end
+
+      def add_processing_type_to_commit_headers(commit_headers, processing_type)
+        commit_headers['x-ebanx-api-processing-type'] = processing_type
+      end
+
       def success_from(action, response)
         if %i[purchase capture refund].include?(action)
           response.try(:[], 'payment').try(:[], 'status') == 'CO'

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

@@ -298,7 +298,7 @@ module ActiveMerchant #:nodoc:
         xml.ssl_dynamic_dba                     options[:dba] if options.has_key?(:dba)
         xml.ssl_merchant_initiated_unscheduled  merchant_initiated_unscheduled(options) if merchant_initiated_unscheduled(options)
         xml.ssl_add_token                       options[:add_recurring_token] if options.has_key?(:add_recurring_token)
-        xml.ssl_token                           options[:ssl_token] if options.has_key?(:ssl_token)
+        xml.ssl_token                           options[:ssl_token] if options[:ssl_token]
         xml.ssl_customer_code                   options[:customer] if options.has_key?(:customer)
         xml.ssl_customer_number                 options[:customer_number] if options.has_key?(:customer_number)
         xml.ssl_entry_mode                      entry_mode(options) if entry_mode(options)
@@ -393,6 +393,7 @@ module ActiveMerchant #:nodoc:
 
       def commit(request)
         request = "xmldata=#{request}".delete('&')
+        store_action = request.match?('CCGETTOKEN')
 
         response = parse(ssl_post(test? ? self.test_url : self.live_url, request, headers))
         response = hash_html_decode(response)
@@ -402,7 +403,7 @@ module ActiveMerchant #:nodoc:
           response[:result_message] || response[:errorMessage],
           response,
           test: @options[:test] || test?,
-          authorization: authorization_from(response),
+          authorization: authorization_from(response, store_action),
           error_code: response[:errorCode],
           avs_result: { code: response[:avs_response] },
           cvv_result: response[:cvv2_response],
@@ -428,7 +429,9 @@ module ActiveMerchant #:nodoc:
         response.deep_transform_keys { |key| key.gsub('ssl_', '').to_sym }
       end
 
-      def authorization_from(response)
+      def authorization_from(response, store_action)
+        return response[:token] if store_action
+
         [response[:approval_code], response[:txn_id]].join(';')
       end
 

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

@@ -82,6 +82,19 @@ module ActiveMerchant #:nodoc:
         commit('CreditCardReturn', request, money)
       end
 
+      def credit(money, payment, options = {})
+        request = build_soap_request do |xml|
+          xml.CreditCardCredit(xmlns: 'https://transaction.elementexpress.com') do
+            add_credentials(xml)
+            add_payment_method(xml, payment)
+            add_transaction(xml, money, options)
+            add_terminal(xml, options)
+          end
+        end
+
+        commit('CreditCardCredit', request, money)
+      end
+
       def void(authorization, options = {})
         trans_id, trans_amount = split_authorization(authorization)
         options.merge!({ trans_id: trans_id, trans_amount: trans_amount, reversal_type: 'Full' })
@@ -186,9 +199,10 @@ module ActiveMerchant #:nodoc:
           xml.ReversalType options[:reversal_type] if options[:reversal_type]
           xml.TransactionID options[:trans_id] if options[:trans_id]
           xml.TransactionAmount amount(money.to_i) if money
-          xml.MarketCode 'Default' if money
+          xml.MarketCode market_code(money, options) if options[:market_code] || money
           xml.ReferenceNumber options[:order_id] || SecureRandom.hex(20)
-
+          xml.TicketNumber options[:ticket_number] if options[:ticket_number]
+          xml.MerchantSuppliedTransactionId options[:merchant_supplied_transaction_id] if options[:merchant_supplied_transaction_id]
           xml.PaymentType options[:payment_type] if options[:payment_type]
           xml.SubmissionType options[:submission_type] if options[:submission_type]
           xml.DuplicateCheckDisableFlag options[:duplicate_check_disable_flag].to_s == 'true' ? 'True' : 'False' unless options[:duplicate_check_disable_flag].nil?
@@ -197,6 +211,10 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def market_code(money, options)
+        options[:market_code] || 'Default'
+      end
+
       def add_terminal(xml, options)
         xml.terminal do
           xml.TerminalID options[:terminal_id] || '01'