activemerchant 1.62.0 → 1.79.2

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

@@ -16,7 +16,8 @@ module ActiveMerchant #:nodoc:
         :capture        => 'cc:capture',
         :refund         => 'cc:refund',
         :void           => 'cc:void',
-        :void_release   => 'cc:void:release'
+        :void_release   => 'cc:void:release',
+        :check_purchase => 'check:sale'
       }
 
       STANDARD_ERROR_CODE_MAPPING = {
@@ -48,7 +49,7 @@ module ActiveMerchant #:nodoc:
 
         add_amount(post, money)
         add_invoice(post, options)
-        add_credit_card(post, credit_card)
+        add_payment(post, credit_card)
         unless credit_card.track_data.present?
           add_address(post, credit_card, options)
           add_customer_data(post, options)
@@ -59,20 +60,20 @@ module ActiveMerchant #:nodoc:
         commit(:authorization, post)
       end
 
-      def purchase(money, credit_card, options = {})
+      def purchase(money, payment, options = {})
         post = {}
 
         add_amount(post, money)
         add_invoice(post, options)
-        add_credit_card(post, credit_card)
-        unless credit_card.track_data.present?
-          add_address(post, credit_card, options)
+        add_payment(post, payment)
+        unless payment.respond_to?(:track_data) && payment.track_data.present?
+          add_address(post, payment, options)
           add_customer_data(post, options)
         end
         add_split_payments(post, options)
         add_test_mode(post, options)
 
-        commit(:purchase, post)
+        payment.respond_to?(:routing_number) ? commit(:check_purchase, post) : commit(:purchase, post)
       end
 
       def capture(money, authorization, options = {})
@@ -106,6 +107,19 @@ module ActiveMerchant #:nodoc:
         commit(command, post)
       end
 
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((&?UMcard=)\d*(&?))i, '\1[FILTERED]\2').
+          gsub(%r((&?UMcvv2=)\d*(&?))i, '\1[FILTERED]\2').
+          gsub(%r((&?UMmagstripe=)[^&]*)i, '\1[FILTERED]\2').
+          gsub(%r((&?UMaccount=)[^&]*)i, '\1[FILTERED]').
+          gsub(%r((&?UMkey=)[^&]*)i, '\1[FILTERED]')
+      end
+
     private
 
       def add_amount(post, money)
@@ -126,7 +140,12 @@ module ActiveMerchant #:nodoc:
 
         if options.has_key? :email
           post[:custemail] = options[:email]
-          post[:custreceipt] = 'No'
+          if options[:cust_receipt]
+            post[:custreceipt] = options[:cust_receipt]
+            post[:custreceiptname] = options[:cust_receipt_name] if options[:cust_receipt_name]
+          else
+            post[:custreceipt] = 'No'
+          end
         end
 
         if options.has_key? :customer
@@ -138,19 +157,19 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def add_address(post, credit_card, options)
+      def add_address(post, payment, options)
         billing_address = options[:billing_address] || options[:address]
 
-        add_address_for_type(:billing, post, credit_card, billing_address) if billing_address
-        add_address_for_type(:shipping, post, credit_card, options[:shipping_address]) if options[:shipping_address]
+        add_address_for_type(:billing, post, payment, billing_address) if billing_address
+        add_address_for_type(:shipping, post, payment, options[:shipping_address]) if options[:shipping_address]
       end
 
-      def add_address_for_type(type, post, credit_card, address)
+      def add_address_for_type(type, post, payment, address)
         prefix = address_key_prefix(type)
         first_name, last_name = split_names(address[:name])
 
-        post[address_key(prefix, 'fname')]    = first_name.blank? && last_name.blank? ? credit_card.first_name : first_name
-        post[address_key(prefix, 'lname')]    = first_name.blank? && last_name.blank? ? credit_card.last_name : last_name
+        post[address_key(prefix, 'fname')]    = first_name.blank? && last_name.blank? ? payment.first_name : first_name
+        post[address_key(prefix, 'lname')]    = first_name.blank? && last_name.blank? ? payment.last_name : last_name
         post[address_key(prefix, 'company')]  = address[:company]   unless address[:company].blank?
         post[address_key(prefix, 'street')]   = address[:address1]  unless address[:address1].blank?
         post[address_key(prefix, 'street2')]  = address[:address2]  unless address[:address2].blank?
