activemerchant 1.119.0 → 1.124.0

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

@@ -16,8 +16,8 @@ module ActiveMerchant #:nodoc:
       self.homepage_url = 'https://www.adyen.com/'
       self.display_name = 'Adyen'
 
-      PAYMENT_API_VERSION = 'v40'
-      RECURRING_API_VERSION = 'v30'
+      PAYMENT_API_VERSION = 'v64'
+      RECURRING_API_VERSION = 'v49'
 
       STANDARD_ERROR_CODE_MAPPING = {
         '101' => STANDARD_ERROR_CODE[:incorrect_number],
@@ -59,6 +59,8 @@ module ActiveMerchant #:nodoc:
         add_3ds_authenticated_data(post, options)
         add_splits(post, options)
         add_recurring_contract(post, options)
+        add_network_transaction_reference(post, options)
+        add_application_info(post, options)
         commit('authorise', post, options)
       end
 
@@ -67,21 +69,35 @@ module ActiveMerchant #:nodoc:
         add_invoice_for_modification(post, money, options)
         add_reference(post, authorization, options)
         add_splits(post, options)
+        add_network_transaction_reference(post, options)
         commit('capture', post, options)
       end
 
       def refund(money, authorization, options = {})
         post = init_post(options)
         add_invoice_for_modification(post, money, options)
-        add_original_reference(post, authorization, options)
+        add_reference(post, authorization, options)
         add_splits(post, options)
+        add_network_transaction_reference(post, options)
         commit('refund', post, options)
       end
 
+      def credit(money, payment, options = {})
+        action = 'refundWithData'
+        post = init_post(options)
+        add_invoice(post, money, options)
+        add_payment(post, payment, options, action)
+        add_shopper_reference(post, options)
+        add_network_transaction_reference(post, options)
+        commit(action, post, options)
+      end
+
       def void(authorization, options = {})
         post = init_post(options)
+        endpoint = options[:cancel_or_refund] ? 'cancelOrRefund' : 'cancel'
         add_reference(post, authorization, options)
-        commit('cancel', post, options)
+        add_network_transaction_reference(post, options)
+        commit(endpoint, post, options)
       end
 
       def adjust(money, authorization, options = {})
@@ -138,12 +154,19 @@ module ActiveMerchant #:nodoc:
         true
       end
 
+      def supports_network_tokenization?
+        true
+      end
+
       def scrub(transcript)
         transcript.
           gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
-          gsub(%r(("number\\?":\\?")[^"]*)i, '\1[FILTERED]').
-          gsub(%r(("cvc\\?":\\?")[^"]*)i, '\1[FILTERED]').
-          gsub(%r(("cavv\\?":\\?")[^"]*)i, '\1[FILTERED]')
+          gsub(%r(("number\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("cvc\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("cavv\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("bankLocationId\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("iban\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("bankAccountNumber\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]')
       end
 
       private
@@ -195,7 +218,7 @@ module ActiveMerchant #:nodoc:
       }
 
       def add_extra_data(post, payment, options)
-        post[:telephoneNumber] = options[:billing_address][:phone] if options.dig(:billing_address, :phone)
+        post[:telephoneNumber] = (options[:billing_address][:phone_number] if options.dig(:billing_address, :phone_number)) || (options[:billing_address][:phone] if options.dig(:billing_address, :phone)) || ''
         post[:fraudOffset] = options[:fraud_offset] if options[:fraud_offset]
         post[:selectedBrand] = options[:selected_brand] if options[:selected_brand]
         post[:selectedBrand] ||= NETWORK_TOKENIZATION_CARD_SOURCE[payment.source.to_s] if payment.is_a?(NetworkTokenizationCreditCard)
@@ -318,7 +341,7 @@ module ActiveMerchant #:nodoc:
           post[:deliveryAddress][:stateOrProvince] = get_state(address)
           post[:deliveryAddress][:country] = address[:country] if address[:country]
         end
-        return unless post[:card]&.kind_of?(Hash)
+        return unless post[:bankAccount]&.kind_of?(Hash) || post[:card]&.kind_of?(Hash)
 
         if (address = options[:billing_address] || options[:address]) && address[:country]
           post[:billingAddress] = {}
@@ -341,6 +364,7 @@ module ActiveMerchant #:nodoc:
           value: localized_amount(money, currency),
           currency: currency
         }
+
         post[:amount] = amount
       end
 
@@ -353,17 +377,32 @@ module ActiveMerchant #:nodoc:
         post[:modificationAmount] = amount
       end
 
-      def add_payment(post, payment, options)
+      def add_payment(post, payment, options, action = nil)
         if payment.is_a?(String)
           _, _, recurring_detail_reference = payment.split('#')
           post[:selectedRecurringDetailReference] = recurring_detail_reference
           options[:recurring_contract_type] ||= 'RECURRING'
+        elsif payment.is_a?(Check)
+          add_bank_account(post, payment, options, action)
         else
           add_mpi_data_for_network_tokenization_card(post, payment) if payment.is_a?(NetworkTokenizationCreditCard)
           add_card(post, payment)
         end
       end
 
+      def add_bank_account(post, bank_account, options, action)
+        bank = {
+          bankAccountNumber: bank_account.account_number,
+          ownerName: bank_account.name,
+          countryCode: options[:billing_address][:country]
+        }
+
+        action == 'refundWithData' ? bank[:iban] = bank_account.routing_number : bank[:bankLocationId] = bank_account.routing_number
+
+        requires!(bank, :bankAccountNumber, :ownerName, :countryCode)
+        post[:bankAccount] = bank
+      end
+
       def add_card(post, credit_card)
         card = {
           expiryMonth: credit_card.month,
@@ -374,7 +413,7 @@ module ActiveMerchant #:nodoc:
         }
 
         card.delete_if { |_k, v| v.blank? }
-        card[:holderName] ||= 'Not Provided' if credit_card.is_a?(NetworkTokenizationCreditCard)
+        card[:holderName] ||= 'Not Provided'
         requires!(card, :expiryMonth, :expiryYear, :holderName, :number)
         post[:card] = card
       end
@@ -385,14 +424,16 @@ module ActiveMerchant #:nodoc:
         options
       end
 
-      def add_reference(post, authorization, options = {})
-        _, psp_reference, = authorization.split('#')
-        post[:originalReference] = single_reference(authorization) || psp_reference
+      def add_network_transaction_reference(post, options)
+        return unless ntid = options[:network_transaction_id] || options.dig(:stored_credential, :network_transaction_id)
+
+        post[:additionalData] = {} unless post[:additionalData]
+        post[:additionalData][:networkTxReference] = ntid
       end
 
-      def add_original_reference(post, authorization, options = {})
-        original_psp_reference, = authorization.split('#')
-        post[:originalReference] = single_reference(authorization) || original_psp_reference
+      def add_reference(post, authorization, options = {})
+        original_reference = authorization.split('#').reject(&:empty?).first
+        post[:originalReference] = original_reference
       end
 
       def add_mpi_data_for_network_tokenization_card(post, payment)
@@ -403,10 +444,6 @@ module ActiveMerchant #:nodoc:
         post[:mpiData][:eci] = payment.eci || '07'
       end
 
-      def single_reference(authorization)
-        authorization if !authorization.include?('#')
-      end
-
       def add_recurring_contract(post, options = {})
         return unless options[:recurring_contract_type]
 
@@ -417,6 +454,31 @@ module ActiveMerchant #:nodoc:
         post[:recurring] = recurring
       end
 
+      def add_application_info(post, options)
+        post[:applicationInfo] ||= {}
+        add_external_platform(post, options)
+        add_merchant_application(post, options)
+      end
+
+      def add_external_platform(post, options)
+        return unless options[:externalPlatform]
+
+        post[:applicationInfo][:externalPlatform] = {
+          name: options[:externalPlatform][:name],
+          version: options[:externalPlatform][:version],
+          integrator: options[:externalPlatform][:integrator]
+        }
+      end
+
+      def add_merchant_application(post, options)
+        return unless options[:merchantApplication]
+
+        post[:applicationInfo][:merchantApplication] = {
+          name: options[:merchantApplication][:name],
+          version: options[:merchantApplication][:version]
+        }
+      end
+
       def add_installments(post, options)
         post[:installments] = {
           value: options[:installments]
@@ -498,6 +560,7 @@ module ActiveMerchant #:nodoc:
           raw_response = e.response.body
           response = parse(raw_response)
         end
+
         success = success_from(action, response, options)
         Response.new(
           success,
@@ -506,6 +569,7 @@ module ActiveMerchant #:nodoc:
           authorization: authorization_from(action, parameters, response),
           test: test?,
           error_code: success ? nil : error_code_from(response),
+          network_transaction_id: network_transaction_id_from(response),
           avs_result: AVSResult.new(code: avs_code_from(response)),
           cvv_result: CVVResult.new(cvv_result_from(response))
         )
@@ -552,11 +616,10 @@ module ActiveMerchant #:nodoc:
           response['refusalReason'] = 'Received unexpected 3DS authentication response. Use the execute_threed and/or threed_dynamic options to initiate a proper 3DS flow.'
           return false
         end
-
         case action.to_s
         when 'authorise', 'authorise3d'
           %w[Authorised Received RedirectShopper].include?(response['resultCode'])
-        when 'capture', 'refund', 'cancel'
+        when 'capture', 'refund', 'cancel', 'cancelOrRefund'
           response['response'] == "[#{action}-received]"
         when 'adjustAuthorisation'
           response['response'] == 'Authorised' || response['response'] == '[adjustAuthorisation-received]'
@@ -564,6 +627,8 @@ module ActiveMerchant #:nodoc:
           response['result'] == 'Success'
         when 'disable'
           response['response'] == '[detail-successfully-disabled]'
+        when 'refundWithData'
+          response['resultCode'] == 'Received'
         else
           false
         end
@@ -572,7 +637,7 @@ module ActiveMerchant #:nodoc:
       def message_from(action, response)
         return authorize_message_from(response) if %w(authorise authorise3d authorise3ds2).include?(action.to_s)
 
-        response['response'] || response['message'] || response['result']
+        response['response'] || response['message'] || response['result'] || response['resultCode']
       end
 
       def authorize_message_from(response)
@@ -595,7 +660,7 @@ module ActiveMerchant #:nodoc:
       def init_post(options = {})
         post = {}
         add_merchant_account(post, options)
-        post[:reference] = options[:order_id] if options[:order_id]
+        post[:reference] = options[:order_id][0..79] if options[:order_id]
         post
       end
 
@@ -607,6 +672,10 @@ module ActiveMerchant #:nodoc:
         STANDARD_ERROR_CODE_MAPPING[response['errorCode']]
       end
 
+      def network_transaction_id_from(response)
+        response.dig('additionalData', 'networkTxReference')
+      end
+
       def add_browser_info(browser_info, post)
         return unless browser_info
 

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

@@ -567,14 +567,16 @@ module ActiveMerchant
 
         xml.customerIP(options[:ip]) unless empty?(options[:ip])
 
-        xml.cardholderAuthentication do
-          three_d_secure = options.fetch(:three_d_secure, {})
-          xml.authenticationIndicator(
-            options[:authentication_indicator] || three_d_secure[:eci]
-          )
-          xml.cardholderAuthenticationValue(
-            options[:cardholder_authentication_value] || three_d_secure[:cavv]
-          )
+        if !empty?(options.fetch(:three_d_secure, {})) || options[:authentication_indicator] || options[:cardholder_authentication_value]
+          xml.cardholderAuthentication do
+            three_d_secure = options.fetch(:three_d_secure, {})
+            xml.authenticationIndicator(
+              options[:authentication_indicator] || three_d_secure[:eci]
+            )
+            xml.cardholderAuthenticationValue(
+              options[:cardholder_authentication_value] || three_d_secure[:cavv]
+            )
+          end
         end
       end
 
@@ -708,9 +710,10 @@ module ActiveMerchant
         return unless options[:stored_credential]
 
         xml.processingOptions do
-          if options[:stored_credential][:initial_transaction]
+          if options[:stored_credential][:initial_transaction] && options[:stored_credential][:reason_type] == 'recurring'
+            xml.isFirstRecurringPayment 'true'
+          elsif options[:stored_credential][:initial_transaction]
             xml.isFirstSubsequentAuth 'true'
-            # xml.isFirstRecurringPayment 'true' if options[:stored_credential][:reason_type] == 'recurring'
           elsif options[:stored_credential][:initiator] == 'cardholder'
             xml.isStoredCredentials 'true'
           else
@@ -720,7 +723,7 @@ module ActiveMerchant
       end
 
       def add_subsequent_auth_information(xml, options)
-        return unless options.dig(:stored_credential, :reason_type) == 'unscheduled'
+        return unless options.dig(:stored_credential, :initiator) == 'merchant'
 
         xml.subsequentAuthInformation do
           xml.reason options[:stored_credential_reason_type_override] if options[:stored_credential_reason_type_override]
@@ -934,6 +937,11 @@ module ActiveMerchant
             empty?(element.content) ? nil : element.content
           end
 
+        response[:network_trans_id] =
+          if element = doc.at_xpath('//networkTransId')
+            empty?(element.content) ? nil : element.content
+          end
+
         response
       end
 

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

@@ -563,6 +563,8 @@ module ActiveMerchant #:nodoc:
 
       def build_get_customer_profile_request(xml, options)
         xml.tag!('customerProfileId', options[:customer_profile_id])
+        xml.tag!('unmaskExpirationDate', options[:unmask_expiration_date]) if options[:unmask_expiration_date]
+        xml.tag!('includeIssuerInfo', options[:include_issuer_info]) if options[:include_issuer_info]
         xml.target!
       end
 
@@ -574,6 +576,7 @@ module ActiveMerchant #:nodoc:
         xml.tag!('customerProfileId', options[:customer_profile_id])
         xml.tag!('customerPaymentProfileId', options[:customer_payment_profile_id])
         xml.tag!('unmaskExpirationDate', options[:unmask_expiration_date]) if options[:unmask_expiration_date]
+        xml.tag!('includeIssuerInfo', options[:include_issuer_info]) if options[:include_issuer_info]
         xml.target!
       end
 

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

@@ -84,6 +84,7 @@ module ActiveMerchant #:nodoc:
         add_customer_data(post, options)
         add_rebill(post, options) if options[:rebill]
         add_duplicate_override(post, options)
+        add_stored_credential(post, options)
         post[:TRANS_TYPE] = 'AUTH'
         commit('AUTH_ONLY', money, post, options)
       end
@@ -107,6 +108,7 @@ module ActiveMerchant #:nodoc:
         add_customer_data(post, options)
         add_rebill(post, options) if options[:rebill]
         add_duplicate_override(post, options)
+        add_stored_credential(post, options)
         post[:TRANS_TYPE] = 'SALE'
         commit('AUTH_CAPTURE', money, post, options)
       end
@@ -461,6 +463,33 @@ module ActiveMerchant #:nodoc:
         post[:REB_CYCLES]      = options[:rebill_cycles]
       end
 
+      def add_stored_credential(post, options)
+        post[:cof] = initiator(options)
+        post[:cofscheduled] = scheduled(options)
+      end
+
+      def initiator(options)
+        return unless initiator = options.dig(:stored_credential, :initiator)
+
+        case initiator
+        when 'merchant'
+          'M'
+        when 'cardholder'
+          'C'
+        end
+      end
+
+      def scheduled(options)
+        return unless reason_type = options.dig(:stored_credential, :reason_type)
+
+        case reason_type
+        when 'recurring' || 'installment'
+          'Y'
+        when 'unscheduled'
+          'N'
+        end
+      end
+
       def post_data(action, parameters = {})
         post = {}
         post[:version]        = '1'

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

@@ -386,7 +386,7 @@ module ActiveMerchant
 
       def parse(response)
         return bad_authentication_response if response.code.to_i == 401
-        return forbidden_response(response.body) if response.code.to_i == 403
+        return generic_error_response(response.body) if [403, 429].include?(response.code.to_i)
 
         parsed = {}
         doc = Nokogiri::XML(response.body)
@@ -564,7 +564,7 @@ module ActiveMerchant
         { 'description' => 'Unable to authenticate.  Please check your credentials.' }
       end
 
-      def forbidden_response(body)
+      def generic_error_response(body)
         { 'description' => body }
       end
     end

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

@@ -7,7 +7,7 @@ rescue LoadError
   raise 'Could not load the braintree gem.  Use `gem install braintree` to install it.'
 end
 
-raise "Need braintree gem >= 2.78.0. Run `gem install braintree --version '~>2.78'` to get the correct version." unless Braintree::Version::Major == 2 && Braintree::Version::Minor >= 78
+raise 'Need braintree gem >= 2.0.0.' unless Braintree::Version::Major >= 2 && Braintree::Version::Minor >= 0
 
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
@@ -115,10 +115,36 @@ module ActiveMerchant #:nodoc:
         end
       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) }
+      def verify(creditcard, options = {})
+        if options[:allow_card_verification] == true
+          options.delete(:allow_card_verification)
+          exp_month = creditcard.month.to_s
+          exp_year = creditcard.year.to_s
+          expiration = "#{exp_month}/#{exp_year}"
+          payload = {
+            credit_card: {
+              number: creditcard.number,
+              expiration_date: expiration,
+              cvv: creditcard.verification_value,
+              billing_address: {
+                postal_code: options[:billing_address][:zip]
+              }
+            }
+          }
+          commit do
+            result = @braintree_gateway.verification.create(payload)
+            response = Response.new(result.success?, message_from_transaction_result(result), response_options(result))
+            response.cvv_result['message'] = ''
+            response.cvv_result['code'] = response.params['cvv_result'] if response.params['cvv_result']
+            response.avs_result['code'] = response.params['avs_result'][:code] if response.params.dig('avs_result', :code)
+            response
+          end
+
+        else
+          MultiResponse.run(:use_first_response) do |r|
+            r.process { authorize(100, creditcard, options) }
+            r.process(:ignore_result) { void(r.authorization, options) }
+          end
         end
       end
 
@@ -368,7 +394,11 @@ module ActiveMerchant #:nodoc:
 
       def response_options(result)
         options = {}
-        if result.transaction
+        if result.credit_card_verification
+          options[:authorization] = result.credit_card_verification.id
+          options[:avs_result] = { code: avs_code_from(result.credit_card_verification) }
+          options[:cvv_result] = result.credit_card_verification.cvv_response_code
+        elsif result.transaction
           options[:authorization] = result.transaction.id
           options[:avs_result] = { code: avs_code_from(result.transaction) }
           options[:cvv_result] = result.transaction.cvv_response_code
@@ -558,7 +588,8 @@ module ActiveMerchant #:nodoc:
           'merchant_account_id'     => transaction.merchant_account_id,
           'risk_data'               => risk_data,
           'network_transaction_id'  => transaction.network_transaction_id || nil,
-          'processor_response_code' => response_code_from_result(result)
+          'processor_response_code' => response_code_from_result(result),
+          'recurring'               => transaction.recurring
         }
       end
 
@@ -592,6 +623,7 @@ module ActiveMerchant #:nodoc:
         add_addresses(parameters, options)
 
         add_descriptor(parameters, options)
+        add_risk_data(parameters, options)
         add_travel_data(parameters, options) if options[:travel_data]
         add_lodging_data(parameters, options) if options[:lodging_data]
         add_channel(parameters, options)
@@ -652,6 +684,15 @@ module ActiveMerchant #:nodoc:
         }
       end
 
+      def add_risk_data(parameters, options)
+        return unless options[:risk_data]
+
+        parameters[:risk_data] = {
+          customer_browser: options[:risk_data][:customer_browser],
+          customer_ip: options[:risk_data][:customer_ip]
+        }
+      end
+
       def add_level_2_data(parameters, options)
         parameters[:tax_amount] = options[:tax_amount] if options[:tax_amount]
         parameters[:tax_exempt] = options[:tax_exempt] if options[:tax_exempt]
@@ -730,6 +771,8 @@ module ActiveMerchant #:nodoc:
           else
             parameters[:transaction_source] = stored_credential[:reason_type]
           end
+        elsif %w(recurring_first moto).include?(stored_credential[:reason_type])
+          parameters[:transaction_source] = stored_credential[:reason_type]
         else
           parameters[:transaction_source] = ''
         end
@@ -761,7 +804,8 @@ module ActiveMerchant #:nodoc:
                 eci_indicator: credit_card_or_vault_id.eci
               }
             elsif credit_card_or_vault_id.source == :android_pay || credit_card_or_vault_id.source == :google_pay
-              parameters[:android_pay_card] = {
+              Braintree::Version::Major < 3 ? pay_card = :android_pay_card : pay_card = :google_pay_card
+              parameters[pay_card] = {
                 number: credit_card_or_vault_id.number,
                 cryptogram: credit_card_or_vault_id.payment_cryptogram,
                 expiration_month: credit_card_or_vault_id.month.to_s.rjust(2, '0'),

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

@@ -150,23 +150,13 @@ module ActiveMerchant #:nodoc:
 
       def authorize(money, credit_card_or_reference, options = {})
         post = {}
-        add_pair(post, :captureDelay, -1)
-        add_amount(post, money, options)
-        add_invoice(post, credit_card_or_reference, money, options)
-        add_credit_card_or_reference(post, credit_card_or_reference)
-        add_customer_data(post, options)
-        add_remote_address(post, options)
+        add_auth_purchase(post, -1, money, credit_card_or_reference, options)
         commit('SALE', post)
       end
 
       def purchase(money, credit_card_or_reference, options = {})
         post = {}
-        add_pair(post, :captureDelay, 0)
-        add_amount(post, money, options)
-        add_invoice(post, credit_card_or_reference, money, options)
-        add_credit_card_or_reference(post, credit_card_or_reference)
-        add_customer_data(post, options)
-        add_remote_address(post, options)
+        add_auth_purchase(post, 0, money, credit_card_or_reference, options)
         commit('SALE', post)
       end
 
@@ -184,6 +174,7 @@ module ActiveMerchant #:nodoc:
         add_pair(post, :xref, authorization)
         add_amount(post, money, options)
         add_remote_address(post, options)
+        add_country_code(post, options)
         response = commit('REFUND_SALE', post)
 
         return response if response.success?
@@ -223,6 +214,16 @@ module ActiveMerchant #:nodoc:
 
       private
 
+      def add_auth_purchase(post, pair_value, money, credit_card_or_reference, options)
+        add_pair(post, :captureDelay, pair_value)
+        add_amount(post, money, options)
+        add_invoice(post, credit_card_or_reference, money, options)
+        add_credit_card_or_reference(post, credit_card_or_reference)
+        add_customer_data(post, options)
+        add_remote_address(post, options)
+        add_country_code(post, options)
+      end
+
       def add_amount(post, money, options)
         currency = options[:currency] || currency(money)
         add_pair(post, :amount, localized_amount(money, currency), required: true)
@@ -286,6 +287,10 @@ module ActiveMerchant #:nodoc:
         add_pair(post, :remoteAddress, options[:ip] || '1.1.1.1')
       end
 
+      def add_country_code(post, options)
+        post[:countryCode] = options[:country_code] || self.supported_countries[0]
+      end
+
       def normalize_line_endings(str)
         str.gsub(/%0D%0A|%0A%0D|%0D/, '%0A')
       end
@@ -309,7 +314,6 @@ module ActiveMerchant #:nodoc:
       end
 
       def commit(action, parameters)
-        parameters.update(countryCode: self.supported_countries[0]) unless %w[CAPTURE CANCEL].include?(action)
         parameters.update(
           merchantID: @options[:login],
           action: action

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

@@ -8,7 +8,7 @@ module ActiveMerchant #:nodoc:
 
       self.supported_countries = ['US']
       self.supported_cardtypes = %i[visa master american_express discover diners_club jcb]
-      self.homepage_url        = 'http://www.higherone.com/'
+      self.homepage_url        = 'https://transactcampus.com'
       self.display_name        = 'Cashnet'
       self.money_format        = :dollars
       self.max_retries         = 0
@@ -76,7 +76,7 @@ module ActiveMerchant #:nodoc:
 
         return unparsable_response(raw_response) unless parsed_response
 
-        success = (parsed_response[:result] == '0')
+        success = success?(parsed_response)
         Response.new(
           success,
           CASHNET_CODES[parsed_response[:result]],
@@ -86,6 +86,10 @@ module ActiveMerchant #:nodoc:
         )
       end
 
+      def success?(response)
+        response[:result] == '0'
+      end
+
       def post_data(action, parameters = {})
         post = {}
         post[:command]        = action
@@ -191,6 +195,7 @@ module ActiveMerchant #:nodoc:
         '215' => 'Old PIN does not validate ',
         '221' => 'Invalid credit card processor type specified in location or payment code',
         '222' => 'Credit card processor error',
+        '230' => 'Host Error (USE VOID OR REVERSAL TO REFUND UNSETTLED TRANSACTIONS)',
         '280' => 'SmartPay transaction not posted',
         '301' => 'Original transaction not found for this customer',
         '302' => 'Amount to refund exceeds original payment amount or is missing',