@@ -177,16 +196,20 @@ module ActiveMerchant #:nodoc:
         post[:description]  = options[:description]
       end
 
-      def add_credit_card(post, credit_card)
-        if credit_card.track_data.present?
-          post[:magstripe] = credit_card.track_data
+      def add_payment(post, payment)
+        if payment.respond_to?(:routing_number)
+          post[:account] = payment.account_number
+          post[:routing] = payment.routing_number
+          post[:name]    = payment.name unless payment.name.blank?
+        elsif payment.respond_to?(:track_data) && payment.track_data.present?
+          post[:magstripe] = payment.track_data
           post[:cardpresent] = true
         else
-          post[:card]   = credit_card.number
-          post[:cvv2]   = credit_card.verification_value if credit_card.verification_value?
-          post[:expir]  = expdate(credit_card)
-          post[:name]   = credit_card.name unless credit_card.name.blank?
-          post[:cardpresent] = true if credit_card.manual_entry
+          post[:card]   = payment.number
+          post[:cvv2]   = payment.verification_value if payment.verification_value?
+          post[:expir]  = expdate(payment)
+          post[:name]   = payment.name unless payment.name.blank?
+          post[:cardpresent] = true if payment.manual_entry
         end
       end
 

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

@@ -5,7 +5,7 @@ module ActiveMerchant
     class VancoGateway < Gateway
       include Empty
 
-      self.test_url = 'https://www.vancodev.com/cgi-bin/wstest2.vps'
+      self.test_url = 'https://uat.vancopayments.com/cgi-bin/ws2.vps'
       self.live_url = 'https://myvanco.vancopayments.com/cgi-bin/ws2.vps'
 
       self.supported_countries = ['US']

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

@@ -4,7 +4,7 @@ module ActiveMerchant #:nodoc:
       self.test_url = 'https://stage.wepayapi.com/v2'
       self.live_url = 'https://wepayapi.com/v2'
 
-      self.supported_countries = ['US']
+      self.supported_countries = ['US', 'CA']
       self.supported_cardtypes = [:visa, :master, :american_express, :discover]
       self.homepage_url = 'https://www.wepay.com/'
       self.default_currency = 'USD'
@@ -18,38 +18,47 @@ module ActiveMerchant #:nodoc:
       def purchase(money, payment_method, options = {})
         post = {}
         if payment_method.is_a?(String)
-          purchase_with_token(post, money, payment_method, options)
+          MultiResponse.run do |r|
+            r.process { authorize_with_token(post, money, payment_method, options) }
+            r.process { capture(money, r.authorization, options) }
+          end
         else
           MultiResponse.run do |r|
             r.process { store(payment_method, options) }
-            r.process { purchase_with_token(post, money, split_authorization(r.authorization).first, options) }
+            r.process { authorize_with_token(post, money, r.authorization, options) }
+            r.process { capture(money, r.authorization, options) }
           end
         end
       end
 
       def authorize(money, payment_method, options = {})
-        post = {auto_capture: 0}
+        post = {}
         if payment_method.is_a?(String)
-          purchase_with_token(post, money, payment_method, options)
+          authorize_with_token(post, money, payment_method, options)
         else
           MultiResponse.run do |r|
             r.process { store(payment_method, options) }
-            r.process { purchase_with_token(post, money, split_authorization(r.authorization).first, options) }
+            r.process { authorize_with_token(post, money, r.authorization, options) }
           end
         end
       end
 
       def capture(money, identifier, options = {})
+        checkout_id, original_amount = split_authorization(identifier)
+
         post = {}
-        post[:checkout_id] = split_authorization(identifier).first
-        commit('/checkout/capture', post)
+        post[:checkout_id] = checkout_id
+        if(money && (original_amount != amount(money)))
+          post[:amount] = amount(money)
+        end
+        commit('/checkout/capture', post, options)
       end
 
       def void(identifier, options = {})
         post = {}
         post[:checkout_id] = split_authorization(identifier).first
         post[:cancel_reason] = (options[:description] || "Void")
-        commit('/checkout/cancel', post)
+        commit('/checkout/cancel', post, options)
       end
 
       def refund(money, identifier, options = {})
@@ -61,68 +70,70 @@ module ActiveMerchant #:nodoc:
           post[:amount] = amount(money)
         end
         post[:refund_reason] = (options[:description] || "Refund")
-        post[:app_fee] = options[:application_fee] if options[:application_fee]
         post[:payer_email_message] = options[:payer_email_message] if options[:payer_email_message]
         post[:payee_email_message] = options[:payee_email_message] if options[:payee_email_message]
-        commit("/checkout/refund", post)
+        commit("/checkout/refund", post, options)
       end
 
       def store(creditcard, options = {})
-        requires!(options, :email)
-
         post = {}
         post[:client_id] = @options[:client_id]
         post[:user_name] = "#{creditcard.first_name} #{creditcard.last_name}"
         post[:email] = options[:email] || "unspecified@example.com"
         post[:cc_number] = creditcard.number
         post[:cvv] = creditcard.verification_value unless options[:recurring]
-        post[:expiration_month] = "#{creditcard.month}"
-        post[:expiration_year] = "#{creditcard.year}"
-        post[:original_ip] = options[:ip] if options[:ip]
-        post[:original_device] = options[:device_fingerprint] if options[:device_fingerprint]
+        post[:expiration_month] = creditcard.month
+        post[:expiration_year] = creditcard.year
+
         if(billing_address = (options[:billing_address] || options[:address]))
-          post[:address] = {
-            "address1" => billing_address[:address1],
-            "city"     => billing_address[:city],
-            "country"  => billing_address[:country]
-          }
-          if(post[:country] == "US")
-            post[:address]["zip"] = billing_address[:zip]
-            post[:address]["state"] = billing_address[:state]
-          else
-            post[:address]["region"] = billing_address[:state]
-            post[:address]["postcode"] = billing_address[:zip]
-          end
+          post[:address] = {}
+          post[:address]["address1"] = billing_address[:address1] if billing_address[:address1]
+          post[:address]["city"]     = billing_address[:city] if billing_address[:city]
+          post[:address]["country"]  = billing_address[:country]  if billing_address[:country]
+          post[:address]["region"]   = billing_address[:state]  if billing_address[:state]
+          post[:address]["postal_code"] = billing_address[:zip]
         end
 
         if options[:recurring] == true
           post[:client_secret] = @options[:client_secret]
-          commit('/credit_card/transfer', post)
+          commit('/credit_card/transfer', post, options)
         else
-          commit('/credit_card/create', post)
+          post[:original_device] = options[:device_fingerprint] if options[:device_fingerprint]
+          post[:original_ip] = options[:ip] if options[:ip]
+          commit('/credit_card/create', post, options)
         end
       end
 
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((\\?"cc_number\\?":\\?")[^\\"]+(\\?"))i, '\1[FILTERED]\2').
+          gsub(%r((\\?"cvv\\?":\\?")[^\\"]+(\\?"))i, '\1[FILTERED]\2').
+          gsub(%r((Authorization: Bearer )\w+)i, '\1[FILTERED]\2')
+      end
+
       private
 
-      def purchase_with_token(post, money, token, options)
+      def authorize_with_token(post, money, token, options)
         add_token(post, token)
         add_product_data(post, money, options)
-        commit('/checkout/create', post)
+        commit('/checkout/create', post, options)
       end
 
       def add_product_data(post, money, options)
         post[:account_id] = @options[:account_id]
         post[:amount] = amount(money)
         post[:short_description] = (options[:description] || "Purchase")
-        post[:type] = (options[:type] || "GOODS")
+        post[:type] = (options[:type] || "goods")
         post[:currency] = (options[:currency] || currency(money))
         post[:long_description] = options[:long_description] if options[:long_description]
         post[:payer_email_message] = options[:payer_email_message] if options[:payer_email_message]
         post[:payee_email_message] = options[:payee_email_message] if options[:payee_email_message]
         post[:reference_id] = options[:order_id] if options[:order_id]
-        post[:app_fee] = options[:application_fee] if options[:application_fee]
-        post[:fee_payer] = options[:fee_payer] if options[:fee_payer]
+        post[:unique_id] = options[:unique_id] if options[:unique_id]
         post[:redirect_uri] = options[:redirect_uri] if options[:redirect_uri]
         post[:callback_uri] = options[:callback_uri] if options[:callback_uri]
         post[:fallback_uri] = options[:fallback_uri] if options[:fallback_uri]
@@ -133,11 +144,28 @@ module ActiveMerchant #:nodoc:
         post[:preapproval_id] = options[:preapproval_id] if options[:preapproval_id]
         post[:prefill_info] = options[:prefill_info] if options[:prefill_info]
         post[:funding_sources] = options[:funding_sources] if options[:funding_sources]
+        post[:payer_rbits] = options[:payer_rbits] if options[:payer_rbits]
+        post[:transaction_rbits] = options[:transaction_rbits] if options[:transaction_rbits]
+        add_fee(post, options)
       end
 
       def add_token(post, token)
-        post[:payment_method_id]   = token
-        post[:payment_method_type] = "credit_card"
+        payment_method = {}
+        payment_method[:type] = "credit_card"
+        payment_method[:credit_card] = {
+          id: token,
+          auto_capture: false
+        }
+
+        post[:payment_method] = payment_method
+      end
+
+      def add_fee(post, options)
+        if options[:application_fee] || options[:fee_payer]
+          post[:fee] = {}
+          post[:fee][:app_fee] = options[:application_fee] if options[:application_fee]
+          post[:fee][:fee_payer] = options[:fee_payer] if options[:fee_payer]
+        end
       end
 
       def parse(response)
@@ -149,7 +177,7 @@ module ActiveMerchant #:nodoc:
           response = parse(ssl_post(
             ((test? ? test_url : live_url) + action),
             params.to_json,
-            headers
+            headers(options)
           ))
         rescue ResponseError => e
           response = parse(e.response.body)
@@ -178,7 +206,8 @@ module ActiveMerchant #:nodoc:
       def authorization_from(response, params)
         return response["credit_card_id"].to_s if response["credit_card_id"]
 
-        [response["checkout_id"], params[:amount]].join('|')
+        original_amount = response["amount"].nil? ? nil : sprintf("%0.02f", response["amount"])
+        [response["checkout_id"], original_amount].join('|')
       end
 
       def split_authorization(authorization)
@@ -192,14 +221,18 @@ module ActiveMerchant #:nodoc:
         return Response.new(false, message)
       end
 
-      def headers
-        {
-          "Content-Type"  => "application/json",
-          "User-Agent"    => "ActiveMerchantBindings/#{ActiveMerchant::VERSION}",
-          "Authorization" => "Bearer #{@options[:access_token]}"
+      def headers(options)
+        headers = {
+          "Content-Type"      => "application/json",
+          "User-Agent"        => "ActiveMerchantBindings/#{ActiveMerchant::VERSION}",
+          "Authorization"     => "Bearer #{@options[:access_token]}"
         }
+        headers["Api-Version"] = options[:version] if options[:version]
+        headers["Client-IP"] = options[:ip] if options[:ip]
+        headers["WePay-Risk-Token"] = options[:risk_token] if options[:risk_token]
+
+        headers
       end
     end
   end
 end
-

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

@@ -235,17 +235,18 @@ module ActiveMerchant #:nodoc:
               add_address(xml, options[:billing_address])
             when :capture, :bookback
               xml.tag! 'GuWID', options[:preauthorization]
-              add_amount(xml, money)
+              add_amount(xml, money, options)
             when :reversal
               xml.tag! 'GuWID', options[:preauthorization]
             end
+            add_customer_data(xml, options)
           end
         end
       end
 
       # Includes the payment (amount, currency, country) to the transaction-xml
       def add_invoice(xml, money, options)
-        add_amount(xml, money)
+        add_amount(xml, money, options)
         xml.tag! 'Currency', options[:currency] || currency(money)
         xml.tag! 'CountryCode', options[:billing_address][:country]
         xml.tag! 'RECURRING_TRANSACTION' do
@@ -254,8 +255,8 @@ module ActiveMerchant #:nodoc:
       end
 
       # Include the amount in the transaction-xml
-      def add_amount(xml, money)
-        xml.tag! 'Amount', amount(money)
+      def add_amount(xml, money, options)
+        xml.tag! 'Amount', localized_amount(money, options[:currency] || currency(money))
       end
 
       # Includes the credit-card data to the transaction-xml

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

@@ -6,9 +6,10 @@ module ActiveMerchant #:nodoc:
 
       self.default_currency = 'GBP'
       self.money_format = :cents
-      self.supported_countries = %w(HK GB AU AD BE CH CY CZ DE DK ES FI FR GI GR HU IE IL IT LI LU MC MT NL NO NZ PL PT SE SG SI SM TR UM VA)
+      self.supported_countries = %w(HK GB AU AD AR BE BR CA CH CN CO CR CY CZ DE DK ES FI FR GI GR HU IE IN IT JP LI LU MC MT MY MX NL NO NZ PA PE PL PT SE SG SI SM TR UM VA)
       self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :maestro, :laser, :switch]
       self.currencies_without_fractions = %w(HUF IDR ISK JPY KRW)
+      self.currencies_with_three_decimal_places = %w(BHD KWD OMR RSD TND)
       self.homepage_url = 'http://www.worldpay.com/'
       self.display_name = 'Worldpay Global'
 
@@ -54,22 +55,35 @@ module ActiveMerchant #:nodoc:
 
       def void(authorization, options = {})
         MultiResponse.run do |r|
-          r.process{inquire_request(authorization, options, "AUTHORISED")}
+          r.process{inquire_request(authorization, options, "AUTHORISED")} unless options[:authorization_validated]
           r.process{cancel_request(authorization, options)}
         end
       end
 
       def refund(money, authorization, options = {})
-        MultiResponse.run do |r|
-          r.process{inquire_request(authorization, options, "CAPTURED", "SETTLED", "SETTLED_BY_MERCHANT")}
-          r.process{refund_request(money, authorization, options)}
+        response = MultiResponse.run do |r|
+          r.process { inquire_request(authorization, options, "CAPTURED", "SETTLED", "SETTLED_BY_MERCHANT") }
+          r.process { refund_request(money, authorization, options) }
         end
+
+        return response if response.success?
+        return response unless options[:force_full_refund_if_unsettled]
+
+        void(authorization, options ) if response.params["last_event"] == "AUTHORISED"
+      end
+
+      # Credits only function on a Merchant ID/login/profile flagged for Payouts
+      #   aka Credit Fund Transfers (CFT), whereas normal purchases, refunds,
+      #   and other transactions should be performed on a normal eCom-flagged
+      #   merchant ID.
+      def credit(money, payment_method, options = {})
+        credit_request(money, payment_method, options.merge(:credit => true))
       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) }
+          r.process(:ignore_result) { void(r.authorization, options.merge(:authorization_validated => true)) }
         end
       end
 
@@ -87,23 +101,27 @@ module ActiveMerchant #:nodoc:
       private
 
       def authorize_request(money, payment_method, options)
-        commit('authorize', build_authorization_request(money, payment_method, options), "AUTHORISED")
+        commit('authorize', build_authorization_request(money, payment_method, options), "AUTHORISED", options)
       end
 
       def capture_request(money, authorization, options)
-        commit('capture', build_capture_request(money, authorization, options), :ok)
+        commit('capture', build_capture_request(money, authorization, options), :ok, options)
       end
 
       def cancel_request(authorization, options)
-        commit('cancel', build_void_request(authorization, options), :ok)
+        commit('cancel', build_void_request(authorization, options), :ok, options)
       end
 
       def inquire_request(authorization, options, *success_criteria)
-        commit('inquiry', build_order_inquiry_request(authorization, options), *success_criteria)
+        commit('inquiry', build_order_inquiry_request(authorization, options), *success_criteria, options)
       end
 
       def refund_request(money, authorization, options)
-        commit('refund', build_refund_request(money, authorization, options), :ok)
+        commit('refund', build_refund_request(money, authorization, options), :ok, options)
+      end
+
+      def credit_request(money, payment_method, options)
+        commit('credit', build_authorization_request(money, payment_method, options), :ok, options)
       end
 
       def build_request
@@ -189,7 +207,7 @@ module ActiveMerchant #:nodoc:
         amount_hash = {
           :value => localized_amount(money, currency),
           'currencyCode' => currency,
-          'exponent' => non_fractional_currency?(currency) ? 0 : 2
+          'exponent' => currency_exponent(currency)
         }
 
         if options[:debit_credit_indicator]
@@ -211,7 +229,7 @@ module ActiveMerchant #:nodoc:
             end
           end
         else
-          xml.tag! 'paymentDetails' do
+          xml.tag! 'paymentDetails', credit_fund_transfer_attribute(options) do
             xml.tag! CARD_CODES[card_brand(payment_method)] do
               xml.tag! 'cardNumber', payment_method.number
               xml.tag! 'expiryDate' do
@@ -223,21 +241,30 @@ module ActiveMerchant #:nodoc:
 
               add_address(xml, (options[:billing_address] || options[:address]))
             end
-            if options[:ip]
-              xml.tag! 'session', 'shopperIPAddress' => options[:ip]
+            if options[:ip] && options[:session_id]
+              xml.tag! 'session', 'shopperIPAddress' => options[:ip], 'id' => options[:session_id]
+            else
+              xml.tag! 'session', 'shopperIPAddress' => options[:ip] if options[:ip]
+              xml.tag! 'session', 'id' => options[:session_id] if options[:session_id]
             end
           end
         end
       end
 
       def add_email(xml, options)
-        return unless options[:email]
+        return unless options[:execute_threed] || options[:email]
         xml.tag! 'shopper' do
-          xml.tag! 'shopperEmailAddress', options[:email]
+          xml.tag! 'shopperEmailAddress', options[:email] if  options[:email]
+          xml.tag! 'browser' do
+            xml.tag! 'acceptHeader', options[:accept_header]
+            xml.tag! 'userAgentHeader', options[:user_agent]
+          end
         end
       end
 
       def add_address(xml, address)
+        return unless address
+
         address = address_with_defaults(address)
 
         xml.tag! 'cardAddress' do
@@ -298,9 +325,24 @@ module ActiveMerchant #:nodoc:
         raw
       end
 
-      def commit(action, request, *success_criteria)
-        xmr = ssl_post(url, request, 'Content-Type' => 'text/xml', 'Authorization' => encoded_credentials)
-        raw = parse(action, xmr)
+      def headers(options)
+        headers = {
+          'Content-Type' => 'text/xml',
+          'Authorization' => encoded_credentials
+        }
+        if options[:cookie]
+          headers.merge!('Set-Cookie' => options[:cookie]) if options[:cookie]
+        end
+        headers
+      end
+
+      def commit(action, request, *success_criteria, options)
+        xml = ssl_post(url, request, headers(options))
+        raw = parse(action, xml)
+        if options[:execute_threed]
+          raw[:cookie] = @cookie
+          raw[:session_id] = options[:session_id]
+        end
         success, message = success_and_message_from(raw, success_criteria)
 
         Response.new(
@@ -323,6 +365,18 @@ module ActiveMerchant #:nodoc:
         test? ? self.test_url : self.live_url
       end
 
+      # Override the regular handle response so we can access the headers
+      # Set-Cookie value is needed for 3DS transactions
+      def handle_response(response)
+        case response.code.to_i
+        when 200...300
+          @cookie = response.response['Set-Cookie']
+          response.body
+        else
+          raise ResponseError.new(response)
+        end
+      end
+
       # success_criteria can be:
       #   - a string or an array of strings (if one of many responses)
       #   - An array of strings if one of many responses could be considered a
@@ -355,10 +409,21 @@ module ActiveMerchant #:nodoc:
         (pair ? pair.last : nil)
       end
 
+      def credit_fund_transfer_attribute(options)
+        return unless options[:credit]
+        {'action' => "REFUND"}
+      end
+
       def encoded_credentials
         credentials = "#{@options[:login]}:#{@options[:password]}"
         "Basic #{[credentials].pack('m').strip}"
       end
+
+      def currency_exponent(currency)
+        return 0 if non_fractional_currency?(currency)
+        return 3 if three_decimal_currency?(currency)
+        return 2
+      end
     end
   end
 end